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

gobby/hooks/event_handlers.py

@@ -17,7 +17,9 @@ 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.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
@@ -27,6 +29,16 @@ if TYPE_CHECKING:
     from gobby.workflows.hooks import WorkflowHookHandler
 
 
+EDIT_TOOLS = {
+    "write_file",
+    "replace",
+    "edit_file",
+    "notebook_edit",
+    "edit",
+    "write",
+}
+
+
 class EventHandlers:
     """
     Manages event handler registration and dispatch.
@@ -48,6 +60,8 @@ class EventHandlers:
         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,
         get_machine_id: Callable[[], str] | None = None,
         resolve_project_id: Callable[[str | None, str | None], str] | None = None,
         logger: logging.Logger | None = None,
@@ -65,6 +79,8 @@ class EventHandlers:
             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
             get_machine_id: Function to get machine ID
             resolve_project_id: Function to resolve project ID from cwd
             logger: Optional logger instance
@@ -78,6 +94,8 @@ class EventHandlers:
         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._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__)
@@ -213,9 +231,27 @@ class EventHandlers:
                             self.logger.warning(f"Workflow error: {e}")
 
                     # Build system message (terminal display only)
-                    system_message = "\nSession enhanced by gobby."
+                    # Display #N format if seq_num available, fallback to UUID
+                    session_ref = (
+                        f"#{existing_session.seq_num}" if existing_session.seq_num else session_id
+                    )
+                    system_message = f"\nGobby Session Ref: {session_ref}"
+                    system_message += f"\nGobby Session ID: {session_id}"
+                    system_message += f"\nExternal ID: {external_id}"
                     if parent_session_id:
                         context_parts.append(f"Parent session: {parent_session_id}")
+
+                    # Add active lifecycle workflows
+                    if wf_response.metadata and "discovered_workflows" in wf_response.metadata:
+                        wf_list = wf_response.metadata["discovered_workflows"]
+                        if wf_list:
+                            system_message += "\nActive workflows:"
+                            for w in wf_list:
+                                source = "project" if w["is_project"] else "global"
+                                system_message += (
+                                    f"\n  - {w['name']} ({source}, priority={w['priority']})"
+                                )
+
                     if wf_response.system_message:
                         system_message += f"\n\n{wf_response.system_message}"
 
@@ -312,7 +348,25 @@ class EventHandlers:
             context_parts.append(f"Parent session: {parent_session_id}")
 
         # Build system message (terminal display only)
-        system_message = "\nSession enhanced by gobby."
+        # Fetch session to get seq_num for #N display
+        session_ref = session_id  # fallback
+        if session_id and self._session_storage:
+            session_obj = self._session_storage.get(session_id)
+            if session_obj and session_obj.seq_num:
+                session_ref = f"#{session_obj.seq_num}"
+        system_message = f"\nGobby Session Ref: {session_ref}"
+        system_message += f"\nGobby Session ID: {session_id}"
+        system_message += f"\nExternal ID: {external_id}"
+
+        # Add active lifecycle workflows
+        if wf_response.metadata and "discovered_workflows" in wf_response.metadata:
+            wf_list = wf_response.metadata["discovered_workflows"]
+            if wf_list:
+                system_message += "\nActive workflows:"
+                for w in wf_list:
+                    source = "project" if w["is_project"] else "global"
+                    system_message += f"\n  - {w['name']} ({source}, priority={w['priority']})"
+
         if wf_response.system_message:
             system_message += f"\n\n{wf_response.system_message}"
 
@@ -322,6 +376,11 @@ class EventHandlers:
             context_parts.append("\n## Active Task Context\n")
             context_parts.append(f"You are working on task: {task_title} ({event.task_id})")
 
+        # Inject core skills if enabled (restoring from parent session if available)
+        skill_context = self._build_skill_injection_context(parent_session_id)
+        if skill_context:
+            context_parts.append(skill_context)
+
         # Build metadata with terminal context (filter out nulls)
         metadata: dict[str, Any] = {
             "session_id": session_id,
@@ -434,6 +493,112 @@ class EventHandlers:
 
         return HookResponse(decision="allow")
 
+    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.
+
+        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
+        if self._skills_config.injection_format == "none":
+            return None
+
+        # Get alwaysApply skills
+        try:
+            core_skills = self._skill_manager.discover_core_skills()
+            always_apply_skills = [s for s in core_skills if s.is_always_apply()]
+
+            # Get restored skills from parent session
+            restored_skills = self._restore_skills_from_parent(parent_session_id)
+
+            # 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 based on format
+            if self._skills_config.injection_format == "summary":
+                return (
+                    "\n## Available Skills\n"
+                    f"The following skills are always available: {', '.join(skill_names)}\n"
+                    "Use the /skill-name syntax to invoke them."
+                )
+            elif self._skills_config.injection_format == "full":
+                parts = ["\n## Available Skills\n"]
+                # Build a map of always_apply skills for quick lookup
+                always_apply_map = {s.name: s for s in always_apply_skills}
+                # Iterate over combined skill_names list (always_apply + restored)
+                for skill_name in skill_names:
+                    parts.append(f"### {skill_name}")
+                    # Get description from always_apply skill if available
+                    if skill_name in always_apply_map:
+                        skill = always_apply_map[skill_name]
+                        if skill.description:
+                            parts.append(skill.description)
+                    parts.append("")
+                return "\n".join(parts)
+            else:
+                return None
+
+        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"
+            import re
+
+            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 []
+
     # ==================== AGENT HANDLERS ====================
 
     def handle_before_agent(self, event: HookEvent) -> HookResponse:
@@ -548,6 +713,27 @@ class EventHandlers:
         status = "FAIL" if is_failure else "OK"
         if session_id:
             self.logger.debug(f"AFTER_TOOL [{status}]: {tool_name}, session {session_id}")
+
+            # Track edits for session high-water mark
+            # Only if tool succeeded, matches edit tools, and session has claimed a task
+            if (
+                not is_failure
+                and tool_name
+                and tool_name.lower() in EDIT_TOOLS
+                and self._session_storage
+                and self._task_manager
+            ):
+                try:
+                    # Check if session has any claimed tasks in progress
+                    claimed_tasks = self._task_manager.list_tasks(
+                        assignee=session_id, status="in_progress", limit=1
+                    )
+                    if claimed_tasks:
+                        self._session_storage.mark_had_edits(session_id)
+                        self.logger.debug(f"Marked session {session_id} as had_edits")
+                except Exception as e:
+                    self.logger.warning(f"Failed to track edit history: {e}")
+
         else:
             self.logger.debug(f"AFTER_TOOL [{status}]: {tool_name}")
 

gobby/hooks/hook_manager.py

@@ -17,7 +17,7 @@ Example:
 
     manager = HookManager(
         daemon_host="localhost",
-        daemon_port=8765
+        daemon_port=60887
     )
 
     result = manager.execute(
@@ -42,6 +42,7 @@ from gobby.hooks.events import HookEvent, HookEventType, HookResponse
 from gobby.hooks.health_monitor import HealthMonitor
 from gobby.hooks.plugins import PluginLoader, run_plugin_handlers
 from gobby.hooks.session_coordinator import SessionCoordinator
+from gobby.hooks.skill_manager import HookSkillManager
 from gobby.hooks.webhooks import WebhookDispatcher
 from gobby.memory.manager import MemoryManager
 from gobby.sessions.manager import SessionManager
@@ -79,6 +80,21 @@ class HookManager:
     - TranscriptProcessor: JSONL parsing and analysis
     - WorkflowEngine: Handles session handoff and LLM-powered summaries
 
+    Session ID Mapping:
+        There are two types of session IDs used throughout the system:
+
+        | Name                     | Description                                    | Example                                |
+        |--------------------------|------------------------------------------------|----------------------------------------|
+        | external_id / session_id | CLI's internal session UUID (Claude Code, etc) | 683bc13e-091e-4911-9e59-e7546e385cd6   |
+        | _platform_session_id     | Gobby's internal session.id (database PK)      | 0ebb2c00-0f58-4c39-9370-eba1833dec33   |
+
+        The _platform_session_id is derived from session_manager.get_session_id(external_id, source)
+        which looks up Gobby's session by the CLI's external_id.
+
+        When injecting into agent context:
+        - "session_id" in response.metadata = Gobby's _platform_session_id (for MCP tool calls)
+        - "external_id" in response.metadata = CLI's session UUID (for transcript lookups)
+
     Attributes:
         daemon_host: Host for daemon communication
         daemon_port: Port for daemon communication
@@ -89,7 +105,7 @@ class HookManager:
     def __init__(
         self,
         daemon_host: str = "localhost",
-        daemon_port: int = 8765,
+        daemon_port: int = 60887,
         llm_service: "LLMService | None" = None,
         config: Any | None = None,
         log_file: str | None = None,
@@ -212,7 +228,7 @@ class HookManager:
         )
 
         if not memory_config:
-            from gobby.config.app import MemoryConfig
+            from gobby.config.persistence import MemoryConfig
 
             memory_config = MemoryConfig()
 
@@ -300,7 +316,7 @@ class HookManager:
         if self._config and hasattr(self._config, "hook_extensions"):
             webhooks_config = self._config.hook_extensions.webhooks
         if not webhooks_config:
-            from gobby.config.app import WebhooksConfig
+            from gobby.config.extensions import WebhooksConfig
 
             webhooks_config = WebhooksConfig()
         self._webhook_dispatcher = WebhookDispatcher(webhooks_config)
@@ -350,6 +366,9 @@ class HookManager:
             logger=self.logger,
         )
 
+        # Skill manager for core skill injection
+        self._skill_manager = HookSkillManager()
+
         # Event handlers (delegated to EventHandlers module)
         self._event_handlers = EventHandlers(
             session_manager=self._session_manager,
@@ -361,6 +380,8 @@ class HookManager:
             task_manager=self._task_manager,
             session_coordinator=self._session_coordinator,
             message_manager=self._message_manager,
+            skill_manager=self._skill_manager,
+            skills_config=self._config.skills if self._config else None,
             get_machine_id=self.get_machine_id,
             resolve_project_id=self._resolve_project_id,
             logger=self.logger,
@@ -620,6 +641,31 @@ class HookManager:
         try:
             response = handler(event)
 
+            # Copy session metadata from event to response for adapter injection
+            # The adapter reads response.metadata to inject session info into agent context
+            if event.metadata.get("_platform_session_id"):
+                response.metadata["session_id"] = event.metadata["_platform_session_id"]
+            if event.session_id:  # external_id (e.g., Claude Code's session UUID)
+                response.metadata["external_id"] = event.session_id
+            if event.machine_id:
+                response.metadata["machine_id"] = event.machine_id
+            if event.project_id:
+                response.metadata["project_id"] = event.project_id
+            # Copy terminal context if present
+            for key in [
+                "terminal_term_program",
+                "terminal_tty",
+                "terminal_parent_pid",
+                "terminal_iterm_session_id",
+                "terminal_term_session_id",
+                "terminal_kitty_window_id",
+                "terminal_tmux_pane",
+                "terminal_vscode_terminal_id",
+                "terminal_alacritty_socket",
+            ]:
+                if event.metadata.get(key):
+                    response.metadata[key] = event.metadata[key]
+
             # Merge workflow context if present
             if workflow_context:
                 if response.context:

gobby/hooks/plugins.py

@@ -23,7 +23,7 @@ from typing import TYPE_CHECKING, Any
 from gobby.hooks.events import HookEvent, HookEventType, HookResponse
 
 if TYPE_CHECKING:
-    from gobby.config.app import PluginsConfig
+    from gobby.config.extensions import PluginsConfig
 
 logger = logging.getLogger(__name__)
 

gobby/hooks/skill_manager.py

@@ -0,0 +1,130 @@
+"""HookSkillManager - Skill management for the hook system.
+
+This module provides skill discovery and management for the hook system,
+allowing hooks to access and use skills (Agent Skills specification).
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from gobby.skills.loader import SkillLoader
+from gobby.skills.parser import ParsedSkill
+
+logger = logging.getLogger(__name__)
+
+
+class HookSkillManager:
+    """Manage skills for the hook system.
+
+    Provides discovery and access to core skills bundled with Gobby,
+    as well as project-specific skills.
+
+    Example usage:
+        ```python
+        from gobby.hooks.skill_manager import HookSkillManager
+
+        manager = HookSkillManager()
+        skills = manager.discover_core_skills()
+
+        # Get a specific skill
+        tasks_skill = manager.get_skill_by_name("gobby-tasks")
+        ```
+    """
+
+    def __init__(self) -> None:
+        """Initialize the skill manager."""
+        # Path to built-in skills: src/gobby/hooks/ -> src/gobby/install/shared/skills/
+        self._base_dir = Path(__file__).parent.parent
+        self._core_skills_path = self._base_dir / "install" / "shared" / "skills"
+
+        # Loader for parsing skills (use "filesystem" for bundled core skills)
+        self._loader = SkillLoader(default_source_type="filesystem")
+
+        # Cache of discovered skills
+        self._core_skills: list[ParsedSkill] | None = None
+
+    def discover_core_skills(self) -> list[ParsedSkill]:
+        """Discover built-in skills from install/shared/skills/.
+
+        Returns:
+            List of ParsedSkill objects for all valid core skills.
+            Invalid skills are logged as warnings and skipped.
+        """
+        if self._core_skills is not None:
+            return self._core_skills
+
+        if not self._core_skills_path.exists():
+            logger.warning(f"Core skills path not found: {self._core_skills_path}")
+            self._core_skills = []
+            return self._core_skills
+
+        # Load all skills from the core directory
+        self._core_skills = self._loader.load_directory(
+            self._core_skills_path,
+            validate=True,
+        )
+
+        logger.debug(f"Discovered {len(self._core_skills)} core skills")
+        return self._core_skills
+
+    def get_skill_by_name(self, name: str) -> ParsedSkill | None:
+        """Get a skill by name.
+
+        Args:
+            name: The skill name to look up.
+
+        Returns:
+            ParsedSkill if found, None otherwise.
+        """
+        # Ensure skills are discovered
+        skills = self.discover_core_skills()
+
+        for skill in skills:
+            if skill.name == name:
+                return skill
+
+        return None
+
+    def refresh(self) -> None:
+        """Clear the cache and rediscover skills."""
+        self._core_skills = None
+
+    def recommend_skills(self, category: str | None = None) -> list[str]:
+        """Recommend relevant skills based on task category.
+
+        Maps task categories to relevant core skills that would be helpful
+        for that type of work.
+
+        Args:
+            category: Task category (e.g., 'code', 'docs', 'test', 'config')
+
+        Returns:
+            List of skill names that are relevant for the category
+        """
+        # Category to skill mappings
+        category_skills: dict[str, list[str]] = {
+            "code": ["gobby-tasks", "gobby-expand", "gobby-worktrees"],
+            "test": ["gobby-tasks", "gobby-expand"],
+            "docs": ["gobby-tasks", "gobby-plan"],
+            "config": ["gobby-tasks", "gobby-mcp"],
+            "refactor": ["gobby-tasks", "gobby-expand", "gobby-worktrees"],
+            "planning": ["gobby-tasks", "gobby-plan", "gobby-expand"],
+            "research": ["gobby-tasks", "gobby-memory"],
+        }
+
+        # Get skills for the category (or empty list if no match)
+        recommended = category_skills.get(category or "", [])
+
+        # Always include alwaysApply skills
+        skills = self.discover_core_skills()
+        always_apply = [s.name for s in skills if s.is_always_apply()]
+
+        # Combine and dedupe while preserving order
+        result = list(always_apply)
+        for skill_name in recommended:
+            if skill_name not in result:
+                result.append(skill_name)
+
+        return result

