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

gobby/adapters/claude_code.py

@@ -104,6 +104,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         is_failure = hook_type == "post-tool-use-failure"
         metadata = {"is_failure": is_failure} if is_failure else {}
 
+        # Normalize event data for CLI-agnostic processing
+        # This allows downstream code to use consistent field names
+        normalized_data = self._normalize_event_data(input_data)
+
         return HookEvent(
             event_type=event_type,
             session_id=session_id,
@@ -111,10 +115,46 @@ class ClaudeCodeAdapter(BaseAdapter):
             timestamp=datetime.now(UTC),
             machine_id=input_data.get("machine_id"),
             cwd=input_data.get("cwd"),
-            data=input_data,
+            data=normalized_data,
             metadata=metadata,
         )
 
+    def _normalize_event_data(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """Normalize Claude Code event data for CLI-agnostic processing.
+
+        This method enriches the input_data with normalized fields so downstream
+        code doesn't need to handle Claude-specific formats.
+
+        Normalizations performed:
+        1. tool_input.server_name/tool_name → mcp_server/mcp_tool (for MCP calls)
+        2. tool_result → tool_output
+
+        Args:
+            input_data: Raw input data from Claude Code
+
+        Returns:
+            Enriched data dict with normalized fields added
+        """
+        # Start with a copy to avoid mutating original
+        data = dict(input_data)
+
+        # Get tool info
+        tool_name = data.get("tool_name", "")
+        tool_input = data.get("tool_input", {}) or {}
+
+        # 1. Extract MCP info from nested tool_input for call_tool calls
+        if tool_name in ("call_tool", "mcp__gobby__call_tool"):
+            if "mcp_server" not in data:
+                data["mcp_server"] = tool_input.get("server_name")
+            if "mcp_tool" not in data:
+                data["mcp_tool"] = tool_input.get("tool_name")
+
+        # 2. Normalize tool_result → tool_output
+        if "tool_result" in data and "tool_output" not in data:
+            data["tool_output"] = data["tool_result"]
+
+        return data
+
     # Map Claude Code hook types to hookEventName for hookSpecificOutput
     HOOK_EVENT_NAME_MAP: dict[str, str] = {
         "session-start": "SessionStart",
@@ -193,44 +233,65 @@ class ClaudeCodeAdapter(BaseAdapter):
         # Add session identifiers from metadata
         # Note: "session_id" in metadata is Gobby's internal platform session ID
         #       "external_id" in metadata is the CLI's session UUID
+        #       "session_ref" is the short #N format for easier reference
+        # Token optimization: Only inject full metadata on first hook per session
         if response.metadata:
             gobby_session_id = response.metadata.get("session_id")
+            session_ref = response.metadata.get("session_ref")
             external_id = response.metadata.get("external_id")
+            is_first_hook = response.metadata.get("_first_hook_for_session", False)
+
             if gobby_session_id:
-                # Build context with all available identifiers
-                # Use clear naming: Gobby Session ID for MCP calls, External ID for transcripts
-                context_lines = [f"Gobby Session ID: {gobby_session_id}"]
-                if external_id:
-                    context_lines.append(f"External ID: {external_id}")
-                if response.metadata.get("parent_session_id"):
-                    context_lines.append(
-                        f"parent_session_id: {response.metadata['parent_session_id']}"
-                    )
-                if response.metadata.get("machine_id"):
-                    context_lines.append(f"machine_id: {response.metadata['machine_id']}")
-                if response.metadata.get("project_id"):
-                    context_lines.append(f"project_id: {response.metadata['project_id']}")
-                # Add terminal context (non-null values only)
-                if response.metadata.get("terminal_term_program"):
-                    context_lines.append(f"terminal: {response.metadata['terminal_term_program']}")
-                if response.metadata.get("terminal_tty"):
-                    context_lines.append(f"tty: {response.metadata['terminal_tty']}")
-                if response.metadata.get("terminal_parent_pid"):
-                    context_lines.append(f"parent_pid: {response.metadata['terminal_parent_pid']}")
-                # Add terminal-specific session IDs (only one will be present)
-                for key in [
-                    "terminal_iterm_session_id",
-                    "terminal_term_session_id",
-                    "terminal_kitty_window_id",
-                    "terminal_tmux_pane",
-                    "terminal_vscode_terminal_id",
-                    "terminal_alacritty_socket",
-                ]:
-                    if response.metadata.get(key):
-                        # Use friendlier names in output
-                        friendly_name = key.replace("terminal_", "").replace("_", " ")
-                        context_lines.append(f"{friendly_name}: {response.metadata[key]}")
-                additional_context_parts.append("\n".join(context_lines))
+                if is_first_hook:
+                    # First hook: inject full metadata (~60-100 tokens)
+                    context_lines = []
+                    if session_ref:
+                        context_lines.append(
+                            f"Gobby Session ID: {session_ref} (or {gobby_session_id})"
+                        )
+                    else:
+                        context_lines.append(f"Gobby Session ID: {gobby_session_id}")
+                    if external_id:
+                        context_lines.append(
+                            f"CLI-Specific Session ID (external_id): {external_id}"
+                        )
+                    if response.metadata.get("parent_session_id"):
+                        context_lines.append(
+                            f"parent_session_id: {response.metadata['parent_session_id']}"
+                        )
+                    if response.metadata.get("machine_id"):
+                        context_lines.append(f"machine_id: {response.metadata['machine_id']}")
+                    if response.metadata.get("project_id"):
+                        context_lines.append(f"project_id: {response.metadata['project_id']}")
+                    # Add terminal context (non-null values only)
+                    if response.metadata.get("terminal_term_program"):
+                        context_lines.append(
+                            f"terminal: {response.metadata['terminal_term_program']}"
+                        )
+                    if response.metadata.get("terminal_tty"):
+                        context_lines.append(f"tty: {response.metadata['terminal_tty']}")
+                    if response.metadata.get("terminal_parent_pid"):
+                        context_lines.append(
+                            f"parent_pid: {response.metadata['terminal_parent_pid']}"
+                        )
+                    # Add terminal-specific session IDs (only one will be present)
+                    for key in [
+                        "terminal_iterm_session_id",
+                        "terminal_term_session_id",
+                        "terminal_kitty_window_id",
+                        "terminal_tmux_pane",
+                        "terminal_vscode_terminal_id",
+                        "terminal_alacritty_socket",
+                    ]:
+                        if response.metadata.get(key):
+                            # Use friendlier names in output
+                            friendly_name = key.replace("terminal_", "").replace("_", " ")
+                            context_lines.append(f"{friendly_name}: {response.metadata[key]}")
+                    additional_context_parts.append("\n".join(context_lines))
+                else:
+                    # Subsequent hooks: inject minimal session ref only (~8 tokens)
+                    if session_ref:
+                        additional_context_parts.append(f"Gobby Session ID: {session_ref}")
 
         # Build hookSpecificOutput if we have any context to inject
         # Only include hookSpecificOutput for hook types that Claude Code's schema accepts

gobby/adapters/gemini.py

@@ -76,21 +76,39 @@ class GeminiAdapter(BaseAdapter):
 
     # Tool name mapping: Gemini tool names -> normalized names
     # Gemini uses different tool names than Claude Code
+    # This enables workflows to use Claude Code naming conventions
     TOOL_MAP: dict[str, str] = {
+        # Shell/Bash
         "run_shell_command": "Bash",
         "RunShellCommand": "Bash",
+        "ShellTool": "Bash",
+        # File read
         "read_file": "Read",
         "ReadFile": "Read",
         "ReadFileTool": "Read",
+        # File write
         "write_file": "Write",
         "WriteFile": "Write",
         "WriteFileTool": "Write",
+        # File edit
         "edit_file": "Edit",
         "EditFile": "Edit",
         "EditFileTool": "Edit",
+        # Search/Glob/Grep
         "GlobTool": "Glob",
         "GrepTool": "Grep",
-        "ShellTool": "Bash",
+        "search_file_content": "Grep",
+        "SearchText": "Grep",
+        # MCP tools (Gobby MCP server)
+        "call_tool": "mcp__gobby__call_tool",
+        "list_mcp_servers": "mcp__gobby__list_mcp_servers",
+        "list_tools": "mcp__gobby__list_tools",
+        "get_tool_schema": "mcp__gobby__get_tool_schema",
+        "search_tools": "mcp__gobby__search_tools",
+        "recommend_tools": "mcp__gobby__recommend_tools",
+        # Skill and agent tools
+        "activate_skill": "Skill",
+        "delegate_to_agent": "Task",
     }
 
     def __init__(self, hook_manager: "HookManager | None" = None):
@@ -135,6 +153,55 @@ class GeminiAdapter(BaseAdapter):
         """
         return self.TOOL_MAP.get(gemini_tool_name, gemini_tool_name)
 
+    def _normalize_event_data(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """Normalize Gemini event data for CLI-agnostic processing.
+
+        This method enriches the input_data with normalized fields so downstream
+        code doesn't need to handle Gemini-specific formats.
+
+        Normalizations performed:
+        1. mcp_context.server_name/tool_name → mcp_server/mcp_tool (top-level)
+        2. tool_response → tool_output
+        3. function_name → tool_name (if not already present)
+        4. parameters/args → tool_input (if not already present)
+
+        Args:
+            input_data: Raw input data from Gemini CLI
+
+        Returns:
+            Enriched data dict with normalized fields added
+        """
+        # Start with a copy to avoid mutating original
+        data = dict(input_data)
+
+        # 1. Flatten mcp_context to top-level mcp_server/mcp_tool
+        mcp_context = data.get("mcp_context")
+        if mcp_context and isinstance(mcp_context, dict):
+            if "mcp_server" not in data:
+                data["mcp_server"] = mcp_context.get("server_name")
+            if "mcp_tool" not in data:
+                data["mcp_tool"] = mcp_context.get("tool_name")
+
+        # 2. Normalize tool_response → tool_output
+        if "tool_response" in data and "tool_output" not in data:
+            data["tool_output"] = data["tool_response"]
+
+        # 3. Normalize function_name → tool_name
+        if "function_name" in data and "tool_name" not in data:
+            data["tool_name"] = self.normalize_tool_name(data["function_name"])
+        elif "tool_name" in data:
+            # Normalize existing tool_name
+            data["tool_name"] = self.normalize_tool_name(data["tool_name"])
+
+        # 4. Normalize parameters/args → tool_input
+        if "tool_input" not in data:
+            if "parameters" in data:
+                data["tool_input"] = data["parameters"]
+            elif "args" in data:
+                data["tool_input"] = data["args"]
+
+        return data
+
     def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
         """Convert Gemini CLI native event to unified HookEvent.
 
@@ -202,6 +269,10 @@ class GeminiAdapter(BaseAdapter):
         else:
             metadata = {}
 
+        # Normalize event data for CLI-agnostic processing
+        # This allows downstream code to use consistent field names
+        normalized_data = self._normalize_event_data(input_data)
+
         return HookEvent(
             event_type=event_type,
             session_id=session_id,
@@ -209,7 +280,7 @@ class GeminiAdapter(BaseAdapter):
             timestamp=timestamp,
             machine_id=machine_id,
             cwd=input_data.get("cwd"),
-            data=input_data,
+            data=normalized_data,
             metadata=metadata,
         )
 
@@ -254,46 +325,77 @@ class GeminiAdapter(BaseAdapter):
         if response.context:
             hook_specific["additionalContext"] = response.context
 
-        # Add session/terminal context for SessionStart only
-        if hook_type == "SessionStart" and response.metadata:
+        # Add session/terminal context for hooks that support additionalContext
+        # Parity with Claude Code: inject on SessionStart, BeforeAgent, BeforeTool, AfterTool
+        hooks_with_context = {"SessionStart", "BeforeAgent", "BeforeTool", "AfterTool"}
+        if hook_type in hooks_with_context and response.metadata:
             session_id = response.metadata.get("session_id")
+            session_ref = response.metadata.get("session_ref")
+            external_id = response.metadata.get("external_id")
+            is_first_hook = response.metadata.get("_first_hook_for_session", False)
+
             if session_id:
                 hook_event_name = self.HOOK_EVENT_NAME_MAP.get(hook_type, "Unknown")
-                context_lines = [f"session_id: {session_id}"]
-                if response.metadata.get("parent_session_id"):
-                    context_lines.append(
-                        f"parent_session_id: {response.metadata['parent_session_id']}"
+
+                if is_first_hook:
+                    # First hook: inject full metadata (~60-100 tokens)
+                    context_lines = []
+                    if session_ref:
+                        context_lines.append(f"Gobby Session ID: {session_ref} (or {session_id})")
+                    else:
+                        context_lines.append(f"Gobby Session ID: {session_id}")
+                    if external_id:
+                        context_lines.append(
+                            f"CLI-Specific Session ID (external_id): {external_id}"
+                        )
+                    if response.metadata.get("parent_session_id"):
+                        context_lines.append(
+                            f"parent_session_id: {response.metadata['parent_session_id']}"
+                        )
+                    if response.metadata.get("machine_id"):
+                        context_lines.append(f"machine_id: {response.metadata['machine_id']}")
+                    if response.metadata.get("project_id"):
+                        context_lines.append(f"project_id: {response.metadata['project_id']}")
+                    # Add terminal context (non-null values only)
+                    if response.metadata.get("terminal_term_program"):
+                        context_lines.append(
+                            f"terminal: {response.metadata['terminal_term_program']}"
+                        )
+                    if response.metadata.get("terminal_tty"):
+                        context_lines.append(f"tty: {response.metadata['terminal_tty']}")
+                    if response.metadata.get("terminal_parent_pid"):
+                        context_lines.append(
+                            f"parent_pid: {response.metadata['terminal_parent_pid']}"
+                        )
+                    # Add terminal-specific session IDs
+                    for key in [
+                        "terminal_iterm_session_id",
+                        "terminal_term_session_id",
+                        "terminal_kitty_window_id",
+                        "terminal_tmux_pane",
+                        "terminal_vscode_terminal_id",
+                        "terminal_alacritty_socket",
+                    ]:
+                        if response.metadata.get(key):
+                            friendly_name = key.replace("terminal_", "").replace("_", " ")
+                            context_lines.append(f"{friendly_name}: {response.metadata[key]}")
+
+                    hook_specific["hookEventName"] = hook_event_name
+                    # Append to existing additionalContext if present
+                    existing = hook_specific.get("additionalContext", "")
+                    new_context = "\n".join(context_lines)
+                    hook_specific["additionalContext"] = (
+                        f"{existing}\n{new_context}" if existing else new_context
                     )
-                if response.metadata.get("machine_id"):
-                    context_lines.append(f"machine_id: {response.metadata['machine_id']}")
-                if response.metadata.get("project_id"):
-                    context_lines.append(f"project_id: {response.metadata['project_id']}")
-                # Add terminal context (non-null values only)
-                if response.metadata.get("terminal_term_program"):
-                    context_lines.append(f"terminal: {response.metadata['terminal_term_program']}")
-                if response.metadata.get("terminal_tty"):
-                    context_lines.append(f"tty: {response.metadata['terminal_tty']}")
-                if response.metadata.get("terminal_parent_pid"):
-                    context_lines.append(f"parent_pid: {response.metadata['terminal_parent_pid']}")
-                # Add terminal-specific session IDs
-                for key in [
-                    "terminal_iterm_session_id",
-                    "terminal_term_session_id",
-                    "terminal_kitty_window_id",
-                    "terminal_tmux_pane",
-                    "terminal_vscode_terminal_id",
-                    "terminal_alacritty_socket",
-                ]:
-                    if response.metadata.get(key):
-                        friendly_name = key.replace("terminal_", "").replace("_", " ")
-                        context_lines.append(f"{friendly_name}: {response.metadata[key]}")
-                hook_specific["hookEventName"] = hook_event_name
-                # Append to existing additionalContext if present
-                existing = hook_specific.get("additionalContext", "")
-                new_context = "\n".join(context_lines)
-                hook_specific["additionalContext"] = (
-                    f"{existing}\n{new_context}" if existing else new_context
-                )
+                else:
+                    # Subsequent hooks: inject minimal session ref only (~8 tokens)
+                    if session_ref:
+                        hook_specific["hookEventName"] = hook_event_name
+                        existing = hook_specific.get("additionalContext", "")
+                        minimal_context = f"Gobby Session ID: {session_ref}"
+                        hook_specific["additionalContext"] = (
+                            f"{existing}\n{minimal_context}" if existing else minimal_context
+                        )
 
         # Handle BeforeModel-specific output (llm_request modification)
         if hook_type == "BeforeModel" and response.modify_args:

gobby/agents/isolation.py

@@ -197,6 +197,13 @@ class WorktreeIsolationHandler(IsolationHandler):
             task_id=config.task_id,
         )
 
+        # Copy CLI hooks to worktree so hooks fire correctly
+        await self._copy_cli_hooks(
+            main_repo_path=self._git_manager.repo_path,
+            worktree_path=worktree_path,
+            provider=config.provider,
+        )
+
         return IsolationContext(
             cwd=worktree.worktree_path,
             branch_name=worktree.branch_name,
@@ -235,6 +242,64 @@ Commit your changes to the worktree branch when done.
         worktree_dir = tempfile.gettempdir()
         return f"{worktree_dir}/gobby-worktrees/{project_name}/{safe_branch}"
 
+    async def _copy_cli_hooks(
+        self,
+        main_repo_path: str,
+        worktree_path: str,
+        provider: str,
+    ) -> None:
+        """
+        Copy CLI-specific hooks to the worktree.
+
+        Without these hooks, the spawned agent won't trigger SessionStart
+        and other lifecycle hooks, breaking Gobby integration.
+
+        Args:
+            main_repo_path: Path to the main repository
+            worktree_path: Path to the newly created worktree
+            provider: CLI provider (gemini, claude, codex)
+        """
+        import asyncio
+        import logging
+        import shutil
+        from pathlib import Path
+
+        logger = logging.getLogger(__name__)
+
+        # Map provider to CLI hook directory
+        cli_dirs = {
+            "gemini": ".gemini",
+            "claude": ".claude",
+            "codex": ".codex",
+        }
+
+        cli_dir = cli_dirs.get(provider)
+        if not cli_dir:
+            logger.debug(f"No CLI hooks directory defined for provider: {provider}")
+            return
+
+        src_path = Path(main_repo_path) / cli_dir
+        dst_path = Path(worktree_path) / cli_dir
+
+        if not src_path.exists():
+            logger.debug(f"CLI hooks directory not found in main repo: {src_path}")
+            return
+
+        try:
+            # Copy entire CLI hooks directory (non-blocking)
+            await asyncio.to_thread(shutil.copytree, src_path, dst_path, dirs_exist_ok=True)
+            logger.info(f"Copied CLI hooks from {src_path} to {dst_path}")
+        except shutil.Error:
+            logger.warning(
+                f"Failed to copy CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+        except OSError:
+            logger.warning(
+                f"Filesystem error copying CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+
 
 class CloneIsolationHandler(IsolationHandler):
     """
@@ -310,6 +375,13 @@ class CloneIsolationHandler(IsolationHandler):
             task_id=config.task_id,
         )
 
+        # Copy CLI hooks to clone so hooks fire correctly
+        await self._copy_cli_hooks(
+            source_repo_path=config.project_path,
+            clone_path=clone_path,
+            provider=config.provider,
+        )
+
         return IsolationContext(
             cwd=clone.clone_path,
             branch_name=clone.branch_name,
@@ -348,6 +420,64 @@ Push your changes when ready to share with the original.
         clone_dir = tempfile.gettempdir()
         return f"{clone_dir}/gobby-clones/{project_name}/{safe_branch}"
 
+    async def _copy_cli_hooks(
+        self,
+        source_repo_path: str,
+        clone_path: str,
+        provider: str,
+    ) -> None:
+        """
+        Copy CLI-specific hooks to the clone.
+
+        Without these hooks, the spawned agent won't trigger SessionStart
+        and other lifecycle hooks, breaking Gobby integration.
+
+        Args:
+            source_repo_path: Path to the source repository
+            clone_path: Path to the newly created clone
+            provider: CLI provider (gemini, claude, codex)
+        """
+        import asyncio
+        import logging
+        import shutil
+        from pathlib import Path
+
+        logger = logging.getLogger(__name__)
+
+        # Map provider to CLI hook directory
+        cli_dirs = {
+            "gemini": ".gemini",
+            "claude": ".claude",
+            "codex": ".codex",
+        }
+
+        cli_dir = cli_dirs.get(provider)
+        if not cli_dir:
+            logger.debug(f"No CLI hooks directory defined for provider: {provider}")
+            return
+
+        src_path = Path(source_repo_path) / cli_dir
+        dst_path = Path(clone_path) / cli_dir
+
+        if not src_path.exists():
+            logger.debug(f"CLI hooks directory not found in source repo: {src_path}")
+            return
+
+        try:
+            # Copy entire CLI hooks directory (non-blocking)
+            await asyncio.to_thread(shutil.copytree, src_path, dst_path, dirs_exist_ok=True)
+            logger.info(f"Copied CLI hooks from {src_path} to {dst_path}")
+        except shutil.Error:
+            logger.warning(
+                f"Failed to copy CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+        except OSError:
+            logger.warning(
+                f"Filesystem error copying CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+
 
 def get_isolation_handler(
     mode: Literal["current", "worktree", "clone"],

gobby/agents/registry.py

@@ -137,6 +137,17 @@ class RunningAgentRegistry:
         with self._event_callbacks_lock:
             self._event_callbacks.append(callback)
 
+    def emit_event(self, event_type: str, run_id: str, data: dict[str, Any]) -> None:
+        """
+        Emit a custom event to all registered callbacks.
+
+        Args:
+            event_type: Type of event (e.g., terminal_output)
+            run_id: Agent run ID
+            data: Additional event data
+        """
+        self._emit_event(event_type, run_id, data)
+
     def _emit_event(self, event_type: str, run_id: str, data: dict[str, Any]) -> None:
         """
         Emit an event to all registered callbacks.

gobby/agents/session.py

@@ -196,6 +196,7 @@ class ChildSessionManager:
             parent_session_id=config.parent_session_id,
             agent_depth=child_depth,
             spawned_by_agent_id=config.agent_id,
+            workflow_name=config.workflow_name,
         )
 
         child_id = child.id