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

gobby/prompts/loader.py

@@ -12,7 +12,6 @@ Implements prompt loading with precedence:
 
 import logging
 import re
-from collections.abc import Callable
 from functools import lru_cache
 from pathlib import Path
 from typing import Any
@@ -66,21 +65,6 @@ class PromptLoader:
         # Template cache
         self._cache: dict[str, PromptTemplate] = {}
 
-        # Fallback registry for strangler fig pattern
-        self._fallbacks: dict[str, Callable[[], str]] = {}
-
-    def register_fallback(self, path: str, getter: Callable[[], str]) -> None:
-        """Register a Python constant fallback for a template path.
-
-        Used for strangler fig pattern - if template file doesn't exist,
-        fall back to the original Python constant.
-
-        Args:
-            path: Template path (e.g., "expansion/system")
-            getter: Callable that returns the fallback string
-        """
-        self._fallbacks[path] = getter
-
     def clear_cache(self) -> None:
         """Clear the template cache."""
         self._cache.clear()
@@ -162,19 +146,6 @@ class PromptLoader:
             logger.debug(f"Loaded prompt template '{path}' from {template_file}")
             return template
 
-        # Fall back to registered Python constant
-        if path in self._fallbacks:
-            fallback_content = self._fallbacks[path]()
-            template = PromptTemplate(
-                name=path,
-                description=f"Fallback for {path}",
-                content=fallback_content,
-                source_path=None,
-            )
-            self._cache[path] = template
-            logger.debug(f"Using fallback for prompt template '{path}'")
-            return template
-
         raise FileNotFoundError(f"Prompt template not found: {path}")
 
     def render(
@@ -280,7 +251,7 @@ class PromptLoader:
         Returns:
             True if template exists (file or fallback)
         """
-        return self._find_template_file(path) is not None or path in self._fallbacks
+        return self._find_template_file(path) is not None
 
     def list_templates(self, category: str | None = None) -> list[str]:
         """List available template paths.
@@ -305,11 +276,6 @@ class PromptLoader:
                 if category is None or template_path.startswith(f"{category}/"):
                     templates.add(template_path)
 
-        # Add registered fallbacks
-        for fallback_path in self._fallbacks:
-            if category is None or fallback_path.startswith(f"{category}/"):
-                templates.add(fallback_path)
-
         return sorted(templates)
 
 

gobby/runner.py

@@ -9,6 +9,7 @@ from typing import Any
 import uvicorn
 
 from gobby.agents.runner import AgentRunner
+from gobby.app_context import ServiceContainer
 from gobby.config.app import load_config
 from gobby.llm import LLMService, create_llm_service
 from gobby.llm.resolver import ExecutorRegistry
@@ -212,29 +213,38 @@ class GobbyRunner:
         )
 
         # HTTP Server
