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

gobby/config/skills.py

@@ -11,6 +11,37 @@ from typing import Literal
 from pydantic import BaseModel, Field, field_validator
 
 
+class HubConfig(BaseModel):
+    """
+    Configuration for a skill hub or collection.
+    """
+
+    type: Literal["clawdhub", "skillhub", "github-collection"] = Field(
+        ...,
+        description="Type of the hub: 'clawdhub', 'skillhub', or 'github-collection'",
+    )
+
+    base_url: str | None = Field(
+        default=None,
+        description="Base URL for the hub",
+    )
+
+    repo: str | None = Field(
+        default=None,
+        description="GitHub repository (e.g. 'owner/repo')",
+    )
+
+    branch: str | None = Field(
+        default=None,
+        description="Git branch to use",
+    )
+
+    auth_key_name: str | None = Field(
+        default=None,
+        description="Environment variable name for auth key",
+    )
+
+
 class SkillsConfig(BaseModel):
     """
     Configuration for skill injection and discovery.

gobby/config/tasks.py

@@ -669,6 +669,10 @@ class WorkflowConfig(BaseModel):
         default_factory=lambda: ["Edit", "Write", "Update", "NotebookEdit"],
         description="Tools that require an active task when require_task_before_edit is enabled",
     )
+    debug_echo_context: bool = Field(
+        default=False,
+        description="Debug: echo additionalContext to system_message for terminal visibility",
+    )
 
     @field_validator("timeout")
     @classmethod

gobby/hooks/event_handlers/__init__.py

@@ -0,0 +1,155 @@
+"""
+Event handlers module for hook event processing.
+
+This module is extracted from hook_manager.py using Strangler Fig pattern.
+It provides centralized event handler registration and dispatch.
+
+Classes:
+    EventHandlers: Manages event handler registration and dispatch.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.event_handlers._agent import AgentEventHandlerMixin
+from gobby.hooks.event_handlers._misc import MiscEventHandlerMixin
+from gobby.hooks.event_handlers._session import SessionEventHandlerMixin
+from gobby.hooks.event_handlers._tool import EDIT_TOOLS, ToolEventHandlerMixin
+from gobby.hooks.events import HookEvent, HookEventType, HookResponse
+
+if TYPE_CHECKING:
+    from gobby.config.skills import SkillsConfig
+    from gobby.config.tasks import WorkflowConfig
+    from gobby.hooks.artifact_capture import ArtifactCaptureHook
+    from gobby.hooks.session_coordinator import SessionCoordinator
+    from gobby.hooks.skill_manager import HookSkillManager
+    from gobby.sessions.manager import SessionManager
+    from gobby.sessions.summary import SummaryFileGenerator
+    from gobby.storage.session_messages import LocalSessionMessageManager
+    from gobby.storage.session_tasks import SessionTaskManager
+    from gobby.storage.sessions import LocalSessionManager
+    from gobby.storage.tasks import LocalTaskManager
+    from gobby.workflows.hooks import WorkflowHookHandler
+
+
+class EventHandlers(
+    SessionEventHandlerMixin,
+    AgentEventHandlerMixin,
+    ToolEventHandlerMixin,
+    MiscEventHandlerMixin,
+):
+    """
+    Manages event handler registration and dispatch.
+
+    Provides handler methods for all HookEventType values and a registration
+    mechanism for looking up handlers by event type.
+
+    Extracted from HookManager to separate event handling concerns.
+    """
+
+    def __init__(
+        self,
+        session_manager: SessionManager | None = None,
+        workflow_handler: WorkflowHookHandler | None = None,
+        session_storage: LocalSessionManager | None = None,
+        session_task_manager: SessionTaskManager | None = None,
+        message_processor: Any | None = None,
+        summary_file_generator: SummaryFileGenerator | None = None,
+        task_manager: LocalTaskManager | None = None,
+        session_coordinator: SessionCoordinator | None = None,
+        message_manager: LocalSessionMessageManager | None = None,
+        skill_manager: HookSkillManager | None = None,
+        skills_config: SkillsConfig | None = None,
+        artifact_capture_hook: ArtifactCaptureHook | None = None,
+        workflow_config: WorkflowConfig | None = None,
+        get_machine_id: Callable[[], str] | None = None,
+        resolve_project_id: Callable[[str | None, str | None], str] | None = None,
+        logger: logging.Logger | None = None,
+    ) -> None:
+        """
+        Initialize EventHandlers.
+
+        Args:
+            session_manager: SessionManager for session operations
+            workflow_handler: WorkflowHookHandler for lifecycle workflows
+            session_storage: LocalSessionManager for session storage
+            session_task_manager: SessionTaskManager for session-task links
+            message_processor: SessionMessageProcessor for message handling
+            summary_file_generator: SummaryFileGenerator for summaries
+            task_manager: LocalTaskManager for task operations
+            session_coordinator: SessionCoordinator for session tracking
+            message_manager: LocalSessionMessageManager for messages
+            skill_manager: HookSkillManager for skill discovery
+            skills_config: SkillsConfig for skill injection settings
+            artifact_capture_hook: ArtifactCaptureHook for capturing artifacts
+            workflow_config: WorkflowConfig for workflow settings (debug_echo_context)
+            get_machine_id: Function to get machine ID
+            resolve_project_id: Function to resolve project ID from cwd
+            logger: Optional logger instance
+        """
+        self._session_manager = session_manager
+        self._workflow_handler = workflow_handler
+        self._session_storage = session_storage
+        self._session_task_manager = session_task_manager
+        self._message_processor = message_processor
+        self._summary_file_generator = summary_file_generator
+        self._task_manager = task_manager
+        self._session_coordinator = session_coordinator
+        self._message_manager = message_manager
+        self._skill_manager = skill_manager
+        self._skills_config = skills_config
+        self._artifact_capture_hook = artifact_capture_hook
+        self._workflow_config = workflow_config
+        self._get_machine_id = get_machine_id or (lambda: "unknown-machine")
+        self._resolve_project_id = resolve_project_id or (lambda p, c: p or "")
+        self.logger = logger or logging.getLogger(__name__)
+
+        # Build handler map
+        self._handler_map: dict[HookEventType, Callable[[HookEvent], HookResponse]] = {
+            HookEventType.SESSION_START: self.handle_session_start,
+            HookEventType.SESSION_END: self.handle_session_end,
+            HookEventType.BEFORE_AGENT: self.handle_before_agent,
+            HookEventType.AFTER_AGENT: self.handle_after_agent,
+            HookEventType.BEFORE_TOOL: self.handle_before_tool,
+            HookEventType.AFTER_TOOL: self.handle_after_tool,
+            HookEventType.PRE_COMPACT: self.handle_pre_compact,
+            HookEventType.SUBAGENT_START: self.handle_subagent_start,
+            HookEventType.SUBAGENT_STOP: self.handle_subagent_stop,
+            HookEventType.NOTIFICATION: self.handle_notification,
+            HookEventType.BEFORE_TOOL_SELECTION: self.handle_before_tool_selection,
+            HookEventType.BEFORE_MODEL: self.handle_before_model,
+            HookEventType.AFTER_MODEL: self.handle_after_model,
+            HookEventType.PERMISSION_REQUEST: self.handle_permission_request,
+            HookEventType.STOP: self.handle_stop,
+        }
+
+    def get_handler(
+        self, event_type: HookEventType | str
+    ) -> Callable[[HookEvent], HookResponse] | None:
+        """
+        Get handler for an event type.
+
+        Args:
+            event_type: The event type to get handler for
+
+        Returns:
+            Handler callable or None if not found
+        """
+        if isinstance(event_type, str):
+            try:
+                event_type = HookEventType(event_type)
+            except ValueError:
+                return None
+        return self._handler_map.get(event_type)
+
+    def get_handler_map(self) -> dict[HookEventType, Callable[[HookEvent], HookResponse]]:
+        """
+        Get a copy of the handler map.
+
+        Returns:
+            Copy of handler map (modifications don't affect internal state)
+        """
+        return dict(self._handler_map)

