gobby 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -26,11 +26,12 @@ Exit Codes:
 
 import argparse
 import json
+import os
 import sys
 from pathlib import Path
 
 # Default daemon configuration
-DEFAULT_DAEMON_PORT = 8765
+DEFAULT_DAEMON_PORT = 60887
 DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
 
 
@@ -38,10 +39,10 @@ def get_daemon_url() -> str:
     """Get the daemon HTTP URL from config file.
 
     Reads daemon_port from ~/.gobby/config.yaml if it exists,
-    otherwise uses the default port 8765.
+    otherwise uses the default port 60887.
 
     Returns:
-        Full daemon URL like http://localhost:8765
+        Full daemon URL like http://localhost:60887
     """
     config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
 
@@ -61,6 +62,55 @@ def get_daemon_url() -> str:
     return f"http://localhost:{port}"
 
 
+def get_terminal_context() -> dict[str, str | int | bool | None]:
+    """Capture terminal/process context for session correlation.
+
+    Returns:
+        Dict with terminal identifiers (values may be None if unavailable)
+    """
+    context: dict[str, str | int | bool | None] = {}
+
+    # Parent process ID (shell or Gemini process)
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    # TTY device name
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    # macOS Terminal.app session ID
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+
+    # iTerm2 session ID
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+
+    # VS Code integrated terminal detection
+    # VSCODE_IPC_HOOK_CLI is set when running in VS Code's integrated terminal
+    # TERM_PROGRAM == "vscode" is also a reliable indicator
+    vscode_ipc_hook = os.environ.get("VSCODE_IPC_HOOK_CLI")
+    term_program = os.environ.get("TERM_PROGRAM")
+    context["vscode_ipc_hook_cli"] = vscode_ipc_hook
+    context["vscode_terminal_detected"] = bool(vscode_ipc_hook) or term_program == "vscode"
+
+    # Tmux pane (if running in tmux)
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+
+    # Kitty terminal window ID
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+
+    # Alacritty IPC socket path (unique per instance)
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+
+    # Generic terminal program identifier (set by many terminals)
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
 def parse_arguments() -> argparse.Namespace:
     """Parse command line arguments.
 
@@ -128,11 +178,26 @@ def main() -> int:
 
     # Check if gobby daemon is running before processing hooks
     if not check_daemon_running():
-        # Daemon is not running - return gracefully without processing
-        print(
-            json.dumps({"status": "daemon_not_running", "message": "gobby daemon is not running"})
-        )
-        return 0  # Exit 0 (allow) - this is expected behavior, not an error
+        # Critical hooks that manage session state MUST have daemon running
+        # Per Gemini CLI docs: SessionEnd, Notification, PreCompress are async/non-blocking
+        # Only SessionStart is critical for session initialization
+        critical_hooks = {"SessionStart"}
+        if hook_type in critical_hooks:
+            # Block the hook - forces user to start daemon before critical lifecycle events
+            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  # Exit 2 = block operation
+        else:
+            # Non-critical hooks can proceed without daemon
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0  # Exit 0 (allow) - allow operation to continue
 
     # Setup logger for dispatcher (not HookManager)
     import logging
@@ -147,6 +212,11 @@ def main() -> int:
         # Read JSON input from stdin
         input_data = json.load(sys.stdin)
 
+        # Inject terminal context for SessionStart hooks
+        # This captures the terminal/process info for session correlation
+        if hook_type == "SessionStart":
+            input_data["terminal_context"] = get_terminal_context()
+
         # Log what Gemini CLI sends us (for debugging hook data issues)
         logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
 
@@ -228,13 +298,18 @@ def main() -> int:
             # Determine exit code based on decision
             decision = result.get("decision", "allow")
 
-            # Print JSON output for Gemini CLI
+            # Check for block/deny decision - return exit code 2 to signal blocking
+            # For blocking, output goes to STDERR (Gemini reads stderr on exit 2)
+            if result.get("continue") is False or decision in ("deny", "block"):
+                # Output just the reason, not the full JSON
+                reason = result.get("stopReason") or result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            # Only print output if there's something meaningful to show
             if result and result != {}:
                 print(json.dumps(result))
 
-            # Exit code: 0 = allow, 2 = deny
-            if decision == "deny":
-                return 2
             return 0
         else:
             # HTTP error from daemon

gobby/llm/claude.py

@@ -495,7 +495,7 @@ class ClaudeLLMProvider(LLMProvider):
         """
         Generate a text description of an image using Claude's vision capabilities.
 
-        Uses the Anthropic API directly for vision support.
+        Uses LiteLLM for unified cost tracking with anthropic/claude-haiku-4-5 model.
 
         Args:
             image_path: Path to the image file to describe
@@ -508,8 +508,6 @@ class ClaudeLLMProvider(LLMProvider):
         import mimetypes
         from pathlib import Path
 