-        self.http_server = HTTPServer(
-            port=self.config.daemon_port,
-            test_mode=self.config.test_mode,
-            mcp_manager=self.mcp_proxy,
-            mcp_db_manager=self.mcp_db_manager,
+        # Bundle services into container
+        services = ServiceContainer(
             config=self.config,
+            database=self.database,
             session_manager=self.session_manager,
             task_manager=self.task_manager,
             task_sync_manager=self.task_sync_manager,
-            message_manager=self.message_manager,
+            memory_sync_manager=self.memory_sync_manager,
             memory_manager=self.memory_manager,
             llm_service=self.llm_service,
-            message_processor=self.message_processor,
-            memory_sync_manager=self.memory_sync_manager,
-            task_validator=self.task_validator,
+            mcp_manager=self.mcp_proxy,
+            mcp_db_manager=self.mcp_db_manager,
             metrics_manager=self.metrics_manager,
             agent_runner=self.agent_runner,
+            message_processor=self.message_processor,
+            message_manager=self.message_manager,
+            task_validator=self.task_validator,
             worktree_storage=self.worktree_storage,
             clone_storage=self.clone_storage,
             git_manager=self.git_manager,
             project_id=self.project_id,
         )
 
+        self.http_server = HTTPServer(
+            services=services,
+            port=self.config.daemon_port,
+            test_mode=self.config.test_mode,
+        )
+
+        # Inject server into container for circular ref if needed later
+        # self.http_server.services = services
+
         # Ensure message_processor property is set (redundant but explicit):
         self.http_server.message_processor = self.message_processor
 
@@ -424,12 +434,14 @@ class GobbyRunner:
 
             # Start HTTP server
             # nosec B104: 0.0.0.0 binding is intentional - daemon serves local network
+            graceful_shutdown_timeout = 15
             config = uvicorn.Config(
                 self.http_server.app,
                 host="0.0.0.0",  # nosec B104 - local daemon needs network access
                 port=self.http_server.port,
                 log_level="warning",
                 access_log=False,
+                timeout_graceful_shutdown=graceful_shutdown_timeout,
             )
             server = uvicorn.Server(config)
             server_task = asyncio.create_task(server.serve())
@@ -439,9 +451,10 @@ class GobbyRunner:
                 await asyncio.sleep(0.5)
 
             # Cleanup with timeouts to prevent hanging
+            # Use timeout slightly longer than uvicorn's graceful shutdown to let it finish
             server.should_exit = True
             try:
-                await asyncio.wait_for(server_task, timeout=3.0)
+                await asyncio.wait_for(server_task, timeout=graceful_shutdown_timeout + 5)
             except TimeoutError:
                 logger.warning("HTTP server shutdown timed out")
 
@@ -471,6 +484,19 @@ class GobbyRunner:
                 except (asyncio.CancelledError, TimeoutError):
                     pass
 
+            # Export memories to JSONL backup on shutdown
+            if self.memory_sync_manager:
+                try:
+                    count = await asyncio.wait_for(
+                        self.memory_sync_manager.export_to_files(), timeout=5.0
+                    )
+                    if count > 0:
+                        logger.info(f"Shutdown memory backup: exported {count} memories")
+                except TimeoutError:
+                    logger.warning("Memory backup on shutdown timed out")
+                except Exception as e:
+                    logger.warning(f"Memory backup on shutdown failed: {e}")
+
             try:
                 await asyncio.wait_for(self.mcp_proxy.disconnect_all(), timeout=3.0)
             except TimeoutError:

gobby/servers/http.py

@@ -10,7 +10,7 @@ import logging
 import time
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -19,18 +19,22 @@ from fastapi.responses import JSONResponse
 from gobby.adapters.codex_impl.adapter import CodexAdapter
 from gobby.hooks.broadcaster import HookEventBroadcaster
 from gobby.hooks.hook_manager import HookManager
-from gobby.llm import LLMService, create_llm_service
+from gobby.llm import create_llm_service
 from gobby.mcp_proxy.registries import setup_internal_registries
 from gobby.mcp_proxy.semantic_search import SemanticToolSearch
 from gobby.mcp_proxy.server import GobbyDaemonTools, create_mcp_server
 from gobby.mcp_proxy.services.tool_filter import ToolFilterService
-from gobby.memory.manager import MemoryManager
-from gobby.storage.sessions import LocalSessionManager
-from gobby.storage.tasks import LocalTaskManager
-from gobby.sync.tasks import TaskSyncManager
 from gobby.utils.metrics import get_metrics_collector
 from gobby.utils.version import get_version
 
+if TYPE_CHECKING:
+    from gobby.app_context import ServiceContainer
+    from gobby.config.app import DaemonConfig
+    from gobby.llm import LLMService
+    from gobby.mcp_proxy.manager import MCPClientManager
+    from gobby.servers.websocket import WebSocketServer
+    from gobby.utils.tool_metrics import ToolMetricsManager
+
 logger = logging.getLogger(__name__)
 
 
@@ -44,84 +48,38 @@ class HTTPServer:
 
     def __init__(
         self,
+        services: "ServiceContainer",
         port: int = 8000,
         test_mode: bool = False,
-        mcp_manager: Any | None = None,
-        mcp_db_manager: Any | None = None,
-        config: Any | None = None,
         codex_client: Any | None = None,
-        session_manager: LocalSessionManager | None = None,
-        websocket_server: Any | None = None,
-        task_manager: LocalTaskManager | None = None,
-        task_sync_manager: TaskSyncManager | None = None,
-        message_processor: Any | None = None,
-        message_manager: Any | None = None,  # LocalSessionMessageManager
-        memory_manager: "MemoryManager | None" = None,
-        llm_service: "LLMService | None" = None,
-        memory_sync_manager: Any | None = None,
-        task_validator: Any | None = None,
-        metrics_manager: Any | None = None,
-        agent_runner: Any | None = None,
-        worktree_storage: Any | None = None,
-        clone_storage: Any | None = None,
-        git_manager: Any | None = None,
-        project_id: str | None = None,
     ) -> None:
         """
         Initialize HTTP server.
 
         Args:
+            services: ServiceContainer holding all dependencies
             port: Server port
             test_mode: Run in test mode (disable features that conflict with testing)
-            mcp_manager: MCPClientManager instance for multi-server support
-            mcp_db_manager: LocalMCPManager instance for SQLite-based storage of MCP
-                server configurations and tool schemas. Used by ToolsHandler for
-                progressive tool discovery. Optional; defaults to None.
-            config: DaemonConfig instance for configuration
             codex_client: CodexAppServerClient instance for Codex integration
-            session_manager: LocalSessionManager for session storage
-            websocket_server: Optional WebSocketServer instance for event broadcasting
-            task_manager: LocalTaskManager instance
-            task_sync_manager: TaskSyncManager instance
-            message_processor: SessionMessageProcessor instance
-            message_manager: LocalSessionMessageManager instance for retrieval
-            memory_manager: MemoryManager instance
-            llm_service: LLMService instance
         """
+        self.services = services
         self.port = port
         self.test_mode = test_mode
-        self.mcp_manager = mcp_manager
-        self.config = config
         self.codex_client = codex_client
-        self.session_manager = session_manager
-        self.task_manager = task_manager
-        self.task_sync_manager = task_sync_manager
-        self.message_processor = message_processor
-        self.message_manager = message_manager
-        self.memory_manager = memory_manager
-        self.websocket_server = websocket_server
-        self.llm_service = llm_service
-        self.memory_sync_manager = memory_sync_manager
-        self.task_validator = task_validator
-        self.metrics_manager = metrics_manager
-        self.agent_runner = agent_runner
-        self.worktree_storage = worktree_storage
-        self.clone_storage = clone_storage
-        self.git_manager = git_manager
-        self.project_id = project_id
-
-        # Initialize WebSocket broadcaster
-        # Note: websocket_server might be None if disabled
-        self.broadcaster = HookEventBroadcaster(websocket_server, config)
+
+        # WebSocket server reference (set by GobbyRunner after construction)
+        self.websocket_server: WebSocketServer | None = None
+
+        self.broadcaster = HookEventBroadcaster(services.websocket_server, services.config)
 
         self._start_time: float = time.time()
 
-        # Create LLM service if not provided
-        if not self.llm_service and config:
+        # Create LLM service if not provided in container (fallback)
+        if not services.llm_service and services.config:
             try:
-                self.llm_service = create_llm_service(config)
+                services.llm_service = create_llm_service(services.config)
                 logger.debug(
-                    f"LLM service initialized with providers: {self.llm_service.enabled_providers}"
+                    f"LLM service initialized with providers: {services.llm_service.enabled_providers}"
                 )
             except Exception as e:
                 logger.error(f"Failed to initialize LLM service: {e}")
@@ -130,12 +88,13 @@ class HTTPServer:
         self._mcp_server = None
         self._internal_manager = None
         self._tools_handler = None
-        self._mcp_db_manager = mcp_db_manager
-        if mcp_manager:
+
+        if services.mcp_manager:
             # Determine WebSocket port
             ws_port = 60888
-            if config and hasattr(config, "websocket") and config.websocket:
-                ws_port = config.websocket.port
+            cfg = services.config
+            if cfg and hasattr(cfg, "websocket") and cfg.websocket:
+                ws_port = cfg.websocket.port
 
             # Create a lazy getter for tool_proxy that will be available after
             # GobbyDaemonTools is created. This allows in-process agents to route
@@ -149,36 +108,38 @@ class HTTPServer:
             merge_storage = None
             merge_resolver = None
             inter_session_message_manager = None
-            if mcp_db_manager:
+            if self.services.mcp_db_manager:
                 from gobby.storage.inter_session_messages import InterSessionMessageManager
                 from gobby.storage.merge_resolutions import MergeResolutionManager
                 from gobby.worktrees.merge.resolver import MergeResolver
 
-                merge_storage = MergeResolutionManager(mcp_db_manager.db)
+                merge_storage = MergeResolutionManager(self.services.mcp_db_manager.db)
                 merge_resolver = MergeResolver()
-                merge_resolver._llm_service = self.llm_service
-                inter_session_message_manager = InterSessionMessageManager(mcp_db_manager.db)
+                merge_resolver._llm_service = services.llm_service
+                inter_session_message_manager = InterSessionMessageManager(
+                    self.services.mcp_db_manager.db
+                )
                 logger.debug("Merge resolution and inter-session messaging subsystems initialized")
 
             # Setup internal registries (gobby-tasks, gobby-memory, etc.)
             self._internal_manager = setup_internal_registries(
-                _config=config,
+                _config=services.config,
                 _session_manager=None,  # Not needed for internal registries
-                memory_manager=memory_manager,
-                task_manager=task_manager,
-                sync_manager=task_sync_manager,
-                task_validator=self.task_validator,
-                message_manager=message_manager,
-                local_session_manager=session_manager,
-                metrics_manager=self.metrics_manager,
-                llm_service=self.llm_service,
-                agent_runner=self.agent_runner,
-                worktree_storage=self.worktree_storage,
-                clone_storage=self.clone_storage,
-                git_manager=self.git_manager,
+                memory_manager=services.memory_manager,
+                task_manager=services.task_manager,
+                sync_manager=services.task_sync_manager,
+                task_validator=services.task_validator,
+                message_manager=services.message_manager,
+                local_session_manager=services.session_manager,
+                metrics_manager=services.metrics_manager,
+                llm_service=services.llm_service,
+                agent_runner=services.agent_runner,
+                worktree_storage=services.worktree_storage,
+                clone_storage=services.clone_storage,
+                git_manager=services.git_manager,
                 merge_storage=merge_storage,
                 merge_resolver=merge_resolver,
-                project_id=self.project_id,
+                project_id=services.project_id,
                 tool_proxy_getter=tool_proxy_getter,
                 inter_session_message_manager=inter_session_message_manager,
             )
@@ -186,47 +147,47 @@ class HTTPServer:
             logger.debug(f"Internal registries initialized: {registry_count} registries")
 
             # Initialize tool summarizer config
-            if config:
+            if services.config:
                 from gobby.tools.summarizer import init_summarizer_config
 
-                init_summarizer_config(config.tool_summarizer)
+                init_summarizer_config(services.config.tool_summarizer)
                 logger.debug("Tool summarizer config initialized")
 
             # Create semantic search instance if db available
             semantic_search = None
-            if mcp_db_manager:
-                semantic_search = SemanticToolSearch(db=mcp_db_manager.db)
+            if services.mcp_db_manager:
+                semantic_search = SemanticToolSearch(db=services.mcp_db_manager.db)
                 logger.debug("Semantic tool search initialized")
 
             # Create tool filter for workflow phase restrictions
             tool_filter = None
-            if mcp_db_manager:
-                tool_filter = ToolFilterService(db=mcp_db_manager.db)
+            if services.mcp_db_manager:
+                tool_filter = ToolFilterService(db=services.mcp_db_manager.db)
                 logger.debug("Tool filter service initialized")
 
             # Create fallback resolver for alternative tool suggestions on error
             fallback_resolver = None
-            if semantic_search and self.metrics_manager:
+            if semantic_search and services.metrics_manager:
                 from gobby.mcp_proxy.services.fallback import ToolFallbackResolver
 
                 fallback_resolver = ToolFallbackResolver(
                     semantic_search=semantic_search,
-                    metrics_manager=self.metrics_manager,
+                    metrics_manager=services.metrics_manager,
                 )
                 logger.debug("Fallback resolver initialized")
 
             # Create tools handler
             self._tools_handler = GobbyDaemonTools(
-                mcp_manager=mcp_manager,
+                mcp_manager=services.mcp_manager,
                 daemon_port=port,
                 websocket_port=ws_port,
                 start_time=self._start_time,
                 internal_manager=self._internal_manager,
-                config=config,
-                llm_service=self.llm_service,
-                session_manager=session_manager,
-                memory_manager=memory_manager,
-                config_manager=mcp_db_manager,
+                config=services.config,
+                llm_service=services.llm_service,
+                session_manager=services.session_manager,
+                memory_manager=services.memory_manager,
+                config_manager=services.mcp_db_manager,
                 semantic_search=semantic_search,
                 tool_filter=tool_filter,
                 fallback_resolver=fallback_resolver,
@@ -240,6 +201,83 @@ class HTTPServer:
         self._metrics = get_metrics_collector()
         self._daemon: Any = None  # Set externally by daemon
 
+    # Property accessors for services (delegate to container)
+    @property
+    def config(self) -> "DaemonConfig | None":
+        return self.services.config
+
+    @property
+    def session_manager(self) -> Any:
+        return self.services.session_manager
+
+    @session_manager.setter
+    def session_manager(self, value: Any) -> None:
+        self.services.session_manager = value
+
+    @property
+    def task_manager(self) -> Any:
+        return self.services.task_manager
+
+    @task_manager.setter
+    def task_manager(self, value: Any) -> None:
+        self.services.task_manager = value
+
+    @property
+    def mcp_manager(self) -> "MCPClientManager | None":
+        return self.services.mcp_manager
+
+    @mcp_manager.setter
+    def mcp_manager(self, value: "MCPClientManager | None") -> None:
+        self.services.mcp_manager = value
+
+    @property
+    def llm_service(self) -> "LLMService | None":
+        return self.services.llm_service
+
+    @llm_service.setter
+    def llm_service(self, value: "LLMService | None") -> None:
+        self.services.llm_service = value
+
+    @property
+    def memory_manager(self) -> Any:
+        return self.services.memory_manager
+
+    @memory_manager.setter
+    def memory_manager(self, value: Any) -> None:
+        self.services.memory_manager = value
+
+    @property
+    def message_manager(self) -> Any:
+        return self.services.message_manager
+
+    @message_manager.setter
+    def message_manager(self, value: Any) -> None:
+        self.services.message_manager = value
+
+    @property
+    def message_processor(self) -> Any:
+        return self.services.message_processor
+
+    @message_processor.setter
+    def message_processor(self, value: Any) -> None:
+        self.services.message_processor = value
+
+    @property
+    def metrics_manager(self) -> "ToolMetricsManager | None":
+        return self.services.metrics_manager
+
+    @metrics_manager.setter
+    def metrics_manager(self, value: "ToolMetricsManager | None") -> None:
+        self.services.metrics_manager = value
+
+    @property
+    def _mcp_db_manager(self) -> Any:
+        return self.services.mcp_db_manager
+
+    @_mcp_db_manager.setter
+    def _mcp_db_manager(self, value: Any) -> None:
+        self.services.mcp_db_manager = value
+
     @property
     def tool_proxy(self) -> Any:
         """Get the ToolProxyService instance for routing tool calls with error enrichment."""
@@ -314,30 +352,32 @@ class HTTPServer:
             hook_manager_kwargs: dict[str, Any] = {
                 "daemon_host": "localhost",
                 "daemon_port": self.port,
-                "llm_service": self.llm_service,
-                "config": self.config,
+                "llm_service": self.services.llm_service,
+                "config": self.services.config,
                 "broadcaster": self.broadcaster,
-                "mcp_manager": self.mcp_manager,
-                "message_processor": self.message_processor,
-                "memory_sync_manager": self.memory_sync_manager,
-                "task_sync_manager": self.task_sync_manager,
+                "mcp_manager": self.services.mcp_manager,
+                "message_processor": self.services.message_processor,
+                "memory_sync_manager": self.services.memory_sync_manager,
+                "task_sync_manager": self.services.task_sync_manager,
             }
-            if self.config:
+            if self.services.config:
                 # Pass full log file path from config
-                hook_manager_kwargs["log_file"] = self.config.logging.hook_manager
-                hook_manager_kwargs["log_max_bytes"] = self.config.logging.max_size_mb * 1024 * 1024
-                hook_manager_kwargs["log_backup_count"] = self.config.logging.backup_count
+                hook_manager_kwargs["log_file"] = self.services.config.logging.hook_manager
+                hook_manager_kwargs["log_max_bytes"] = (
+                    self.services.config.logging.max_size_mb * 1024 * 1024
+                )
+                hook_manager_kwargs["log_backup_count"] = self.services.config.logging.backup_count
 
                 app.state.hook_manager = HookManager(**hook_manager_kwargs)
             logger.debug("HookManager initialized in daemon")
 
             # Wire up stop_registry to WebSocket server for stop_request handling
             if (
-                self.websocket_server
+                self.services.websocket_server
                 and hasattr(app.state, "hook_manager")
                 and hasattr(app.state.hook_manager, "_stop_registry")
             ):
-                self.websocket_server.stop_registry = app.state.hook_manager._stop_registry
+                self.services.websocket_server.stop_registry = app.state.hook_manager._stop_registry
                 logger.debug("Stop registry connected to WebSocket server")
 
             # Store server instance for dependency injection
@@ -496,45 +536,48 @@ class HTTPServer:
         try:
             logger.debug("Processing graceful shutdown")
 
-            # Wait for pending background tasks to complete
+            # Cancel pending background tasks immediately instead of polling
             pending_tasks_count = len(self._background_tasks)
             if pending_tasks_count > 0:
                 logger.debug(
-                    "Waiting for pending background tasks to complete",
+                    "Cancelling pending background tasks",
                     extra={"pending_tasks": pending_tasks_count},
                 )
 
-                max_wait = 30.0
-                wait_start = time.perf_counter()
-
-                while (
-                    len(self._background_tasks) > 0
-                    and (time.perf_counter() - wait_start) < max_wait
-                ):
-                    await asyncio.sleep(0.5)
-
-                completed_wait = time.perf_counter() - wait_start
-                remaining_tasks = len(self._background_tasks)
-
-                if remaining_tasks > 0:
-                    logger.warning(
-                        "Shutdown timeout - some background tasks still pending",
-                        extra={
-                            "remaining_tasks": remaining_tasks,
-                            "wait_seconds": completed_wait,
-                        },
-                    )
-                else:
-                    logger.debug(
-                        "All background tasks completed",
-                        extra={"wait_seconds": completed_wait},
+                # Cancel all tasks
+                for task in self._background_tasks:
+                    task.cancel()
+
+                # Wait for cancellation to complete with a short timeout
+                if self._background_tasks:
+                    done, pending = await asyncio.wait(
+                        self._background_tasks,
+                        timeout=5.0,
+                        return_when=asyncio.ALL_COMPLETED,
                     )
 
+                    completed_count = len(done)
+                    remaining_count = len(pending)
+
+                    if remaining_count > 0:
+                        logger.warning(
+                            "Some background tasks did not cancel in time",
+                            extra={
+                                "completed": completed_count,
+                                "remaining": remaining_count,
+                            },
+                        )
+                    else:
+                        logger.debug(
+                            "All background tasks cancelled",
+                            extra={"completed": completed_count},
+                        )
+
             # Disconnect all MCP servers
-            if self.mcp_manager:
+            if self.services.mcp_manager:
                 logger.debug("Disconnecting MCP servers...")
                 try:
-                    await self.mcp_manager.disconnect_all()
+                    await self.services.mcp_manager.disconnect_all()
                     logger.debug("MCP servers disconnected")
                 except Exception as e:
                     logger.warning(f"Error disconnecting MCP servers: {e}")
@@ -560,31 +603,25 @@ class HTTPServer:
 
 
 async def create_server(
+    services: "ServiceContainer",
     port: int = 60887,
     test_mode: bool = False,
-    mcp_manager: Any | None = None,
-    config: Any | None = None,
-    session_manager: LocalSessionManager | None = None,
 ) -> HTTPServer:
     """
     Create HTTP server instance.
 
     Args:
+        services: ServiceContainer holding dependencies
         port: Port to listen on
         test_mode: Enable test mode
-        mcp_manager: MCP client manager
-        config: Daemon configuration
-        session_manager: Local session manager
 
     Returns:
         Configured HTTPServer instance
     """
     return HTTPServer(
+        services=services,
         port=port,
         test_mode=test_mode,
-        mcp_manager=mcp_manager,
-        config=config,
-        session_manager=session_manager,
     )