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

gobby/hooks/event_handlers/_session.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import re
 from typing import TYPE_CHECKING, Any
 
 from gobby.hooks.event_handlers._base import EventHandlersBase
@@ -36,12 +35,18 @@ class SessionEventHandlerMixin(EventHandlersBase):
         )
 
         # Step 0: Check if this is a pre-created session (terminal mode agent)
-        # When we spawn an agent in terminal mode, we pass --session-id <internal_id>
-        # to Claude, so external_id here might actually be our internal session ID
+        # Two cases:
+        # 1. Claude: We pass --session-id <internal_id>, so external_id IS our internal ID
+        # 2. Gemini: We pass GOBBY_SESSION_ID env var, hook_dispatcher includes it in terminal_context
         existing_session = None
+        terminal_context = input_data.get("terminal_context")
+        gobby_session_id_from_env = (
+            terminal_context.get("gobby_session_id") if terminal_context else None
+        )
+
         if self._session_storage:
             try:
-                # Try to find by internal ID first (terminal mode case)
+                # Try to find by internal ID first (Claude case - external_id IS internal_id)
                 existing_session = self._session_storage.get(external_id)
                 if existing_session:
                     return self._handle_pre_created_session(
@@ -53,7 +58,32 @@ class SessionEventHandlerMixin(EventHandlersBase):
                         cwd=cwd,
                     )
             except Exception as e:
-                self.logger.debug(f"No pre-created session found: {e}")
+                self.logger.debug(f"No pre-created session found by external_id: {e}")
+
+            # Gemini case: Look up by gobby_session_id from terminal_context
+            if gobby_session_id_from_env and not existing_session:
+                try:
+                    existing_session = self._session_storage.get(gobby_session_id_from_env)
+                    if existing_session:
+                        self.logger.info(
+                            f"Found pre-created session {gobby_session_id_from_env} via "
+                            f"terminal_context, updating external_id to {external_id}"
+                        )
+                        # Update the session's external_id with CLI's native session_id
+                        self._session_storage.update(
+                            gobby_session_id_from_env,
+                            external_id=external_id,
+                        )
+                        return self._handle_pre_created_session(
+                            existing_session=existing_session,
+                            external_id=external_id,
+                            transcript_path=transcript_path,
+                            cli_source=cli_source,
+                            event=event,
+                            cwd=cwd,
+                        )
+                except Exception as e:
+                    self.logger.debug(f"No pre-created session found by gobby_session_id: {e}")
 
         # Step 1: Find parent session
         # Check env vars first (spawned agent case), then handoff (source='clear')
@@ -76,8 +106,7 @@ class SessionEventHandlerMixin(EventHandlersBase):
                 self.logger.warning(f"Error finding parent session: {e}")
 
         # Step 2: Register new session with parent if found
-        # Extract terminal context (injected by hook_dispatcher for terminal correlation)
-        terminal_context = input_data.get("terminal_context")
+        # terminal_context already extracted in Step 0
         # Parse agent_depth as int if provided
         agent_depth_val = 0
         if agent_depth:
@@ -142,17 +171,14 @@ class SessionEventHandlerMixin(EventHandlersBase):
             except Exception as e:
                 self.logger.warning(f"Workflow error: {e}")
 
-        # Build additional context (task and skill injection)
+        # Build additional context (task context)
+        # Note: Skill injection is now handled by workflows via inject_context action
         additional_context: list[str] = []
         if event.task_id:
             task_title = event.metadata.get("_task_title", "Unknown Task")
             additional_context.append("\n## Active Task Context\n")
             additional_context.append(f"You are working on task: {task_title} ({event.task_id})")
 
-        skill_context = self._build_skill_injection_context(parent_session_id)
-        if skill_context:
-            additional_context.append(skill_context)
-
         # Fetch session to get seq_num for #N display
         session_obj = None
         if session_id and self._session_storage:
@@ -313,7 +339,12 @@ class SessionEventHandlerMixin(EventHandlersBase):
 
         # Auto-activate workflow if specified for this session
         if existing_session.workflow_name and session_id:
-            self._auto_activate_workflow(existing_session.workflow_name, session_id, cwd)
+            self._auto_activate_workflow(
+                existing_session.workflow_name,
+                session_id,
+                cwd,
+                variables=existing_session.step_variables,
+            )
 
         # Update event metadata
         event.metadata["_platform_session_id"] = session_id
@@ -454,120 +485,3 @@ class SessionEventHandlerMixin(EventHandlersBase):
             system_message=system_message,
             metadata=metadata,
         )
