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

gobby/__init__.py

@@ -1,3 +1,3 @@
 """Gobby - Local-first daemon for multi-CLI session management."""
 
-__version__ = "0.2.7"
+__version__ = "0.2.9"

gobby/adapters/claude_code.py

@@ -61,13 +61,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         """Initialize the Claude Code adapter.
 
         Args:
-            hook_manager: Reference to HookManager for strangler fig delegation.
+            hook_manager: Reference to HookManager for delegation.
                          If None, the adapter can only translate (not handle events).
         """
         self._hook_manager = hook_manager
-        # Phase 2C: Use new handle() path with unified HookEvent model
-        # Note: systemMessage handoff notification bug exists in both paths (see plan-multi-cli.md)
-        self._use_legacy = False
 
     def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
         """Convert Claude Code native event to unified HookEvent.
@@ -310,14 +307,6 @@ class ClaudeCodeAdapter(BaseAdapter):
     ) -> dict[str, Any]:
         """Main entry point for HTTP endpoint.
 
-        Strangler fig pattern:
-        - Phase 2A-2B: Delegates to existing execute() — validates translation only
-        - Phase 2C+: Calls new handle() with HookEvent
-
-        Note: This method is synchronous for Phase 2A-2B compatibility with
-        the existing execute() method. In Phase 2C+, it will become async
-        when handle() is implemented as async.
-
         Args:
             native_event: Raw payload from Claude Code's hook_dispatcher.py
             hook_manager: HookManager instance for processing.
@@ -325,22 +314,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         Returns:
             Response dict in Claude Code's expected format.
         """
-        # Always translate (validates our mapping is correct)
+        # Translate to HookEvent
         hook_event = self.translate_to_hook_event(native_event)
 
-        # Phase 2C+: Use new HookEvent-based handler
-        # Legacy execute() path removed as HookManager.execute is deprecated/removed.
+        # Use HookEvent-based handler
         hook_type = native_event.get("hook_type", "")
         hook_response = hook_manager.handle(hook_event)
         return self.translate_from_hook_response(hook_response, hook_type=hook_type)
-
-    def set_legacy_mode(self, use_legacy: bool) -> None:
-        """Toggle between legacy and new code paths.
-
-        This method is used during the strangler fig migration to switch
-        between delegating to execute() and calling handle() directly.
-
-        Args:
-            use_legacy: If True, use legacy execute() path. If False, use new handle() path.
-        """
-        self._use_legacy = use_legacy

gobby/app_context.py

@@ -0,0 +1,59 @@
+"""
+Service container for dependency injection in Gobby daemon.
+
+Holds references to singleton services to avoid prop-drilling in HTTPServer
+and other components.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from gobby.config.app import DaemonConfig
+from gobby.llm import LLMService
+from gobby.memory.manager import MemoryManager
+from gobby.storage.clones import LocalCloneManager
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.storage.tasks import LocalTaskManager
+from gobby.storage.worktrees import LocalWorktreeManager
+from gobby.sync.memories import MemorySyncManager
+from gobby.sync.tasks import TaskSyncManager
+
+
+@dataclass
+class ServiceContainer:
+    """Container for daemon services."""
+
+    # Core Infrastructure
+    config: DaemonConfig
+    database: DatabaseProtocol
+
+    # Core Managers
+    session_manager: LocalSessionManager
+    task_manager: LocalTaskManager
+
+    # Sync Managers
+    task_sync_manager: TaskSyncManager | None = None
+    memory_sync_manager: MemorySyncManager | None = None
+
+    # Advanced Features
+    memory_manager: MemoryManager | None = None
+    llm_service: LLMService | None = None
+
+    # MCP & Agents
+    mcp_manager: Any | None = None  # MCPClientManager
+    mcp_db_manager: Any | None = None  # LocalMCPManager
+    metrics_manager: Any | None = None  # ToolMetricsManager
+    agent_runner: Any | None = None  # AgentRunner
+    message_processor: Any | None = None  # SessionMessageProcessor
+    message_manager: Any | None = None  # LocalSessionMessageManager
+
+    # Validation & Git
+    task_validator: Any | None = None  # TaskValidator
+    worktree_storage: LocalWorktreeManager | None = None
+    clone_storage: LocalCloneManager | None = None
+    git_manager: Any | None = None  # WorktreeGitManager
+
+    # Context
+    project_id: str | None = None
+    websocket_server: Any | None = None

gobby/cli/utils.py

@@ -394,23 +394,10 @@ def get_install_dir() -> Path:
     Returns:
         Path to the install directory
     """
-    import gobby
+    # Import from centralized paths module to avoid duplication
+    from gobby.paths import get_install_dir as _get_install_dir
 
-    package_install_dir = Path(gobby.__file__).parent / "install"
-
-    # Try to find source directory (project root)
-    current = Path(gobby.__file__).resolve()
-    source_install_dir = None
-
-    for parent in current.parents:
-        potential_source = parent / "src" / "gobby" / "install"
-        if potential_source.exists():
-            source_install_dir = potential_source
-            break
-
-    if source_install_dir and source_install_dir.exists():
-        return source_install_dir
-    return package_install_dir
+    return _get_install_dir()
 
 
 def _is_process_alive(pid: int) -> bool:
@@ -472,7 +459,8 @@ def stop_daemon(quiet: bool = False) -> bool:
             click.echo(f"Sent shutdown signal to Gobby daemon (PID {pid})")
 
         # Wait for graceful shutdown
-        max_wait = 5
+        # Match daemon's uvicorn timeout_graceful_shutdown (15s) + buffer
+        max_wait = 20
         for _ in range(max_wait * 10):
             time.sleep(0.1)
             if not _is_process_alive(pid):

gobby/config/features.py

@@ -23,7 +23,6 @@ __all__ = [
     "HookStageConfig",
     "HooksConfig",
     "TaskDescriptionConfig",
-    "DEFAULT_IMPORT_MCP_SERVER_PROMPT",
 ]
 
 
@@ -139,25 +138,6 @@ class RecommendToolsConfig(BaseModel):
     )
 
 
-DEFAULT_IMPORT_MCP_SERVER_PROMPT = """You are an MCP server configuration extractor. Given documentation for an MCP server, extract the configuration needed to connect to it.
-
-Return ONLY a valid JSON object (no markdown, no code blocks) with these fields:
-- name: Server name (lowercase, no spaces, use hyphens)
-- transport: "http", "stdio", or "websocket"
-- url: Server URL (required for http/websocket transports)
-- command: Command to run (required for stdio, e.g., "npx", "uv", "node")
-- args: Array of command arguments (for stdio)
-- env: Object of environment variables needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- headers: Object of HTTP headers needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- instructions: How to obtain any required API keys or setup steps
-
-Example stdio server:
-{"name": "filesystem", "transport": "stdio", "command": "npx", "args": ["-y", "@anthropic-ai/filesystem-mcp"], "env": {}, "instructions": "No setup required"}
-
-Example http server with API key:
-{"name": "exa", "transport": "http", "url": "https://mcp.exa.ai/mcp", "headers": {"EXA_API_KEY": "<YOUR_EXA_API_KEY>"}, "instructions": "Get your API key from https://exa.ai/dashboard"}"""
-
-
 class ImportMCPServerConfig(BaseModel):
     """MCP server import configuration."""
 

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,
+            )