gobby 0.2.5__py3-none-any.whl

gobby/hooks/session_coordinator.py

@@ -0,0 +1,396 @@
+"""
+Session coordinator module for session lifecycle management.
+
+This module is extracted from hook_manager.py using Strangler Fig pattern.
+It provides centralized session registration tracking, message caching,
+and lifecycle coordination.
+
+Classes:
+    SessionCoordinator: Coordinates session lifecycle operations.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.storage.agents import LocalAgentRunManager
+    from gobby.storage.sessions import LocalSessionManager
+    from gobby.storage.worktrees import LocalWorktreeManager
+
+
+class SessionCoordinator:
+    """
+    Coordinates session lifecycle operations.
+
+    Provides centralized tracking for:
+    - Session registration with daemon
+    - Title synthesis status
+    - Agent message caching between hooks
+    - Session lifecycle transitions (completion, cleanup)
+
+    Thread-safe for concurrent operations.
+
+    Extracted from HookManager to separate session coordination concerns.
+    """
+
+    def __init__(
+        self,
+        session_storage: LocalSessionManager | None = None,
+        message_processor: Any | None = None,
+        agent_run_manager: LocalAgentRunManager | None = None,
+        worktree_manager: LocalWorktreeManager | None = None,
+        logger: logging.Logger | None = None,
+    ) -> None:
+        """
+        Initialize SessionCoordinator.
+
+        Args:
+            session_storage: LocalSessionManager for session queries
+            message_processor: SessionMessageProcessor for message registration
+            agent_run_manager: LocalAgentRunManager for agent run completion
+            worktree_manager: LocalWorktreeManager for worktree release
+            logger: Optional logger instance
+        """
+        self._session_storage = session_storage
+        self._message_processor = message_processor
+        self._agent_run_manager = agent_run_manager
+        self._worktree_manager = worktree_manager
+        self.logger = logger or logging.getLogger(__name__)
+
+        # Session registration tracking (to avoid noisy logs)
+        # Tracks which sessions have been registered with daemon
+        self._registered_sessions: set[str] = set()
+        self._registered_sessions_lock = threading.Lock()
+
+        # Session title synthesis tracking
+        # Tracks which sessions have had titles synthesized
+        self._title_synthesized_sessions: set[str] = set()
+        self._title_synthesized_lock = threading.Lock()
+
+        # Agent message cache (session_id -> (message, timestamp))
+        # Used to pass agent responses from stop hook to post-tool-use hook
+        self._agent_message_cache: dict[str, tuple[str, float]] = {}
+        self._cache_lock = threading.Lock()
+
+        # Lock for session lookups to prevent race conditions (double firing)
+        self._lookup_lock = threading.Lock()
+
+    # ==================== REGISTRATION TRACKING ====================
+
+    def register_session(self, session_id: str) -> None:
+        """
+        Mark a session as registered with the daemon.
+
+        Args:
+            session_id: The session ID to register
+        """
+        with self._registered_sessions_lock:
+            self._registered_sessions.add(session_id)
+
+    def unregister_session(self, session_id: str) -> None:
+        """
+        Remove a session from registration tracking.
+
+        Args:
+            session_id: The session ID to unregister
+        """
+        with self._registered_sessions_lock:
+            self._registered_sessions.discard(session_id)
+
+    def is_registered(self, session_id: str) -> bool:
+        """
+        Check if a session is registered with the daemon.
+
+        Args:
+            session_id: The session ID to check
+
+        Returns:
+            True if registered, False otherwise
+        """
+        with self._registered_sessions_lock:
+            return session_id in self._registered_sessions
+
+    def clear_registrations(self) -> None:
+        """Clear all session registrations."""
+        with self._registered_sessions_lock:
+            self._registered_sessions.clear()
+
+    # ==================== TITLE SYNTHESIS TRACKING ====================
+
+    def mark_title_synthesized(self, session_id: str) -> None:
+        """
+        Mark a session as having had its title synthesized.
+
+        Args:
+            session_id: The session ID to mark
+        """
+        with self._title_synthesized_lock:
+            self._title_synthesized_sessions.add(session_id)
+
+    def is_title_synthesized(self, session_id: str) -> bool:
+        """
+        Check if a session has had its title synthesized.
+
+        Args:
+            session_id: The session ID to check
+
+        Returns:
+            True if title has been synthesized, False otherwise
+        """
+        with self._title_synthesized_lock:
+            return session_id in self._title_synthesized_sessions
+
+    # ==================== MESSAGE CACHING ====================
+
+    def cache_agent_message(self, session_id: str, message: str) -> None:
+        """
+        Cache an agent message for later retrieval.
+
+        Args:
+            session_id: The session ID
+            message: The message to cache
+        """
+        with self._cache_lock:
+            self._agent_message_cache[session_id] = (message, time.time())
+
+    def get_cached_message(
+        self, session_id: str, max_age_seconds: float | None = None
+    ) -> str | None:
+        """
+        Get a cached agent message.
+
+        Args:
+            session_id: The session ID
+            max_age_seconds: Optional maximum age in seconds. If set, returns None
+                           for messages older than this.
+
+        Returns:
+            The cached message, or None if not found or expired
+        """
+        with self._cache_lock:
+            if session_id not in self._agent_message_cache:
+                return None
+
+            message, timestamp = self._agent_message_cache[session_id]
+
+            if max_age_seconds is not None:
+                age = time.time() - timestamp
+                if age > max_age_seconds:
+                    return None
+
+            return message
+
+    def clear_cached_message(self, session_id: str) -> None:
+        """
+        Clear a cached agent message.
+
+        Args:
+            session_id: The session ID
+        """
+        with self._cache_lock:
+            self._agent_message_cache.pop(session_id, None)
+
+    # ==================== LOOKUP LOCK ====================
+
+    def get_lookup_lock(self) -> threading.Lock:
+        """
+        Get the lookup lock for preventing race conditions.
+
+        Returns:
+            The lookup lock
+        """
+        return self._lookup_lock
+
+    # ==================== LIFECYCLE OPERATIONS ====================
+
+    def reregister_active_sessions(self, limit: int = 1000) -> int:
+        """
+        Re-register active sessions with the message processor.
+
+        Called during initialization to restore message processing
+        for sessions that were active before a daemon restart.
+
+        Args:
+            limit: Maximum number of sessions to re-register (default 1000).
+                   Sessions beyond this limit will not be re-registered.
+
+        Returns:
+            Number of sessions successfully re-registered
+        """
+        if not self._message_processor or not self._session_storage:
+            return 0
+
+        try:
+            # Query active sessions from storage
+            active_sessions = self._session_storage.list(status="active", limit=limit)
+            registered_count = 0
+
+            for session in active_sessions:
+                jsonl_path = getattr(session, "jsonl_path", None)
+                if not jsonl_path:
+                    continue
+
+                try:
+                    # Determine source from session (default to claude)
+                    source = getattr(session, "source", "claude") or "claude"
+                    self._message_processor.register_session(session.id, jsonl_path, source=source)
+                    registered_count += 1
+                except Exception as e:
+                    self.logger.warning(f"Failed to re-register session {session.id}: {e}")
+
+            if registered_count > 0:
+                self.logger.info(
+                    f"Re-registered {registered_count} active sessions with message processor"
+                )
+
+            return registered_count
+
+        except Exception as e:
+            self.logger.warning(f"Failed to re-register active sessions: {e}")
+            return 0
+
+    def start_agent_run(self, agent_run_id: str) -> bool:
+        """
+        Mark an agent run as started when its terminal-mode session begins.
+
+        Called from handle_session_start when a pre-created session with an
+        agent_run_id is detected. This updates the status from 'pending' to
+        'running' and sets the started_at timestamp.
+
+        Args:
+            agent_run_id: The agent run ID to start
+
+        Returns:
+            True if the run was started, False otherwise
+        """
+        if not self._agent_run_manager:
+            self.logger.debug("start_agent_run: No agent_run_manager, skipping")
+            return False
+
+        try:
+            agent_run = self._agent_run_manager.get(agent_run_id)
+            if not agent_run:
+                self.logger.warning(f"Agent run {agent_run_id} not found")
+                return False
+
+            # Only start if currently pending
+            if agent_run.status != "pending":
+                self.logger.debug(
+                    f"Agent run {agent_run_id} not pending (status={agent_run.status}), skipping start"
+                )
+                return False
+
+            self._agent_run_manager.start(agent_run_id)
+            self.logger.info(f"Started agent run {agent_run_id}")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to start agent run {agent_run_id}: {e}")
+            return False
+
+    def complete_agent_run(self, session: Any) -> None:
+        """
+        Complete an agent run when its terminal-mode session ends.
+
+        Updates the agent run status based on session outcome, removes the
+        agent from the in-memory running registry, and releases any worktrees
+        associated with the session.
+
+        Args:
+            session: Session object with agent_run_id
+        """
+        # Check for agent_run_id
+        agent_run_id = getattr(session, "agent_run_id", None)
+        if not agent_run_id:
+            return
+
+        self.logger.debug(f"Completing agent run {agent_run_id} for session {session.id}")
+
+        # Remove from in-memory running agents registry
+        try:
+            from gobby.agents.registry import get_running_agent_registry
+
+            running_registry = get_running_agent_registry()
+            removed = running_registry.remove(agent_run_id)
+            if removed:
+                self.logger.debug(f"Unregistered running agent {agent_run_id} from registry")
+        except Exception as e:
+            self.logger.warning(f"Failed to unregister agent from running registry: {e}")
+
+        if not self._agent_run_manager:
+            return
+
+        try:
+            agent_run = self._agent_run_manager.get(agent_run_id)
+            if not agent_run:
+                self.logger.warning(f"Agent run {agent_run_id} not found")
+                return
+
+            # Skip if already completed
+            if agent_run.status in ("success", "error", "timeout", "cancelled"):
+                self.logger.debug(
+                    f"Agent run {agent_run_id} already in terminal state: {agent_run.status}"
+                )
+                return
+
+            # Use summary as result if available
+            result = (
+                getattr(session, "summary_markdown", None)
+                or getattr(session, "compact_markdown", None)
+                or ""
+            )
+
+            # Mark as success
+            self._agent_run_manager.complete(
+                run_id=agent_run_id,
+                result=result,
+                tool_calls_count=0,
+                turns_used=0,
+            )
+            self.logger.info(f"Completed agent run {agent_run_id}")
+
+        except Exception as e:
+            self.logger.error(f"Failed to complete agent run {agent_run_id}: {e}")
+
+        # Release any worktrees associated with this session
+        try:
+            self.release_session_worktrees(session.id)
+        except Exception as e:
+            self.logger.warning(f"Failed to release worktrees for session {session.id}: {e}")
+
+    def release_session_worktrees(self, session_id: str) -> None:
+        """
+        Release all worktrees claimed by a session.
+
+        When a session ends, any worktrees it claimed should be released
+        so they can be reused by other sessions.
+
+        Args:
+            session_id: The session ID whose worktrees to release
+        """
+        if not self._worktree_manager:
+            return
+
+        try:
+            # Find worktrees owned by this session
+            worktrees = self._worktree_manager.list_worktrees(agent_session_id=session_id)
+
+            for worktree in worktrees:
+                try:
+                    # Release the worktree (sets agent_session_id to NULL)
+                    self._worktree_manager.release(worktree.id)
+                    self.logger.debug(f"Released worktree {worktree.id} from session {session_id}")
+                except Exception as e:
+                    self.logger.warning(f"Failed to release worktree {worktree.id}: {e}")
+
+            if worktrees:
+                self.logger.info(f"Released {len(worktrees)} worktree(s) from session {session_id}")
+        except Exception as e:
+            self.logger.warning(f"Failed to list worktrees for session {session_id}: {e}")
+
+
+__all__ = ["SessionCoordinator"]

gobby/hooks/verification_runner.py

@@ -0,0 +1,268 @@
+"""Verification runner for git hooks.
+
+Executes configured verification commands (lint, typecheck, tests, etc.) for git hook stages.
+"""
+
+import logging
+import subprocess  # nosec B404 - subprocess needed for verification commands
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from gobby.config.features import HooksConfig, HookStageConfig, ProjectVerificationConfig
+from gobby.utils.project_context import get_hooks_config, get_verification_config
+
+logger = logging.getLogger(__name__)
+
+# Default timeout for verification commands (5 minutes)
+DEFAULT_TIMEOUT = 300
+
+
+@dataclass
+class VerificationResult:
+    """Result of running a single verification command."""
+
+    name: str
+    command: str
+    success: bool
+    exit_code: int | None = None
+    stdout: str = ""
+    stderr: str = ""
+    duration_ms: int = 0
+    skipped: bool = False
+    skip_reason: str | None = None
+    error: str | None = None
+
+
+@dataclass
+class StageResult:
+    """Result of running all verification commands for a hook stage."""
+
+    stage: str
+    success: bool
+    results: list[VerificationResult] = field(default_factory=list)
+    skipped: bool = False
+    skip_reason: str | None = None
+
+    @property
+    def failed_count(self) -> int:
+        """Number of failed verifications."""
+        return sum(1 for r in self.results if not r.success and not r.skipped)
+
+    @property
+    def passed_count(self) -> int:
+        """Number of passed verifications."""
+        return sum(1 for r in self.results if r.success)
+
+    @property
+    def skipped_count(self) -> int:
+        """Number of skipped verifications."""
+        return sum(1 for r in self.results if r.skipped)
+
+
+def run_command(
+    name: str,
+    command: str,
+    cwd: Path,
+    timeout: int = DEFAULT_TIMEOUT,
+) -> VerificationResult:
+    """Execute a verification command and return the result.
+
+    Args:
+        name: Name of the verification (e.g., 'lint', 'unit_tests').
+        command: The command to execute.
+        cwd: Working directory for the command.
+        timeout: Maximum execution time in seconds.
+
+    Returns:
+        VerificationResult with command output and status.
+    """
+    start_time = time.time()
+
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,  # nosec B602 - user-configured verification commands require shell features
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=cwd,
+        )
+
+        duration_ms = int((time.time() - start_time) * 1000)
+
+        return VerificationResult(
+            name=name,
+            command=command,
+            success=result.returncode == 0,
+            exit_code=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            duration_ms=duration_ms,
+        )
+
+    except subprocess.TimeoutExpired:
+        duration_ms = int((time.time() - start_time) * 1000)
+        return VerificationResult(
+            name=name,
+            command=command,
+            success=False,
+            duration_ms=duration_ms,
+            error=f"Command timed out after {timeout} seconds",
+        )
+
+    except Exception as e:
+        duration_ms = int((time.time() - start_time) * 1000)
+        return VerificationResult(
+            name=name,
+            command=command,
+            success=False,
+            duration_ms=duration_ms,
+            error=str(e),
+        )
+
+
+class VerificationRunner:
+    """Runs verification commands for git hooks.
+
+    Reads configuration from project.json and executes the appropriate
+    commands for each hook stage (pre-commit, pre-push, pre-merge).
+    """
+
+    def __init__(
+        self,
+        verification_config: ProjectVerificationConfig | None = None,
+        hooks_config: HooksConfig | None = None,
+        cwd: Path | None = None,
+    ):
+        """Initialize VerificationRunner.
+
+        Args:
+            verification_config: Verification commands configuration.
+            hooks_config: Git hooks configuration.
+            cwd: Working directory (auto-detected if None).
+        """
+        self.cwd = cwd or Path.cwd()
+        self.verification_config = verification_config
+        self.hooks_config = hooks_config
+
+    @classmethod
+    def from_project(cls, cwd: Path | None = None) -> "VerificationRunner":
+        """Create a VerificationRunner from project configuration.
+
+        Args:
+            cwd: Working directory to search for project config.
+
+        Returns:
+            VerificationRunner instance with loaded configuration.
+        """
+        cwd = cwd or Path.cwd()
+        verification_config = get_verification_config(cwd)
+        hooks_config = get_hooks_config(cwd)
+        return cls(
+            verification_config=verification_config,
+            hooks_config=hooks_config,
+            cwd=cwd,
+        )
+
+    def run_stage(self, stage: str) -> StageResult:
+        """Run all verification commands for a hook stage.
+
+        Args:
+            stage: Hook stage name (e.g., 'pre-commit', 'pre-push', 'pre-merge').
+
+        Returns:
+            StageResult with all verification results.
+        """
+        # Check if hooks are configured
+        if not self.hooks_config:
+            return StageResult(
+                stage=stage,
+                success=True,
+                skipped=True,
+                skip_reason="No hooks configured in project.json",
+            )
+
+        # Get stage configuration
+        stage_config = self.hooks_config.get_stage(stage)
+
+        # Check if stage is enabled
+        if not stage_config.enabled:
+            return StageResult(
+                stage=stage,
+                success=True,
+                skipped=True,
+                skip_reason=f"Hook stage '{stage}' is disabled",
+            )
+
+        # Check if any commands are configured for this stage
+        if not stage_config.run:
+            return StageResult(
+                stage=stage,
+                success=True,
+                skipped=True,
+                skip_reason=f"No commands configured for '{stage}'",
+            )
+
+        # Check if verification config exists
+        if not self.verification_config:
+            return StageResult(
+                stage=stage,
+                success=True,
+                skipped=True,
+                skip_reason="No verification commands defined in project.json",
+            )
+
+        # Run each command
+        results: list[VerificationResult] = []
+        overall_success = True
+
+        for cmd_name in stage_config.run:
+            command = self.verification_config.get_command(cmd_name)
+
+            if not command:
+                # Command not defined - skip with warning
+                results.append(
+                    VerificationResult(
+                        name=cmd_name,
+                        command="",
+                        success=True,
+                        skipped=True,
+                        skip_reason=f"Command '{cmd_name}' not defined in verification config",
+                    )
+                )
+                continue
+
+            # Run the command
+            result = run_command(
+                name=cmd_name,
+                command=command,
+                cwd=self.cwd,
+                timeout=stage_config.timeout,
+            )
+            results.append(result)
+
+            if not result.success:
+                overall_success = False
+                if stage_config.fail_fast:
+                    # Stop on first failure
+                    break
+
+        return StageResult(
+            stage=stage,
+            success=overall_success,
+            results=results,
+        )
+
+    def get_stage_config(self, stage: str) -> HookStageConfig | None:
+        """Get configuration for a hook stage.
+
+        Args:
+            stage: Hook stage name.
+
+        Returns:
+            HookStageConfig if configured, None otherwise.
+        """
+        if not self.hooks_config:
+            return None
+        return self.hooks_config.get_stage(stage)