gobby/hooks/event_handlers/_agent.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from gobby.hooks.event_handlers._base import EventHandlersBase
+from gobby.hooks.events import HookEvent, HookResponse, SessionSource
+
+
+class AgentEventHandlerMixin(EventHandlersBase):
+    """Mixin for handling agent-related events."""
+
+    def handle_before_agent(self, event: HookEvent) -> HookResponse:
+        """Handle BEFORE_AGENT event (user prompt submit)."""
+        input_data = event.data
+        prompt = input_data.get("prompt", "")
+        transcript_path = input_data.get("transcript_path")
+        session_id = event.metadata.get("_platform_session_id")
+
+        context_parts = []
+
+        if session_id:
+            self.logger.debug(f"BEFORE_AGENT: session {session_id}, prompt_len={len(prompt)}")
+
+            # Update status to active (unless /clear or /exit)
+            prompt_lower = prompt.strip().lower()
+            if prompt_lower not in ("/clear", "/exit") and self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "active")
+                    if self._session_storage:
+                        self._session_storage.reset_transcript_processed(session_id)
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+
+            # Handle /clear command - lifecycle workflows handle handoff
+            if prompt_lower in ("/clear", "/exit") and transcript_path:
+                self.logger.debug(f"Detected {prompt_lower} - lifecycle workflows handle handoff")
+
+        # 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_agent(self, event: HookEvent) -> HookResponse:
+        """Handle AFTER_AGENT event."""
+        session_id = event.metadata.get("_platform_session_id")
+        cli_source = event.source.value
+
+        context_parts = []
+
+        if session_id:
+            self.logger.debug(f"AFTER_AGENT: session {session_id}, cli={cli_source}")
+            if self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "paused")
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+        else:
+            self.logger.debug(f"AFTER_AGENT: cli={cli_source}")
+
+        # 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_stop(self, event: HookEvent) -> HookResponse:
+        """Handle STOP event (Claude Code only)."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        context_parts = []
+
+        if session_id:
+            self.logger.debug(f"STOP: session {session_id}")
+            if self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "paused")
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+        else:
+            self.logger.debug("STOP")
+
+        # 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_pre_compact(self, event: HookEvent) -> HookResponse:
+        """Handle PRE_COMPACT event.
+
+        Note: Gemini fires PreCompress constantly during normal operation,
+        unlike Claude which fires it only when approaching context limits.
+        We skip handoff logic and workflow execution for Gemini to avoid
+        excessive state changes and workflow interruptions.
+        """
+        trigger = event.data.get("trigger", "auto")
+        session_id = event.metadata.get("_platform_session_id")
+
+        # Skip handoff logic for Gemini - it fires PreCompress too frequently
+        if event.source == SessionSource.GEMINI:
+            self.logger.debug(f"PRE_COMPACT ({trigger}): session {session_id} [Gemini - skipped]")
+            return HookResponse(decision="allow")
+
+        if session_id:
+            self.logger.debug(f"PRE_COMPACT ({trigger}): session {session_id}")
+            # Mark session as handoff_ready so it can be found as parent after compact
+            if self._session_manager:
+                self._session_manager.update_session_status(session_id, "handoff_ready")
+        else:
+            self.logger.debug(f"PRE_COMPACT ({trigger})")
+
+        # Execute lifecycle workflows
+        if self._workflow_handler:
+            try:
+                return self._workflow_handler.handle_all_lifecycles(event)
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(decision="allow")
+
+    def handle_subagent_start(self, event: HookEvent) -> HookResponse:
+        """Handle SUBAGENT_START event."""
+        input_data = event.data
+        session_id = event.metadata.get("_platform_session_id")
+        agent_id = input_data.get("agent_id")
+        subagent_id = input_data.get("subagent_id")
+
+        log_msg = f"SUBAGENT_START: session {session_id}" if session_id else "SUBAGENT_START"
+        if agent_id:
+            log_msg += f", agent_id={agent_id}"
+        if subagent_id:
+            log_msg += f", subagent_id={subagent_id}"
+        self.logger.debug(log_msg)
+
+        return HookResponse(decision="allow")
+
+    def handle_subagent_stop(self, event: HookEvent) -> HookResponse:
+        """Handle SUBAGENT_STOP event."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"SUBAGENT_STOP: session {session_id}")
+        else:
+            self.logger.debug("SUBAGENT_STOP")
+
+        return HookResponse(decision="allow")

