tiphys.context

  1"""
  2Centralized application context (Composition Root pattern).
  3
  4Replaces scattered global singletons with explicit dependency injection.
  5All components receive dependencies through constructor parameters.
  6"""
  7
  8from __future__ import annotations
  9
 10from contextvars import ContextVar
 11from dataclasses import dataclass, field
 12from typing import TYPE_CHECKING
 13
 14if TYPE_CHECKING:
 15    from castor import Castor, CheckpointStore
 16
 17    from tiphys.config import TiphysConfig
 18    from tiphys.hooks.manager import HookManager
 19    from tiphys.kernel.bridge import CheckpointHITLBridge, HITLBridge
 20    from tiphys.kernel.budget import SessionBudgetManager
 21    from tiphys.kernel.guard import TiphysGuard
 22    from tiphys.kernel.runner import CastorAgentRunner
 23    from tiphys.plugins.registry import PluginRegistry
 24    from tiphys.routing.registry import AgentRegistry
 25    from tiphys.routing.resolver import RouteResolver
 26    from tiphys.scheduler.service import TaskScheduler
 27    from tiphys.security.dm_policy import DMPolicyEnforcer
 28    from tiphys.security.pairing import PairingManager
 29    from tiphys.security.policy import PolicyEngine
 30    from tiphys.server.bus import EventBus
 31    from tiphys.tools.base import ToolRegistry
 32
 33
 34@dataclass
 35class AppContext:
 36    """
 37    Centralized application context holding all shared services.
 38
 39    This is the Composition Root pattern - the single location where
 40    the entire object graph is assembled. All components receive the
 41    context they need through constructor parameters.
 42
 43    Usage:
 44        # At startup (in bootstrap.py):
 45        ctx = AppContext(config=load_config())
 46        set_context(ctx)
 47
 48        # In components:
 49        def __init__(self, context: AppContext):
 50            self.event_bus = context.event_bus
 51            self.tools = context.tool_registry
 52    """
 53
 54    config: TiphysConfig
 55
 56    # Core services - created with defaults if not provided
 57    event_bus: EventBus = field(default=None)  # type: ignore[assignment]
 58    hook_manager: HookManager = field(default=None)  # type: ignore[assignment]
 59    tool_registry: ToolRegistry = field(default=None)  # type: ignore[assignment]
 60    agent_registry: AgentRegistry = field(default=None)  # type: ignore[assignment]
 61
 62    # Optional services - created in __post_init__ with cross-wiring
 63    plugin_registry: PluginRegistry | None = None
 64    route_resolver: RouteResolver | None = None
 65    policy_engine: PolicyEngine | None = None
 66    scheduler: TaskScheduler | None = None
 67    pairing_manager: PairingManager | None = None
 68    dm_enforcer: DMPolicyEnforcer | None = None
 69
 70    # Castor kernel services (L1 Guard)
 71    castor_guard: TiphysGuard | None = None
 72    session_budget_mgr: SessionBudgetManager | None = None
 73    hitl_bridge: HITLBridge | None = None
 74
 75    # Castor kernel services (L2 Deep Guard)
 76    castor_kernel: Castor | None = None
 77    checkpoint_store: CheckpointStore | None = None
 78    checkpoint_hitl_bridge: CheckpointHITLBridge | None = None
 79    castor_agent_runner: CastorAgentRunner | None = None
 80
 81    def __post_init__(self) -> None:
 82        """Wire up cross-component dependencies."""
 83        # Import here to avoid circular imports
 84        from tiphys.hooks.manager import HookManager
 85        from tiphys.plugins.registry import PluginRegistry
 86        from tiphys.routing.registry import AgentRegistry
 87        from tiphys.routing.resolver import RouteResolver
 88        from tiphys.scheduler.service import TaskScheduler
 89        from tiphys.security.dm_policy import DMPolicyEnforcer
 90        from tiphys.security.pairing import PairingManager
 91        from tiphys.security.policy import create_default_policy
 92        from tiphys.server.bus import EventBus
 93        from tiphys.tools.base import ToolRegistry
 94
 95        # Create core services if not provided
 96        if self.event_bus is None:
 97            self.event_bus = EventBus()
 98
 99        if self.hook_manager is None:
100            self.hook_manager = HookManager()
101
102        if self.tool_registry is None:
103            self.tool_registry = ToolRegistry()
104
105        if self.agent_registry is None:
106            self.agent_registry = AgentRegistry()
107
108        # Create optional services with cross-wiring
109        if self.plugin_registry is None:
110            self.plugin_registry = PluginRegistry(hook_manager=self.hook_manager)
111
112        if self.route_resolver is None:
113            self.route_resolver = RouteResolver(agent_registry=self.agent_registry)
114
115        if self.policy_engine is None:
116            self.policy_engine = create_default_policy(self.config)
117
118        if self.scheduler is None:
119            self.scheduler = TaskScheduler(context=self)
120
121        if self.pairing_manager is None:
122            self.pairing_manager = PairingManager()
123
124        if self.dm_enforcer is None:
125            self.dm_enforcer = DMPolicyEnforcer(pairing_manager=self.pairing_manager)
126
127    async def startup(self) -> None:
128        """
129        Initialize all components.
130
131        Called during application lifespan startup.
132        Emits GatewayBootEvent to notify hooks.
133        """
134        from tiphys.hooks.events import GatewayBootEvent
135
136        if self.scheduler:
137            await self.scheduler.start()
138
139        await self.hook_manager.emit(GatewayBootEvent(config=self.config.model_dump()))
140
141    async def shutdown(self) -> None:
142        """
143        Clean shutdown of all components.
144
145        Called during application lifespan shutdown.
146        Emits GatewayShutdownEvent to notify hooks.
147        """
148        from tiphys.hooks.events import GatewayShutdownEvent
149
150        if self.scheduler:
151            await self.scheduler.stop()
152
153        await self.hook_manager.emit(GatewayShutdownEvent())
154
155
156# Context variable for request-scoped access
157_current_context: ContextVar[AppContext | None] = ContextVar("app_context", default=None)
158
159
160def get_context() -> AppContext:
161    """
162    Get the current application context.
163
164    Returns:
165        The current AppContext.
166
167    Raises:
168        RuntimeError: If context has not been initialized.
169    """
170    ctx = _current_context.get()
171    if ctx is None:
172        raise RuntimeError(
173            "AppContext not initialized. "
174            "Call set_context() first, or use create_app_context() from bootstrap."
175        )
176    return ctx
177
178
179def set_context(ctx: AppContext) -> None:
180    """
181    Set the current application context.
182
183    Args:
184        ctx: The AppContext to set as current.
185    """
186    _current_context.set(ctx)
187
188
189def has_context() -> bool:
190    """
191    Check if an application context is set.
192
193    Returns:
194        True if context is available, False otherwise.
195    """
196    return _current_context.get() is not None