-
-    def _build_skill_injection_context(self, parent_session_id: str | None = None) -> str | None:
-        """Build skill injection context for session-start.
-
-        Combines alwaysApply skills with skills restored from parent session.
-        Uses per-skill injection_format to control how each skill is injected:
-        - "summary": name + description only
-        - "full" or "content": name + description + full content
-
-        Args:
-            parent_session_id: Optional parent session ID to restore skills from
-
-        Returns context string with available skills if injection is enabled,
-        or None if disabled.
-        """
-        # Skip if no skill manager or config
-        if not self._skill_manager or not self._skills_config:
-            return None
-
-        # Check if injection is enabled
-        if not self._skills_config.inject_core_skills:
-            return None
-
-        # Check injection format (global config level)
-        if self._skills_config.injection_format == "none":
-            return None
-
-        # Get alwaysApply skills (efficiently via column query)
-        try:
-            always_apply_skills = self._skill_manager.discover_core_skills()
-
-            # Get restored skills from parent session
-            restored_skills = self._restore_skills_from_parent(parent_session_id)
-
-            # Build a map of always_apply skills for quick lookup
-            always_apply_map = {s.name: s for s in always_apply_skills}
-
-            # Combine: alwaysApply skills + any additional restored skills
-            skill_names = [s.name for s in always_apply_skills]
-            for skill_name in restored_skills:
-                if skill_name not in skill_names:
-                    skill_names.append(skill_name)
-
-            if not skill_names:
-                return None
-
-            # Build context with per-skill injection format
-            parts = ["\n## Available Skills\n"]
-
-            for skill_name in skill_names:
-                skill = always_apply_map.get(skill_name)
-                if not skill:
-                    # Restored skill not in always_apply - just list the name
-                    parts.append(f"- **{skill_name}**")
-                    continue
-
-                # Determine injection format for this skill
-                # Use per-skill injection_format, fallback to global config
-                skill_format = skill.injection_format or self._skills_config.injection_format
-
-                if skill_format in ("full", "content"):
-                    # Full injection: name + description + content
-                    parts.append(f"### {skill_name}")
-                    if skill.description:
-                        parts.append(f"*{skill.description}*\n")
-                    if skill.content:
-                        parts.append(skill.content)
-                    parts.append("")
-                else:
-                    # Summary injection: name + description only
-                    if skill.description:
-                        parts.append(f"- **{skill_name}**: {skill.description}")
-                    else:
-                        parts.append(f"- **{skill_name}**")
-
-            return "\n".join(parts)
-
-        except Exception as e:
-            self.logger.warning(f"Failed to build skill injection context: {e}")
-            return None
-
-    def _restore_skills_from_parent(self, parent_session_id: str | None) -> list[str]:
-        """Restore active skills from parent session's handoff context.
-
-        Args:
-            parent_session_id: Parent session ID to restore from
-
-        Returns:
-            List of skill names from the parent session
-        """
-        if not parent_session_id or not self._session_storage:
-            return []
-
-        try:
-            parent = self._session_storage.get(parent_session_id)
-            if not parent:
-                return []
-
-            compact_md = getattr(parent, "compact_markdown", None)
-            if not compact_md:
-                return []
-
-            # Parse active skills from markdown
-            # Format: "### Active Skills\nSkills available: skill1, skill2, skill3"
-
-            match = re.search(r"### Active Skills\s*\nSkills available:\s*([^\n]+)", compact_md)
-            if match:
-                skills_str = match.group(1).strip()
-                skills = [s.strip() for s in skills_str.split(",") if s.strip()]
-                self.logger.debug(f"Restored {len(skills)} skills from parent session")
-                return skills
-
-            return []
-
-        except Exception as e:
-            self.logger.warning(f"Failed to restore skills from parent: {e}")
-            return []

gobby/hooks/events.py

@@ -63,6 +63,9 @@ class SessionSource(str, Enum):
     CODEX = "codex"
     CLAUDE_SDK = "claude_sdk"
     ANTIGRAVITY = "antigravity"  # Antigravity IDE (uses Claude Code format)
+    CURSOR = "cursor"
+    WINDSURF = "windsurf"
+    COPILOT = "copilot"
 
 
 @dataclass
