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

gobby/hooks/event_handlers/_tool.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from typing import Any
+
+from gobby.hooks.event_handlers._base import EventHandlersBase
+from gobby.hooks.events import HookEvent, HookResponse
+
+EDIT_TOOLS = {
+    "write_file",
+    "replace",
+    "edit_file",
+    "notebook_edit",
+    "edit",
+    "write",
+}
+
+
+class ToolEventHandlerMixin(EventHandlersBase):
+    """Mixin for handling tool-related events."""
+
+    def handle_before_tool(self, event: HookEvent) -> HookResponse:
+        """Handle BEFORE_TOOL event."""
+        input_data = event.data
+        tool_name = input_data.get("tool_name", "unknown")
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"BEFORE_TOOL: {tool_name}, session {session_id}")
+        else:
+            self.logger.debug(f"BEFORE_TOOL: {tool_name}")
+
+        context_parts = []
+
+        # Execute lifecycle workflow triggers
+        if self._workflow_handler:
+            try:
+                wf_response = self._workflow_handler.handle_all_lifecycles(event)
+                if wf_response.context:
+                    context_parts.append(wf_response.context)
+                if wf_response.decision != "allow":
+                    return wf_response
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(
+            decision="allow",
+            context="\n\n".join(context_parts) if context_parts else None,
+        )
+
+    def handle_after_tool(self, event: HookEvent) -> HookResponse:
+        """Handle AFTER_TOOL event."""
+        input_data = event.data
+        tool_name = input_data.get("tool_name", "unknown")
+        session_id = event.metadata.get("_platform_session_id")
+        is_failure = event.metadata.get("is_failure", False)
+
+        status = "FAIL" if is_failure else "OK"
+        if session_id:
+            self.logger.debug(f"AFTER_TOOL [{status}]: {tool_name}, session {session_id}")
+
+            # Track edits for session high-water mark
+            # Only if tool succeeded, matches edit tools, and session has claimed a task
+            # Skip .gobby/ internal files (tasks.jsonl, memories.jsonl, etc.)
+            tool_input = input_data.get("tool_input", {})
+
+            # Capture artifacts from edit tools
+            if not is_failure and self._artifact_capture_hook:
+                self._capture_tool_artifact(session_id, tool_name, tool_input)
+
+            # Simple check for edit tools (case-insensitive)
+            is_edit = tool_name.lower() in EDIT_TOOLS
+
+            # For complex tools (multi_replace, etc), check if they modify files
+            # This logic could be expanded, but for now stick to the basic set
+
+            if not is_failure and is_edit and self._session_storage:
+                try:
+                    # Check if file is internal .gobby file
+                    file_path = (
+                        tool_input.get("file_path")
+                        or tool_input.get("target_file")
+                        or tool_input.get("path")
+                    )
+                    is_internal = file_path and ".gobby/" in str(file_path)
+
+                    if not is_internal:
+                        # Check if session has any claimed tasks before marking had_edits
+                        has_claimed_task = False
+                        if self._task_manager:
+                            try:
+                                claimed_tasks = self._task_manager.list_tasks(assignee=session_id)
+                                has_claimed_task = len(claimed_tasks) > 0
+                            except Exception as e:
+                                self.logger.debug(
+                                    f"Failed to check claimed tasks for session {session_id}: {e}"
+                                )
+
+                        if has_claimed_task:
+                            self._session_storage.mark_had_edits(session_id)
+                except Exception as e:
+                    # Don't fail the event if tracking fails
+                    self.logger.warning(f"Failed to process file edit: {e}")
+
+        else:
+            self.logger.debug(f"AFTER_TOOL [{status}]: {tool_name}")
+
+        # Execute lifecycle workflow triggers
+        if self._workflow_handler:
+            try:
+                wf_response = self._workflow_handler.handle_all_lifecycles(event)
+                if wf_response.decision != "allow":
+                    return wf_response
+                if wf_response.context:
+                    return wf_response
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(decision="allow")
+
+    def handle_before_tool_selection(self, event: HookEvent) -> HookResponse:
+        """Handle BEFORE_TOOL_SELECTION event (Gemini only)."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"BEFORE_TOOL_SELECTION: session {session_id}")
+        else:
+            self.logger.debug("BEFORE_TOOL_SELECTION")
+
+        return HookResponse(decision="allow")
+
+    def _capture_tool_artifact(
+        self, session_id: str, tool_name: str, tool_input: dict[str, Any]
+    ) -> None:
+        """Capture artifacts from tool inputs for edit/write tools.
+
+        Args:
+            session_id: Platform session ID
+            tool_name: Name of the tool
+            tool_input: Tool input dictionary
+        """
+        if not self._artifact_capture_hook:
+            return
+
+        # Get content and file path from tool input
+        content = tool_input.get("content") or tool_input.get("new_string")
+        file_path = (
+            tool_input.get("file_path") or tool_input.get("target_file") or tool_input.get("path")
+        )
+
+        if not content:
+            return
+
+        # Skip internal .gobby files
+        if file_path and ".gobby/" in str(file_path):
+            return
+
+        # Detect language from file extension
+        language = ""
+        if file_path:
+            ext_map = {
+                ".py": "python",
+                ".js": "javascript",
+                ".ts": "typescript",
+                ".tsx": "tsx",
+                ".jsx": "jsx",
+                ".rs": "rust",
+                ".go": "go",
+                ".java": "java",
+                ".rb": "ruby",
+                ".sh": "bash",
+                ".yaml": "yaml",
+                ".yml": "yaml",
+                ".json": "json",
+                ".md": "markdown",
+                ".sql": "sql",
+                ".html": "html",
+                ".css": "css",
+            }
+            for ext, lang in ext_map.items():
+                if str(file_path).endswith(ext):
+                    language = lang
+                    break
+
+        # Wrap content as markdown code block for process_message
+        # This reuses the deduplication and classification logic
+        markdown_content = f"```{language}\n{content}\n```"
+
+        try:
+            self._artifact_capture_hook.process_message(
+                session_id=session_id,
+                role="assistant",
+                content=markdown_content,
+            )
+            self.logger.debug(f"Captured artifact from {tool_name}: {file_path or 'unknown'}")
+        except Exception as e:
+            self.logger.warning(f"Failed to capture artifact from {tool_name}: {e}")

gobby/hooks/hook_manager.py

@@ -369,6 +369,10 @@ class HookManager:
         # Skill manager for core skill injection
         self._skill_manager = HookSkillManager()
 
+        # Track sessions that have received full metadata injection
+        # Key: "{platform_session_id}:{source}" - cleared on daemon restart
+        self._injected_sessions: set[str] = set()
+
         # Event handlers (delegated to EventHandlers module)
         self._event_handlers = EventHandlers(
             session_manager=self._session_manager,
@@ -382,6 +386,8 @@ class HookManager:
             message_manager=self._message_manager,
             skill_manager=self._skill_manager,
             skills_config=self._config.skills if self._config else None,
+            artifact_capture_hook=self._artifact_capture_hook,
+            workflow_config=self._config.workflow if self._config else None,
             get_machine_id=self.get_machine_id,
             resolve_project_id=self._resolve_project_id,
             logger=self.logger,
@@ -644,7 +650,21 @@ class HookManager:
             # Copy session metadata from event to response for adapter injection
             # The adapter reads response.metadata to inject session info into agent context
             if event.metadata.get("_platform_session_id"):
-                response.metadata["session_id"] = event.metadata["_platform_session_id"]
+                platform_session_id = event.metadata["_platform_session_id"]
+                response.metadata["session_id"] = platform_session_id
+                # Look up seq_num for session_ref (#N format)
+                if self._session_storage:
+                    session_obj = self._session_storage.get(platform_session_id)
+                    if session_obj and session_obj.seq_num:
+                        response.metadata["session_ref"] = f"#{session_obj.seq_num}"
+
+                # Track first hook per session for token optimization
+                # Adapters use this flag to inject full metadata only on first hook
+                session_key = f"{platform_session_id}:{event.source.value}"
+                is_first = session_key not in self._injected_sessions
+                if is_first:
+                    self._injected_sessions.add(session_key)
+                response.metadata["_first_hook_for_session"] = is_first
             if event.session_id:  # external_id (e.g., Claude Code's session UUID)
                 response.metadata["external_id"] = event.session_id
             if event.machine_id:

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -216,52 +216,111 @@ def main() -> int:
         # This captures the terminal/process info for session correlation
         if hook_type == "SessionStart":
             input_data["terminal_context"] = get_terminal_context()
+            # Note: gobby_context (parent_session_id, workflow, etc.) is no longer
+            # injected from env vars. For spawned agents, the session is pre-created
+            # with all linkage via preflight+resume pattern, so the daemon already
+            # has the context when SessionStart fires.
 
         # Log what Gemini CLI sends us (for debugging hook data issues)
-        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+        # Extract common context fields for structured logging
+        session_id = input_data.get("session_id")
+        task_id = input_data.get("task_id")
+        project_id = input_data.get("project_id")
+        base_context = {
+            "hook_type": hook_type,
+            "session_id": session_id,
+            "task_id": task_id,
+            "project_id": project_id,
+        }
+
+        logger.info(
+            "[%s] Received input keys: %s",
+            hook_type,
+            list(input_data.keys()),
+            extra=base_context,
+        )
 
         # Log hook-specific critical fields
         if hook_type == "SessionStart":
-            logger.info(f"[SessionStart] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[SessionStart] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "SessionEnd":
+            reason = input_data.get("reason")
             logger.info(
-                f"[SessionEnd] session_id={input_data.get('session_id')}, "
-                f"reason={input_data.get('reason')}"
+                "[SessionEnd] session_id=%s, reason=%s",
+                session_id,
+                reason,
+                extra={**base_context, "reason": reason},
             )
         elif hook_type == "BeforeAgent":
             prompt = input_data.get("prompt", "")
             prompt_preview = prompt[:100] + "..." if len(prompt) > 100 else prompt
             logger.info(
-                f"[BeforeAgent] session_id={input_data.get('session_id')}, prompt={prompt_preview}"
+                "[BeforeAgent] session_id=%s, prompt=%s",
+                session_id,
+                prompt_preview,
+                extra={**base_context, "prompt_preview": prompt_preview},
             )
         elif hook_type == "BeforeTool":
             tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
             logger.info(
-                f"[BeforeTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+                "[BeforeTool] tool_name=%s, session_id=%s",
+                tool_name,
+                session_id,
+                extra={**base_context, "tool_name": tool_name},
             )
         elif hook_type == "AfterTool":
             tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
+            error = input_data.get("error")
             logger.info(
-                f"[AfterTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+                "[AfterTool] tool_name=%s, session_id=%s",
+                tool_name,
+                session_id,
+                extra={**base_context, "tool_name": tool_name, "error": error},
             )
         elif hook_type == "BeforeToolSelection":
-            logger.info(f"[BeforeToolSelection] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[BeforeToolSelection] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "BeforeModel":
+            model = input_data.get("model", "unknown")
             logger.info(
-                f"[BeforeModel] session_id={input_data.get('session_id')}, "
-                f"model={input_data.get('model', 'unknown')}"
+                "[BeforeModel] session_id=%s, model=%s",
+                session_id,
+                model,
+                extra={**base_context, "model": model},
             )
         elif hook_type == "AfterModel":
-            logger.info(f"[AfterModel] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[AfterModel] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "PreCompress":
-            logger.info(f"[PreCompress] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[PreCompress] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "Notification":
+            message = input_data.get("message")
             logger.info(
-                f"[Notification] session_id={input_data.get('session_id')}, "
-                f"message={input_data.get('message')}"
+                "[Notification] session_id=%s, message=%s",
+                session_id,
+                message,
+                extra={**base_context, "notification_message": message},
             )
         elif hook_type == "AfterAgent":
-            logger.info(f"[AfterAgent] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[AfterAgent] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
 
         if debug_mode:
             logger.debug(f"Input data: {input_data}")