gobby 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/install/cursor/hooks/hook_dispatcher.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Hook Dispatcher - Routes Cursor hooks to HookManager.
+
+This is a thin wrapper script that receives hook calls from Cursor
+and routes them to the appropriate handler via HookManager.
+
+Usage:
+    hook_dispatcher.py --type sessionStart < input.json > output.json
+    hook_dispatcher.py --type preToolUse --debug < input.json > output.json
+
+Exit Codes:
+    0 - Success
+    1 - General error (logged, continues)
+    2 - Block action (Cursor interprets as deny)
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Default daemon configuration
+DEFAULT_DAEMON_PORT = 60887
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+
+
+def get_daemon_url() -> str:
+    """Get the daemon HTTP URL from config file."""
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    if config_path.exists():
+        try:
+            import yaml
+
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+            port = config.get("daemon_port", DEFAULT_DAEMON_PORT)
+        except Exception:
+            port = DEFAULT_DAEMON_PORT
+    else:
+        port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def get_terminal_context() -> dict[str, str | int | None]:
+    """Capture terminal/process context for session correlation."""
+    context: dict[str, str | int | None] = {}
+
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+    context["vscode_terminal_id"] = os.environ.get("VSCODE_GIT_ASKPASS_NODE")
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Cursor Hook Dispatcher")
+    parser.add_argument(
+        "--type",
+        required=True,
+        help="Hook type (e.g., sessionStart, preToolUse)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+def check_daemon_running(timeout: float = 0.5) -> bool:
+    """Check if gobby daemon is active and responding."""
+    try:
+        import httpx
+
+        daemon_url = get_daemon_url()
+        response = httpx.get(
+            f"{daemon_url}/admin/status",
+            timeout=timeout,
+            follow_redirects=False,
+        )
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def main() -> int:
+    """Main dispatcher execution."""
+    try:
+        args = parse_arguments()
+    except (argparse.ArgumentError, SystemExit):
+        print(json.dumps({}))
+        return 2
+
+    hook_type = args.type
+    debug_mode = args.debug
+
+    # Check if daemon is running
+    if not check_daemon_running():
+        critical_hooks = {"sessionStart", "sessionEnd", "preCompact"}
+        if hook_type in critical_hooks:
+            print(
+                f"Gobby daemon is not running. Start with 'gobby start' before continuing. "
+                f"({hook_type} requires daemon for session state management)",
+                file=sys.stderr,
+            )
+            return 2
+        else:
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0
+
+    import logging
+
+    logger = logging.getLogger("gobby.hooks.dispatcher.cursor")
+    if debug_mode:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING, handlers=[])
+
+    try:
+        input_data = json.load(sys.stdin)
+
+        if hook_type == "sessionStart":
+            input_data["terminal_context"] = get_terminal_context()
+
+        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+
+        if debug_mode:
+            logger.debug(f"Input data: {input_data}")
+
+    except json.JSONDecodeError as e:
+        if debug_mode:
+            logger.error(f"JSON decode error: {e}")
+        print(json.dumps({}))
+        return 2
+
+    import httpx
+
+    daemon_url = get_daemon_url()
+    try:
+        response = httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": hook_type,
+                "input_data": input_data,
+                "source": "cursor",
+            },
+            timeout=90.0,
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+
+            if debug_mode:
+                logger.debug(f"Output data: {result}")
+
+            # Check for block decision
+            if result.get("continue") is False or result.get("decision") == "deny":
+                reason = result.get("user_message") or result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            if result and result != {}:
+                print(json.dumps(result))
+
+            return 0
+        else:
+            error_detail = response.text
+            logger.error(
+                f"Daemon returned error: status={response.status_code}, detail={error_detail}"
+            )
+            print(json.dumps({"status": "error", "message": f"Daemon error: {error_detail}"}))
+            return 1
+
+    except Exception as e:
+        logger.error(f"Hook execution failed: {e}", exc_info=True)
+        print(json.dumps({"status": "error", "message": str(e)}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -108,6 +108,14 @@ def get_terminal_context() -> dict[str, str | int | bool | None]:
     # Generic terminal program identifier (set by many terminals)
     context["term_program"] = os.environ.get("TERM_PROGRAM")
 
+    # Gobby session context (set when spawned by Gobby)
+    # These allow the daemon to link this Gemini session to a pre-created Gobby session
+    context["gobby_session_id"] = os.environ.get("GOBBY_SESSION_ID")
+    context["gobby_parent_session_id"] = os.environ.get("GOBBY_PARENT_SESSION_ID")
+    context["gobby_agent_run_id"] = os.environ.get("GOBBY_AGENT_RUN_ID")
+    context["gobby_project_id"] = os.environ.get("GOBBY_PROJECT_ID")
+    context["gobby_workflow_name"] = os.environ.get("GOBBY_WORKFLOW_NAME")
+
     return context
 
 

gobby/install/windsurf/hooks/hook_dispatcher.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""Hook Dispatcher - Routes Windsurf (Cascade) hooks to HookManager.
+
+This is a thin wrapper script that receives hook calls from Windsurf
+and routes them to the appropriate handler via HookManager.
+
+Usage:
+    hook_dispatcher.py --type pre_user_prompt < input.json > output.json
+    hook_dispatcher.py --type pre_run_command --debug < input.json > output.json
+
+Exit Codes:
+    0 - Success
+    1 - General error (logged, continues)
+    2 - Block action (Windsurf interprets as deny)
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Default daemon configuration
+DEFAULT_DAEMON_PORT = 60887
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+
+
+def get_daemon_url() -> str:
+    """Get the daemon HTTP URL from config file."""
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    if config_path.exists():
+        try:
+            import yaml
+
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+            port = config.get("daemon_port", DEFAULT_DAEMON_PORT)
+        except Exception:
+            port = DEFAULT_DAEMON_PORT
+    else:
+        port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def get_terminal_context() -> dict[str, str | int | None]:
+    """Capture terminal/process context for session correlation."""
+    context: dict[str, str | int | None] = {}
+
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+    context["vscode_terminal_id"] = os.environ.get("VSCODE_GIT_ASKPASS_NODE")
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Windsurf Hook Dispatcher")
+    parser.add_argument(
+        "--type",
+        required=True,
+        help="Hook type (e.g., pre_user_prompt, pre_run_command)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+def check_daemon_running(timeout: float = 0.5) -> bool:
+    """Check if gobby daemon is active and responding."""
+    try:
+        import httpx
+
+        daemon_url = get_daemon_url()
+        response = httpx.get(
+            f"{daemon_url}/admin/status",
+            timeout=timeout,
+            follow_redirects=False,
+        )
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def main() -> int:
+    """Main dispatcher execution."""
+    try:
+        args = parse_arguments()
+    except (argparse.ArgumentError, SystemExit):
+        print(json.dumps({}))
+        return 2
+
+    hook_type = args.type
+    debug_mode = args.debug
+
+    # Check if daemon is running
+    # Note: Windsurf doesn't have explicit session start/end, so pre_user_prompt is critical
+    if not check_daemon_running():
+        critical_hooks = {"pre_user_prompt"}
+        if hook_type in critical_hooks:
+            print(
+                f"Gobby daemon is not running. Start with 'gobby start' before continuing. "
+                f"({hook_type} requires daemon for session state management)",
+                file=sys.stderr,
+            )
+            return 2
+        else:
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0
+
+    import logging
+
+    logger = logging.getLogger("gobby.hooks.dispatcher.windsurf")
+    if debug_mode:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING, handlers=[])
+
+    try:
+        input_data = json.load(sys.stdin)
+
+        # Inject terminal context for first prompt (acts as session start)
+        if hook_type == "pre_user_prompt":
+            input_data["terminal_context"] = get_terminal_context()
+
+        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+
+        if debug_mode:
+            logger.debug(f"Input data: {input_data}")
+
+    except json.JSONDecodeError as e:
+        if debug_mode:
+            logger.error(f"JSON decode error: {e}")
+        print(json.dumps({}))
+        return 2
+
+    import httpx
+
+    daemon_url = get_daemon_url()
+    try:
+        response = httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": hook_type,
+                "input_data": input_data,
+                "source": "windsurf",
+            },
+            timeout=90.0,
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+
+            if debug_mode:
+                logger.debug(f"Output data: {result}")
+
+            # Check for block decision
+            if result.get("decision") == "deny":
+                reason = result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            if result and result != {}:
+                print(json.dumps(result))
+
+            return 0
+        else:
+            error_detail = response.text
+            logger.error(
+                f"Daemon returned error: status={response.status_code}, detail={error_detail}"
+            )
+            print(json.dumps({"status": "error", "message": f"Daemon error: {error_detail}"}))
+            return 1
+
+    except Exception as e:
+        logger.error(f"Hook execution failed: {e}", exc_info=True)
+        print(json.dumps({"status": "error", "message": str(e)}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gobby/llm/__init__.py

@@ -10,7 +10,15 @@ Usage:
 """
 
 from gobby.llm.base import AuthMode, LLMProvider
-from gobby.llm.claude import MCPToolResult, ToolCall
+from gobby.llm.claude import (
+    ChatEvent,
+    DoneEvent,
+    MCPToolResult,
+    TextChunk,
+    ToolCall,
+    ToolCallEvent,
+    ToolResultEvent,
+)
 from gobby.llm.claude_executor import ClaudeExecutor
 from gobby.llm.executor import (
     AgentExecutor,
@@ -27,14 +35,19 @@ __all__ = [
     "AgentExecutor",
     "AgentResult",
     "AuthMode",
+    "ChatEvent",
     "ClaudeExecutor",
+    "DoneEvent",
     "LLMProvider",
     "LLMService",
     "MCPToolResult",
+    "TextChunk",
     "ToolCall",
+    "ToolCallEvent",
     "ToolCallRecord",
     "ToolHandler",
     "ToolResult",
+    "ToolResultEvent",
     "ToolSchema",
     "create_llm_service",
 ]

gobby/llm/claude.py

@@ -12,6 +12,7 @@ import logging
 import os
 import shutil
 import time
+from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
 from typing import Any, Literal, cast
 
@@ -62,6 +63,67 @@ class MCPToolResult:
     """List of tool calls made during generation."""
 
 
+# Streaming event types for stream_with_mcp_tools
+@dataclass
+class TextChunk:
+    """A chunk of text from the streaming response."""
+
+    content: str
+    """The text content."""
+
+
+@dataclass
+class ToolCallEvent:
+    """Event when a tool is being called."""
+
+    tool_call_id: str
+    """Unique ID for this tool call."""
+
+    tool_name: str
+    """Full tool name (e.g., mcp__gobby-tasks__create_task)."""
+
+    server_name: str
+    """Extracted server name (e.g., gobby-tasks)."""
+
+    arguments: dict[str, Any]
+    """Arguments passed to the tool."""
+
+
+@dataclass
+class ToolResultEvent:
+    """Event when a tool call completes."""
+
+    tool_call_id: str
+    """ID matching the original ToolCallEvent."""
+
+    success: bool
+    """Whether the tool call succeeded."""
+
+    result: Any = None
+    """Result data if successful."""
+
+    error: str | None = None
+    """Error message if failed."""
+
+
+@dataclass
+class DoneEvent:
+    """Event when streaming is complete."""
+
+    tool_calls_count: int
+    """Total number of tool calls made."""
+
+    cost_usd: float | None = None
+    """Cost in USD if available."""
+
+    duration_ms: float | None = None
+    """Duration in milliseconds if available."""
+
+
+# Union type for all streaming events
+ChatEvent = TextChunk | ToolCallEvent | ToolResultEvent | DoneEvent
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -661,7 +723,7 @@ class ClaudeLLMProvider(LLMProvider):
                 parts = full_tool_name.split("__")
                 if len(parts) >= 2:
                     return parts[1]
-            return "unknown"
+            return "builtin"
 
         # Run async query
         async def _run_query() -> str:
@@ -727,6 +789,160 @@ class ClaudeLLMProvider(LLMProvider):
                 tool_calls=tool_calls,
             )
 
+    async def stream_with_mcp_tools(
+        self,
+        prompt: str,
+        allowed_tools: list[str],
+        system_prompt: str | None = None,
+        model: str | None = None,
+        max_turns: int = 10,
+    ) -> AsyncIterator[ChatEvent]:
+        """
+        Stream generation with MCP tools, yielding events as they occur.
+
+        This method enables real-time streaming of text and tool call events
+        during multi-turn agent conversations. Unlike generate_with_mcp_tools(),
+        this yields events incrementally rather than waiting for completion.
+
+        Note: This method requires subscription mode (Claude Agent SDK).
+
+        Args:
+            prompt: User prompt to process.
+            allowed_tools: List of allowed MCP tool patterns.
+                Tools should be in format "mcp__{server}__{tool}" or patterns
+                like "mcp__gobby-tasks__*" for all tools from a server.
+            system_prompt: Optional system prompt.
+            model: Optional model override (default: claude-sonnet-4-5).
+            max_turns: Maximum number of agentic turns (default: 10).
+
+        Yields:
+            ChatEvent: One of TextChunk, ToolCallEvent, ToolResultEvent, or DoneEvent.
+
+        Example:
+            >>> async for event in provider.stream_with_mcp_tools(
+            ...     prompt="Create a task called 'Fix bug'",
+            ...     allowed_tools=["mcp__gobby-tasks__*"],
+            ... ):
+            ...     if isinstance(event, TextChunk):
+            ...         print(event.content, end="")
+            ...     elif isinstance(event, ToolCallEvent):
+            ...         print(f"Calling {event.tool_name}...")
+        """
+        # MCP tools require subscription mode (Claude Agent SDK)
+        if self._auth_mode == "api_key":
+            yield TextChunk(
+                content="MCP tools require subscription mode. "
+                "Set auth_mode: subscription in llm_providers.claude config."
+            )
+            yield DoneEvent(tool_calls_count=0)
+            return
+
+        cli_path = self._verify_cli_path()
+        if not cli_path:
+            yield TextChunk(content="Generation unavailable (Claude CLI not found)")
+            yield DoneEvent(tool_calls_count=0)
+            return
+
+        # Build mcp_servers config - use .mcp.json if gobby tools requested
+        from pathlib import Path
+
+        mcp_servers_config: dict[str, Any] | str | None = None
+
+        if any("gobby" in t for t in allowed_tools):
+            cwd_config = Path.cwd() / ".mcp.json"
+            if cwd_config.exists():
+                mcp_servers_config = str(cwd_config)
+            else:
+                gobby_root = Path(__file__).parent.parent.parent.parent
+                gobby_config = gobby_root / ".mcp.json"
+                if gobby_config.exists():
+                    mcp_servers_config = str(gobby_config)
+
+        # Configure Claude Agent SDK with MCP tools
+        options = ClaudeAgentOptions(
+            system_prompt=system_prompt
+            or "You are Gobby, a helpful assistant with access to tools.",
+            max_turns=max_turns,
+            model=model or "claude-sonnet-4-5",
+            allowed_tools=allowed_tools,
+            permission_mode="bypassPermissions",
+            cli_path=cli_path,
+            mcp_servers=mcp_servers_config if mcp_servers_config is not None else {},
+        )
+
+        def _parse_server_name(full_tool_name: str) -> str:
+            """Extract server name from mcp__{server}__{tool} format."""
+            if full_tool_name.startswith("mcp__"):
+                parts = full_tool_name.split("__")
+                if len(parts) >= 2:
+                    return parts[1]
+            return "builtin"
+
+        tool_calls_count = 0
+        pending_tool_calls: dict[str, str] = {}  # Map tool_use_id -> tool_name
+        needs_spacing_before_text = False  # Track if we need spacing before text
+
+        try:
+            async for message in query(prompt=prompt, options=options):
+                if isinstance(message, ResultMessage):
+                    # Final result - extract metadata
+                    cost_usd = getattr(message, "total_cost_usd", None)
+                    duration_ms = getattr(message, "duration_ms", None)
+                    yield DoneEvent(
+                        tool_calls_count=tool_calls_count,
+                        cost_usd=cost_usd,
+                        duration_ms=duration_ms,
+                    )
+
+                elif isinstance(message, AssistantMessage):
+                    for block in message.content:
+                        if isinstance(block, TextBlock):
+                            # Add spacing before text that follows tool calls/results
+                            # This ensures proper paragraph separation in the UI
+                            text = block.text
+                            if needs_spacing_before_text and text:
+                                # Ensure we have a proper paragraph break (double newline)
+                                # even if the text starts with a single newline
+                                text = text.lstrip("\n")
+                                if text:
+                                    text = "\n\n" + text
+                            yield TextChunk(content=text)
+                            needs_spacing_before_text = False
+                        elif isinstance(block, ToolUseBlock):
+                            tool_calls_count += 1
+                            server_name = _parse_server_name(block.name)
+                            pending_tool_calls[block.id] = block.name
+                            yield ToolCallEvent(
+                                tool_call_id=block.id,
+                                tool_name=block.name,
+                                server_name=server_name,
+                                arguments=block.input if isinstance(block.input, dict) else {},
+                            )
+
+                elif isinstance(message, UserMessage):
+                    # UserMessage may contain tool results
+                    if isinstance(message.content, list):
+                        for block in message.content:
+                            if isinstance(block, ToolResultBlock):
+                                # Determine success based on is_error attribute
+                                is_error = getattr(block, "is_error", False)
+                                yield ToolResultEvent(
+                                    tool_call_id=block.tool_use_id,
+                                    success=not is_error,
+                                    result=block.content if not is_error else None,
+                                    error=str(block.content) if is_error else None,
+                                )
+                                needs_spacing_before_text = True
+
+        except ExceptionGroup as eg:
+            errors = [f"{type(exc).__name__}: {exc}" for exc in eg.exceptions]
+            yield TextChunk(content=f"Generation failed: {'; '.join(errors)}")
+            yield DoneEvent(tool_calls_count=tool_calls_count)
+        except Exception as e:
+            self.logger.error(f"Failed to stream with MCP tools: {e}", exc_info=True)
+            yield TextChunk(content=f"Generation failed: {e}")
+            yield DoneEvent(tool_calls_count=tool_calls_count)
+
     async def describe_image(
         self,
         image_path: str,