@@ -144,75 +147,120 @@ EVENT_TYPE_CLI_SUPPORT: dict[HookEventType, dict[str, str | None]] = {
         "claude": "SessionStart",
         "gemini": "SessionStart",
         "codex": "thread/started",
+        "cursor": "SessionStart",
+        "windsurf": "SessionStart",
+        "copilot": "SessionStart",
     },
     HookEventType.SESSION_END: {
         "claude": "SessionEnd",
         "gemini": "SessionEnd",
         "codex": "thread/archive",
+        "cursor": "SessionEnd",
+        "windsurf": "SessionEnd",
+        "copilot": "SessionEnd",
     },
     HookEventType.BEFORE_AGENT: {
         "claude": "UserPromptSubmit",
         "gemini": "BeforeAgent",
         "codex": "turn/started",
+        "cursor": "UserPromptSubmit",
+        "windsurf": "UserPromptSubmit",
+        "copilot": "UserPromptSubmit",
     },
     HookEventType.AFTER_AGENT: {
         "claude": "Stop",
         "gemini": "AfterAgent",
         "codex": "turn/completed",
+        "cursor": "Stop",
+        "windsurf": "Stop",
+        "copilot": "Stop",
     },
     HookEventType.STOP: {
         "claude": "Stop",
         "gemini": None,
         "codex": None,
+        "cursor": "Stop",
+        "windsurf": "Stop",
+        "copilot": "Stop",
     },
     HookEventType.BEFORE_TOOL: {
         "claude": "PreToolUse",
         "gemini": "BeforeTool",
         "codex": "requestApproval",
+        "cursor": "PreToolUse",
+        "windsurf": "PreToolUse",
+        "copilot": "PreToolUse",
     },
     HookEventType.AFTER_TOOL: {
         "claude": "PostToolUse",
         "gemini": "AfterTool",
         "codex": "item/completed",
+        "cursor": "PostToolUse",
+        "windsurf": "PostToolUse",
+        "copilot": "PostToolUse",
     },
     HookEventType.BEFORE_TOOL_SELECTION: {
         "claude": None,
         "gemini": "BeforeToolSelection",
         "codex": None,
+        "cursor": None,
+        "windsurf": None,
+        "copilot": None,
     },
     HookEventType.BEFORE_MODEL: {
         "claude": None,
         "gemini": "BeforeModel",
         "codex": None,
+        "cursor": None,
+        "windsurf": None,
+        "copilot": None,
     },
     HookEventType.AFTER_MODEL: {
         "claude": None,
         "gemini": "AfterModel",
         "codex": None,
+        "cursor": None,
+        "windsurf": None,
+        "copilot": None,
     },
     HookEventType.PRE_COMPACT: {
         "claude": "PreCompact",
         "gemini": "PreCompress",
         "codex": None,
+        "cursor": "PreCompact",
+        "windsurf": "PreCompact",
+        "copilot": "PreCompact",
     },
     HookEventType.SUBAGENT_START: {
         "claude": "SubagentStart",
         "gemini": None,
         "codex": None,
+        "cursor": "SubagentStart",
+        "windsurf": "SubagentStart",
+        "copilot": "SubagentStart",
     },
     HookEventType.SUBAGENT_STOP: {
         "claude": "SubagentStop",
         "gemini": None,
         "codex": None,
+        "cursor": "SubagentStop",
+        "windsurf": "SubagentStop",
+        "copilot": "SubagentStop",
     },
     HookEventType.PERMISSION_REQUEST: {
         "claude": "PermissionRequest",
         "gemini": None,
         "codex": None,
+        "cursor": "PermissionRequest",
+        "windsurf": "PermissionRequest",
+        "copilot": "PermissionRequest",
     },
     HookEventType.NOTIFICATION: {
         "claude": "Notification",
         "gemini": "Notification",
         "codex": None,
+        "cursor": "Notification",
+        "windsurf": "Notification",
+        "copilot": "Notification",
     },
 }

gobby/hooks/hook_manager.py

@@ -256,11 +256,33 @@ class HookManager:
         # But 'TemplateEngine' constructor takes optional dirs.
         self._template_engine = TemplateEngine()
 
+        # Skill manager for core skill injection
+        # Initialized before ActionExecutor so it can be passed through
+        self._skill_manager = HookSkillManager()
+
         # Get websocket_server from broadcaster if available
         websocket_server = None
         if self.broadcaster and hasattr(self.broadcaster, "websocket_server"):
             websocket_server = self.broadcaster.websocket_server
 
+        # Initialize pipeline executor for run_pipeline action support
+        self._pipeline_executor = None
+        try:
+            from gobby.storage.pipelines import LocalPipelineExecutionManager
+            from gobby.workflows.pipeline_executor import PipelineExecutor
+
+            # Resolve project_id dynamically since it's not stored on the instance
+            project_id = self._resolve_project_id(None, None)
+            pipeline_execution_manager = LocalPipelineExecutionManager(self._database, project_id)
+            self._pipeline_executor = PipelineExecutor(
+                db=self._database,
+                execution_manager=pipeline_execution_manager,
+                llm_service=self._llm_service,
+                loader=self._workflow_loader,
+            )
+        except Exception as e:
+            logging.getLogger(__name__).debug(f"Pipeline executor not available: {e}")
+
         self._action_executor = ActionExecutor(
             db=self._database,
             session_manager=self._session_storage,
@@ -278,6 +300,9 @@ class HookManager:
             progress_tracker=self._progress_tracker,
             stuck_detector=self._stuck_detector,
             websocket_server=websocket_server,
+            skill_manager=self._skill_manager,
+            pipeline_executor=self._pipeline_executor,
+            workflow_loader=self._workflow_loader,
         )
         self._workflow_engine = WorkflowEngine(
             loader=self._workflow_loader,
@@ -366,9 +391,6 @@ class HookManager:
             logger=self.logger,
         )
 