gobby/hooks/webhooks.py

@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING, Any
 import httpx
 
 if TYPE_CHECKING:
-    from gobby.config.app import WebhookEndpointConfig, WebhooksConfig
+    from gobby.config.extensions import WebhookEndpointConfig, WebhooksConfig
     from gobby.hooks.events import HookEvent
 
 logger = logging.getLogger(__name__)

gobby/install/claude/hooks/hook_dispatcher.py

@@ -23,7 +23,7 @@ from pathlib import Path
 # No longer need to import HookManager - we call it via HTTP daemon instead
 
 # Default daemon configuration
-DEFAULT_DAEMON_PORT = 8765
+DEFAULT_DAEMON_PORT = 60887
 DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
 
 
@@ -31,10 +31,10 @@ def get_daemon_url() -> str:
     """Get the daemon HTTP URL from config file.
 
     Reads daemon_port from ~/.gobby/config.yaml if it exists,
-    otherwise uses the default port 8765.
+    otherwise uses the default port 60887.
 
     Returns:
-        Full daemon URL like http://localhost:8765
+        Full daemon URL like http://localhost:60887
     """
     config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
 
@@ -308,7 +308,7 @@ def main() -> int:
                 "input_data": input_data,
                 "source": "claude",  # Required: identifies CLI source
             },
-            timeout=30.0,  # Generous timeout for hook processing
+            timeout=90.0,  # LLM-powered hooks (pre-compact summary) need more time
         )
 
         if response.status_code == 200:

gobby/install/codex/hooks/hook_dispatcher.py

@@ -19,7 +19,7 @@ from typing import Any
 
 import httpx
 
-DEFAULT_DAEMON_PORT = 8765
+DEFAULT_DAEMON_PORT = 60887
 DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
 DEBUG_ENV_VAR = "GOBBY_CODEX_NOTIFY_DEBUG"