-        import anthropic
-
         # Validate image exists
         path = Path(image_path)
         if not path.exists():
@@ -534,45 +532,35 @@ class ClaudeLLMProvider(LLMProvider):
         if context:
             prompt = f"{context}\n\n{prompt}"
 
-        # Use Anthropic API for vision
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
-        if not api_key:
-            return "Image description unavailable (ANTHROPIC_API_KEY not set)"
-
+        # Use LiteLLM for unified cost tracking
         try:
-            client = anthropic.AsyncAnthropic(api_key=api_key)
-            # Type annotation to satisfy mypy
-            image_block: anthropic.types.ImageBlockParam = {
-                "type": "image",
-                "source": {
-                    "type": "base64",
-                    "media_type": mime_type,  # type: ignore[typeddict-item]
-                    "data": image_base64,
-                },
-            }
-            text_block: anthropic.types.TextBlockParam = {
-                "type": "text",
-                "text": prompt,
-            }
-            message = await client.messages.create(
-                model="claude-haiku-4-5-latest",  # Use haiku for cost efficiency
-                max_tokens=1024,
+            import litellm
+
+            # Route through LiteLLM with anthropic prefix for cost tracking
+            response = await litellm.acompletion(
+                model="anthropic/claude-haiku-4-5-20251001",  # Use haiku for cost efficiency
                 messages=[
                     {
                         "role": "user",
-                        "content": [image_block, text_block],
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": f"data:{mime_type};base64,{image_base64}"},
+                            },
+                        ],
                     }
                 ],
+                max_tokens=1024,
             )
 
-            # Extract text from response
-            result = ""
-            for block in message.content:
-                if hasattr(block, "text"):
-                    result += block.text
-
-            return result if result else "No description generated"
+            if not response or not getattr(response, "choices", None):
+                return "No description generated"
+            return response.choices[0].message.content or "No description generated"
 
+        except ImportError:
+            self.logger.error("LiteLLM not installed, falling back to unavailable")
+            return "Image description unavailable (LiteLLM not installed)"
         except Exception as e:
-            self.logger.error(f"Failed to describe image with Claude: {e}")
+            self.logger.error(f"Failed to describe image with Claude via LiteLLM: {e}")
             return f"Image description failed: {e}"

gobby/llm/claude_executor.py

@@ -1,22 +1,20 @@
 """
-Claude implementation of AgentExecutor.
+Claude implementation of AgentExecutor for subscription mode only.
 
-Supports multiple auth modes:
-- api_key: Direct Anthropic API with API key
-- subscription: Claude Agent SDK with CLI (Pro/Team subscriptions)
+This executor uses the Claude Agent SDK with CLI for Pro/Team subscriptions.
+
+Note: api_key mode is now routed through LiteLLMExecutor for unified cost tracking.
+Use the resolver.create_executor() function which handles routing automatically.
 """
 
 import asyncio
 import concurrent.futures
 import json
 import logging
-import os
 import shutil
 from collections.abc import Callable
 from typing import Any, Literal
 