-        # Skill manager for core skill injection
-        self._skill_manager = HookSkillManager()
-
         # Track sessions that have received full metadata injection
         # Key: "{platform_session_id}:{source}" - cleared on daemon restart
         self._injected_sessions: set[str] = set()

gobby/install/copilot/hooks/hook_dispatcher.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Hook Dispatcher - Routes GitHub Copilot CLI hooks to HookManager.
+
+This is a thin wrapper script that receives hook calls from Copilot CLI
+and routes them to the appropriate handler via HookManager.
+
+Usage:
+    hook_dispatcher.py --type sessionStart < input.json > output.json
+    hook_dispatcher.py --type preToolUse --debug < input.json > output.json
+
+Exit Codes:
+    0 - Success
+    1 - General error (logged, continues)
+    2 - Block action (Copilot interprets as deny)
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Default daemon configuration
+DEFAULT_DAEMON_PORT = 60887
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+
+
+def get_daemon_url() -> str:
+    """Get the daemon HTTP URL from config file."""
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    if config_path.exists():
+        try:
+            import yaml
+
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+            port = config.get("daemon_port", DEFAULT_DAEMON_PORT)
+        except Exception:
+            port = DEFAULT_DAEMON_PORT
+    else:
+        port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def get_terminal_context() -> dict[str, str | int | None]:
+    """Capture terminal/process context for session correlation."""
+    context: dict[str, str | int | None] = {}
+
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+    context["vscode_terminal_id"] = os.environ.get("VSCODE_GIT_ASKPASS_NODE")
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Copilot CLI Hook Dispatcher")
+    parser.add_argument(
+        "--type",
+        required=True,
+        help="Hook type (e.g., sessionStart, preToolUse)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+def check_daemon_running(timeout: float = 0.5) -> bool:
+    """Check if gobby daemon is active and responding."""
+    try:
+        import httpx
+
+        daemon_url = get_daemon_url()
+        response = httpx.get(
+            f"{daemon_url}/admin/status",
+            timeout=timeout,
+            follow_redirects=False,
+        )
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def main() -> int:
+    """Main dispatcher execution."""
+    try:
+        args = parse_arguments()
+    except (argparse.ArgumentError, SystemExit):
+        print(json.dumps({}))
+        return 2
+
+    hook_type = args.type
+    debug_mode = args.debug
+
+    # Check if daemon is running
+    if not check_daemon_running():
+        critical_hooks = {"sessionStart", "sessionEnd"}
+        if hook_type in critical_hooks:
+            print(
+                f"Gobby daemon is not running. Start with 'gobby start' before continuing. "
+                f"({hook_type} requires daemon for session state management)",
+                file=sys.stderr,
+            )
+            return 2
+        else:
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0
+
+    import logging
+
+    logger = logging.getLogger("gobby.hooks.dispatcher.copilot")
+    if debug_mode:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING, handlers=[])
+
+    try:
+        input_data = json.load(sys.stdin)
+
+        if hook_type == "sessionStart":
+            input_data["terminal_context"] = get_terminal_context()
+
+        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+
+        if debug_mode:
+            logger.debug(f"Input data: {input_data}")
+
+    except json.JSONDecodeError as e:
+        if debug_mode:
+            logger.error(f"JSON decode error: {e}")
+        print(json.dumps({}))
+        return 2
+
+    import httpx
+
+    daemon_url = get_daemon_url()
+    try:
+        response = httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": hook_type,
+                "input_data": input_data,
+                "source": "copilot",
+            },
+            timeout=90.0,
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+
+            if debug_mode:
+                logger.debug(f"Output data: {result}")
+
+            # Check for block decision
+            if result.get("continue") is False or result.get("permissionDecision") == "deny":
+                reason = result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            if result and result != {}:
+                print(json.dumps(result))
+
+            return 0
+        else:
+            error_detail = response.text
+            logger.error(
+                f"Daemon returned error: status={response.status_code}, detail={error_detail}"
+            )
+            print(json.dumps({"status": "error", "message": f"Daemon error: {error_detail}"}))
+            return 1
+
+    except Exception as e:
+        logger.error(f"Hook execution failed: {e}", exc_info=True)
+        print(json.dumps({"status": "error", "message": str(e)}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())