gobby/hooks/event_handlers/_base.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.events import HookEvent, HookEventType, HookResponse
+
+if TYPE_CHECKING:
+    from gobby.config.skills import SkillsConfig
+    from gobby.config.tasks import WorkflowConfig
+    from gobby.hooks.artifact_capture import ArtifactCaptureHook
+    from gobby.hooks.session_coordinator import SessionCoordinator
+    from gobby.hooks.skill_manager import HookSkillManager
+    from gobby.sessions.manager import SessionManager
+    from gobby.sessions.summary import SummaryFileGenerator
+    from gobby.storage.session_messages import LocalSessionMessageManager
+    from gobby.storage.session_tasks import SessionTaskManager
+    from gobby.storage.sessions import LocalSessionManager
+    from gobby.storage.tasks import LocalTaskManager
+    from gobby.workflows.hooks import WorkflowHookHandler
+
+
+class EventHandlersBase:
+    """Base class for EventHandlers mixins with type hints for shared state."""
+
+    _session_manager: SessionManager | None
+    _workflow_handler: WorkflowHookHandler | None
+    _workflow_config: WorkflowConfig | None
+    _session_storage: LocalSessionManager | None
+    _session_task_manager: SessionTaskManager | None
+    _message_processor: Any | None
+    _summary_file_generator: SummaryFileGenerator | None
+    _task_manager: LocalTaskManager | None
+    _session_coordinator: SessionCoordinator | None
+    _message_manager: LocalSessionMessageManager | None
+    _skill_manager: HookSkillManager | None
+    _skills_config: SkillsConfig | None
+    _artifact_capture_hook: ArtifactCaptureHook | None
+    _get_machine_id: Callable[[], str]
+    _resolve_project_id: Callable[[str | None, str | None], str]
+    logger: logging.Logger
+    _handler_map: dict[HookEventType, Callable[[HookEvent], HookResponse]]
+
+    def _auto_activate_workflow(
+        self, workflow_name: str, session_id: str, project_path: str | None
+    ) -> None:
+        """Shared method for auto-activating workflows."""
+        if not self._workflow_handler:
+            return
+
+        try:
+            result = self._workflow_handler.activate_workflow(
+                workflow_name=workflow_name,
+                session_id=session_id,
+                project_path=project_path,
+            )
+            if result.get("success"):
+                self.logger.info(
+                    "Auto-activated workflow for session",
+                    extra={
+                        "workflow_name": workflow_name,
+                        "session_id": session_id,
+                        "project_path": project_path,
+                    },
+                )
+            else:
+                self.logger.warning(
+                    "Failed to auto-activate workflow",
+                    extra={
+                        "workflow_name": workflow_name,
+                        "session_id": session_id,
+                        "project_path": project_path,
+                        "error": result.get("error"),
+                    },
+                )
+        except Exception as e:
+            self.logger.warning(
+                "Failed to auto-activate workflow",
+                extra={
+                    "workflow_name": workflow_name,
+                    "session_id": session_id,
+                    "project_path": project_path,
+                    "error": str(e),
+                },
+                exc_info=True,
+            )