-import anthropic
-
 from gobby.llm.executor import (
     AgentExecutor,
     AgentResult,
@@ -28,26 +26,28 @@ from gobby.llm.executor import (
 
 logger = logging.getLogger(__name__)
 
-# Auth mode type
-ClaudeAuthMode = Literal["api_key", "subscription"]
+# Auth mode type - subscription only, api_key routes through LiteLLM
+ClaudeAuthMode = Literal["subscription"]
 
 
 class ClaudeExecutor(AgentExecutor):
     """
-    Claude implementation of AgentExecutor.
+    Claude implementation of AgentExecutor for subscription mode only.
+
+    Uses Claude Agent SDK with CLI for Pro/Team subscriptions. This executor
+    is for subscription-based authentication only.
 
-    Supports two authentication modes:
-    - api_key: Uses the Anthropic API directly with an API key
-    - subscription: Uses Claude Agent SDK with CLI for Pro/Team subscriptions
+    For api_key mode, use LiteLLMExecutor with provider="claude" which routes
+    through anthropic/model-name for unified cost tracking.
 
     The executor implements a proper agentic loop:
-    1. Send prompt to Claude with tool schemas
+    1. Send prompt to Claude with tool schemas via SDK
     2. When Claude requests a tool, call tool_handler
     3. Send tool result back to Claude
     4. Repeat until Claude stops requesting tools or limits are reached
 
     Example:
-        >>> executor = ClaudeExecutor(auth_mode="api_key", api_key="sk-ant-...")
+        >>> executor = ClaudeExecutor(auth_mode="subscription")
         >>> result = await executor.run(
         ...     prompt="Create a task",
         ...     tools=[ToolSchema(name="create_task", ...)],
@@ -55,71 +55,47 @@ class ClaudeExecutor(AgentExecutor):
         ... )
     """
 
-    _client: anthropic.AsyncAnthropic | None
     _cli_path: str
 
     def __init__(
         self,
-        auth_mode: ClaudeAuthMode = "api_key",
-        api_key: str | None = None,
+        auth_mode: ClaudeAuthMode = "subscription",
         default_model: str = "claude-sonnet-4-20250514",
     ):
         """
-        Initialize ClaudeExecutor.
+        Initialize ClaudeExecutor for subscription mode.
 
         Args:
-            auth_mode: Authentication mode ("api_key" or "subscription").
-            api_key: Anthropic API key (required for api_key mode).
+            auth_mode: Must be "subscription". API key mode is handled by LiteLLMExecutor.
             default_model: Default model to use if not specified in run().
+
+        Raises:
+            ValueError: If auth_mode is not "subscription" or Claude CLI not found.
         """
+        if auth_mode != "subscription":
+            raise ValueError(
+                "ClaudeExecutor only supports subscription mode. "
+                "For api_key mode, use LiteLLMExecutor with provider='claude'."
+            )
+
         self.auth_mode = auth_mode
         self.default_model = default_model
         self.logger = logger
-        self._client = None
         self._cli_path = ""
 
-        if auth_mode == "api_key":
-            # Use provided key or fall back to environment variable
-            key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-            if not key:
-                raise ValueError(
-                    "API key required for api_key mode. "
-                    "Provide api_key parameter or set ANTHROPIC_API_KEY env var."
-                )
-            self._client = anthropic.AsyncAnthropic(api_key=key)
-        elif auth_mode == "subscription":
-            # Verify Claude CLI is available for subscription mode
-            cli_path = shutil.which("claude")
-            if not cli_path:
-                raise ValueError(
-                    "Claude CLI not found in PATH. Install Claude Code for subscription mode."
-                )
-            self._cli_path = cli_path
-        else:
-            raise ValueError(f"Unknown auth_mode: {auth_mode}")
+        # Verify Claude CLI is available for subscription mode
+        cli_path = shutil.which("claude")
+        if not cli_path:
+            raise ValueError(
+                "Claude CLI not found in PATH. Install Claude Code for subscription mode."
+            )
+        self._cli_path = cli_path
 
     @property
     def provider_name(self) -> str:
         """Return the provider name."""
         return "claude"
 
-    def _convert_tools_to_anthropic_format(
-        self, tools: list[ToolSchema]
-    ) -> list[anthropic.types.ToolParam]:
-        """Convert ToolSchema list to Anthropic API format."""
-        anthropic_tools: list[anthropic.types.ToolParam] = []
-        for tool in tools:
-            # input_schema must have "type": "object" at minimum
-            input_schema: dict[str, Any] = {"type": "object", **tool.input_schema}
-            anthropic_tools.append(
-                {
-                    "name": tool.name,
-                    "description": tool.description,
-                    "input_schema": input_schema,
-                }
-            )
-        return anthropic_tools
-
     async def run(
         self,
         prompt: str,
@@ -131,10 +107,10 @@ class ClaudeExecutor(AgentExecutor):
         timeout: float = 120.0,
     ) -> AgentResult:
         """
-        Execute an agentic loop with tool calling.
+        Execute an agentic loop with tool calling via Claude Agent SDK.
 
-        Runs Claude with the given prompt, calling tools via tool_handler
-        until completion, max_turns, or timeout.
+        Runs Claude with the given prompt using subscription-based authentication,
+        calling tools via tool_handler until completion, max_turns, or timeout.
 
         Args:
             prompt: The user prompt to process.
@@ -148,201 +124,15 @@ class ClaudeExecutor(AgentExecutor):
         Returns:
             AgentResult with output, status, and tool call records.
         """
-        if self.auth_mode == "api_key":
-            return await self._run_with_api(
-                prompt=prompt,
-                tools=tools,
-                tool_handler=tool_handler,
-                system_prompt=system_prompt,
-                model=model or self.default_model,
-                max_turns=max_turns,
-                timeout=timeout,
-            )
-        else:
-            return await self._run_with_sdk(
-                prompt=prompt,
-                tools=tools,
-                tool_handler=tool_handler,
-                system_prompt=system_prompt,
-                model=model or self.default_model,
-                max_turns=max_turns,
-                timeout=timeout,
-            )
-
-    async def _run_with_api(
-        self,
-        prompt: str,
-        tools: list[ToolSchema],
-        tool_handler: ToolHandler,
-        system_prompt: str | None,
-        model: str,
-        max_turns: int,
-        timeout: float,
-    ) -> AgentResult:
-        """Run using direct Anthropic API."""
-        if self._client is None:
-            return AgentResult(
-                output="",
-                status="error",
-                error="Anthropic client not initialized",
-                turns_used=0,
-            )
-
-        tool_calls: list[ToolCallRecord] = []
-        anthropic_tools = self._convert_tools_to_anthropic_format(tools)
-
-        # Build initial messages
-        messages: list[anthropic.types.MessageParam] = [{"role": "user", "content": prompt}]
-
-        # Track turns in outer scope so timeout handler can access the count
-        turns_counter = [0]
-
-        async def _run_loop() -> AgentResult:
-            nonlocal messages
-            turns_used = 0
-            final_output = ""
-            client = self._client
-            if client is None:
-                raise RuntimeError("ClaudeExecutor client not initialized")
-
-            while turns_used < max_turns:
-                turns_used += 1
-                turns_counter[0] = turns_used
-
-                # Call Claude
-                try:
-                    response = await client.messages.create(
-                        model=model,
-                        max_tokens=8192,
-                        system=system_prompt or "You are a helpful assistant.",
-                        messages=messages,
-                        tools=anthropic_tools if anthropic_tools else [],
-                    )
-                except anthropic.APIError as e:
-                    return AgentResult(
-                        output="",
-                        status="error",
-                        tool_calls=tool_calls,
-                        error=f"Anthropic API error: {e}",
-                        turns_used=turns_used,
-                    )
-
-                # Process response
-                assistant_content: list[anthropic.types.ContentBlockParam] = []
-                tool_use_blocks: list[dict[str, Any]] = []
-
-                for block in response.content:
-                    if block.type == "text":
-                        final_output = block.text
-                        assistant_content.append({"type": "text", "text": block.text})
-                    elif block.type == "tool_use":
-                        tool_use_blocks.append(
-                            {
-                                "id": block.id,
-                                "name": block.name,
-                                "input": block.input,
-                            }
-                        )
-                        assistant_content.append(
-                            {
-                                "type": "tool_use",
-                                "id": block.id,
-                                "name": block.name,
-                                "input": dict(block.input) if block.input else {},
-                            }
-                        )
-
-                # Add assistant message to history
-                messages.append({"role": "assistant", "content": assistant_content})
-
-                # If no tool use, we're done
-                if not tool_use_blocks:
-                    return AgentResult(
-                        output=final_output,
-                        status="success",
-                        tool_calls=tool_calls,
-                        turns_used=turns_used,
-                    )
-
-                # Handle tool calls
-                tool_results: list[anthropic.types.ToolResultBlockParam] = []
-
-                for tool_use in tool_use_blocks:
-                    tool_name = tool_use["name"]
-                    arguments = tool_use["input"] if isinstance(tool_use["input"], dict) else {}
-
-                    # Record the tool call
-                    record = ToolCallRecord(
-                        tool_name=tool_name,
-                        arguments=arguments,
-                    )
-                    tool_calls.append(record)
-
-                    # Execute via handler
-                    try:
-                        result = await tool_handler(tool_name, arguments)
-                        record.result = result
-
-                        # Format result for Claude
-                        if result.success:
-                            content = json.dumps(result.result) if result.result else "Success"
-                        else:
-                            content = f"Error: {result.error}"
-
-                        tool_results.append(
-                            {
-                                "type": "tool_result",
-                                "tool_use_id": tool_use["id"],
-                                "content": content,
-                            }
-                        )
-                    except Exception as e:
-                        self.logger.error(f"Tool handler error for {tool_name}: {e}")
-                        record.result = ToolResult(
-                            tool_name=tool_name,
-                            success=False,
-                            error=str(e),
-                        )
-                        tool_results.append(
-                            {
-                                "type": "tool_result",
-                                "tool_use_id": tool_use["id"],
-                                "content": f"Error: {e}",
-                                "is_error": True,
-                            }
-                        )
-
-                # Add tool results to messages
-                messages.append({"role": "user", "content": tool_results})
-
-                # Check stop reason
-                if response.stop_reason == "end_turn":
-                    return AgentResult(
-                        output=final_output,
-                        status="success",
-                        tool_calls=tool_calls,
-                        turns_used=turns_used,
-                    )
-
-            # Max turns reached
-            return AgentResult(
-                output=final_output,
-                status="partial",
-                tool_calls=tool_calls,
-                turns_used=turns_used,
-            )
-
-        # Run with timeout
-        try:
-            return await asyncio.wait_for(_run_loop(), timeout=timeout)
-        except TimeoutError:
-            return AgentResult(
-                output="",
-                status="timeout",
-                tool_calls=tool_calls,
-                error=f"Execution timed out after {timeout}s",
-                turns_used=turns_counter[0],
-            )
+        return await self._run_with_sdk(
+            prompt=prompt,
+            tools=tools,
+            tool_handler=tool_handler,
+            system_prompt=system_prompt,
+            model=model or self.default_model,
+            max_turns=max_turns,
+            timeout=timeout,
+        )
 
     async def _run_with_sdk(
         self,