gobby/hooks/event_handlers/_misc.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from gobby.hooks.event_handlers._base import EventHandlersBase
+from gobby.hooks.events import HookEvent, HookResponse
+
+
+class MiscEventHandlerMixin(EventHandlersBase):
+    """Mixin for handling miscellaneous events."""
+
+    def handle_notification(self, event: HookEvent) -> HookResponse:
+        """Handle NOTIFICATION event."""
+        input_data = event.data
+        notification_type = (
+            input_data.get("notification_type")
+            or input_data.get("notificationType")
+            or input_data.get("type")
+            or "general"
+        )
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"NOTIFICATION ({notification_type}): session {session_id}")
+            if self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "paused")
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+        else:
+            self.logger.debug(f"NOTIFICATION ({notification_type})")
+
+        return HookResponse(decision="allow")
+
+    def handle_permission_request(self, event: HookEvent) -> HookResponse:
+        """Handle PERMISSION_REQUEST event (Claude Code only)."""
+        input_data = event.data
+        session_id = event.metadata.get("_platform_session_id")
+        permission_type = input_data.get("permission_type", "unknown")
+
+        if session_id:
+            self.logger.debug(f"PERMISSION_REQUEST ({permission_type}): session {session_id}")
+        else:
+            self.logger.debug(f"PERMISSION_REQUEST ({permission_type})")
+
+        return HookResponse(decision="allow")
+
+    def handle_before_model(self, event: HookEvent) -> HookResponse:
+        """Handle BEFORE_MODEL event (Gemini only)."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"BEFORE_MODEL: session {session_id}")
+        else:
+            self.logger.debug("BEFORE_MODEL")
+
+        return HookResponse(decision="allow")
+
+    def handle_after_model(self, event: HookEvent) -> HookResponse:
+        """Handle AFTER_MODEL event (Gemini only)."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"AFTER_MODEL: session {session_id}")
+        else:
+            self.logger.debug("AFTER_MODEL")
+
+        return HookResponse(decision="allow")