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

gobby/servers/routes/admin.py

@@ -175,6 +175,17 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             except Exception as e:
                 logger.warning(f"Failed to get memory stats: {e}")
 
+        # Get artifact statistics
+        artifact_stats = {"count": 0}
+        if server.session_manager is not None:
+            try:
+                from gobby.storage.artifacts import LocalArtifactManager
+
+                artifact_manager = LocalArtifactManager(server.session_manager.db)
+                artifact_stats["count"] = artifact_manager.count_artifacts()
+            except Exception as e:
+                logger.warning(f"Failed to get artifact stats: {e}")
+
         # Get skills statistics
         skills_stats: dict[str, Any] = {"total": 0}
         if server._internal_manager:
@@ -231,6 +242,7 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             "sessions": session_stats,
             "tasks": task_stats,
             "memory": memory_stats,
+            "artifacts": artifact_stats,
             "skills": skills_stats,
             "plugins": plugin_stats,
             "response_time_ms": response_time_ms,

gobby/servers/routes/mcp/endpoints/execution.py

@@ -318,12 +318,16 @@ async def get_tool_schema(
                 schema = registry.get_schema(tool_name)
                 if schema:
                     response_time_ms = (time.perf_counter() - start_time) * 1000
-                    return {
-                        "name": tool_name,
+                    # Build response with description only if present
+                    result: dict[str, Any] = {
+                        "name": schema.get("name", tool_name),
+                        "inputSchema": schema.get("inputSchema"),
                         "server": server_name,
-                        "inputSchema": schema,
                         "response_time_ms": response_time_ms,
                     }
+                    if schema.get("description"):
+                        result["description"] = schema["description"]
+                    return result
                 raise HTTPException(
                     status_code=404,
                     detail={
@@ -340,15 +344,19 @@ async def get_tool_schema(
 
         # Get from external MCP server
         try:
-            schema = await server.mcp_manager.get_tool_input_schema(server_name, tool_name)
+            tool_info = await server.mcp_manager.get_tool_info(server_name, tool_name)
             response_time_ms = (time.perf_counter() - start_time) * 1000
 
-            return {
-                "name": tool_name,
+            # Build response with description only if present
+            response: dict[str, Any] = {
+                "name": tool_info.get("name", tool_name),
+                "inputSchema": tool_info.get("inputSchema"),
                 "server": server_name,
-                "inputSchema": schema,
                 "response_time_ms": response_time_ms,
             }
+            if tool_info.get("description"):
+                response["description"] = tool_info["description"]
+            return response
 
         except (KeyError, ValueError) as e:
             # Tool or server not found - 404

gobby/servers/routes/mcp/endpoints/registry.py

@@ -255,17 +255,17 @@ async def refresh_mcp_tools(
                     try:
                         session = await server.mcp_manager.ensure_connected(server_name)
                         tools_result = await session.list_tools()
-                        for t in tools_result.tools:
+                        for mcp_tool in tools_result.tools:
                             schema = None
-                            if hasattr(t, "inputSchema"):
-                                if hasattr(t.inputSchema, "model_dump"):
-                                    schema = t.inputSchema.model_dump()
-                                elif isinstance(t.inputSchema, dict):
-                                    schema = t.inputSchema
+                            if hasattr(mcp_tool, "inputSchema"):
+                                if hasattr(mcp_tool.inputSchema, "model_dump"):
+                                    schema = mcp_tool.inputSchema.model_dump()
+                                elif isinstance(mcp_tool.inputSchema, dict):
+                                    schema = mcp_tool.inputSchema
                             tools.append(
                                 {
-                                    "name": getattr(t, "name", ""),
-                                    "description": getattr(t, "description", ""),
+                                    "name": getattr(mcp_tool, "name", ""),
+                                    "description": getattr(mcp_tool, "description", ""),
                                     "inputSchema": schema,
                                 }
                             )

gobby/servers/routes/mcp/hooks.py

@@ -19,6 +19,44 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Map hook types to hookEventName for additionalContext
+# Only these hook types support hookSpecificOutput in Claude Code
+HOOK_EVENT_NAME_MAP: dict[str, str] = {
+    "pre-tool-use": "PreToolUse",
+    "post-tool-use": "PostToolUse",
+    "post-tool-use-failure": "PostToolUse",
+    "user-prompt-submit": "UserPromptSubmit",
+}
+
+
+def _graceful_error_response(hook_type: str, error_msg: str) -> dict[str, Any]:
+    """
+    Create a graceful degradation response for hook errors.
+
+    Instead of returning HTTP 500 (which causes Claude Code to show a confusing
+    "hook failed" warning), return a successful response that:
+    1. Allows the tool to proceed (continue=True)
+    2. Explains the error via additionalContext (so agents understand what happened)
+
+    This prevents agents from being confused by non-fatal hook errors.
+    """
+    response: dict[str, Any] = {
+        "continue": True,
+        "decision": "approve",
+    }
+
+    # Add helpful context for supported hook types
+    hook_event_name = HOOK_EVENT_NAME_MAP.get(hook_type)
+    if hook_event_name:
+        response["hookSpecificOutput"] = {
+            "hookEventName": hook_event_name,
+            "additionalContext": (
+                f"Gobby hook error (non-fatal): {error_msg}. Tool execution will proceed normally."
+            ),
+        }
+
+    return response
+
 
 def create_hooks_router(server: "HTTPServer") -> APIRouter:
     """
@@ -51,6 +89,7 @@ def create_hooks_router(server: "HTTPServer") -> APIRouter:
         start_time = time.perf_counter()
         metrics.inc_counter("http_requests_total")
         metrics.inc_counter("hooks_total")
+        hook_type: str | None = None  # Track for error handling
 
         try:
             # Parse request
@@ -109,27 +148,35 @@ def create_hooks_router(server: "HTTPServer") -> APIRouter:
                 return result
 
             except ValueError as e:
+                # Invalid request - still return graceful response
                 metrics.inc_counter("hooks_failed_total")
                 logger.warning(
                     f"Invalid hook request: {hook_type}",
                     extra={"hook_type": hook_type, "error": str(e)},
                 )
-                raise HTTPException(status_code=400, detail=str(e)) from e
+                return _graceful_error_response(hook_type, str(e))
 
             except Exception as e:
+                # Hook execution error - return graceful response so tool proceeds
+                # This prevents confusing "hook failed" warnings in Claude Code
                 metrics.inc_counter("hooks_failed_total")
                 logger.error(
                     f"Hook execution failed: {hook_type}",
                     exc_info=True,
                     extra={"hook_type": hook_type},
                 )
-                raise HTTPException(status_code=500, detail=str(e)) from e
+                return _graceful_error_response(hook_type, str(e))
 
         except HTTPException:
+            # Re-raise 400 errors (bad request) - these are client errors
             raise
         except Exception as e:
+            # Outer exception - return graceful response to prevent CLI warning
             metrics.inc_counter("hooks_failed_total")
             logger.error("Hook endpoint error", exc_info=True)
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            if hook_type:
+                return _graceful_error_response(hook_type, str(e))
+            # Fallback: return basic success to prevent CLI hook failure
+            return {"continue": True, "decision": "approve"}
 
     return router

gobby/servers/websocket.py

@@ -10,6 +10,7 @@ Local-first version: Authentication is optional (defaults to always-allow).
 import asyncio
 import json
 import logging
+import os
 from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
 from datetime import UTC, datetime
@@ -21,6 +22,7 @@ from websockets.datastructures import Headers
 from websockets.exceptions import ConnectionClosed, ConnectionClosedError
 from websockets.http11 import Response
 
+from gobby.agents.registry import get_running_agent_registry
 from gobby.mcp_proxy.manager import MCPClientManager
 
 logger = logging.getLogger(__name__)
@@ -256,6 +258,9 @@ class WebSocketServer:
         elif msg_type == "stop_request":
             await self._handle_stop_request(websocket, data)
 
+        elif msg_type == "terminal_input":
+            await self._handle_terminal_input(websocket, data)
+
         else:
             logger.warning(f"Unknown message type: {msg_type}")
             await self._send_error(websocket, f"Unknown message type: {msg_type}")
@@ -496,11 +501,62 @@ class WebSocketServer:
             )
 
             logger.info(f"Stop requested for session {session_id} via WebSocket")
-
         except Exception as e:
             logger.error(f"Error handling stop request: {e}")
             await self._send_error(websocket, f"Failed to signal stop: {str(e)}")
 
+    async def _handle_terminal_input(self, websocket: Any, data: dict[str, Any]) -> None:
+        """
+        Handle terminal input for a running agent.
+
+        Message format:
+        {
+            "type": "terminal_input",
+            "run_id": "uuid",
+            "data": "raw input string"
+        }
+
+        Args:
+            websocket: Client WebSocket connection
+            data: Parsed terminal input message
+        """
+        run_id = data.get("run_id")
+        input_data = data.get("data")
+
+        if not run_id or input_data is None:
+            # Don't send error for every keystroke if malformed, just log debug
+            logger.debug(
+                f"Invalid terminal_input: run_id={run_id}, data_len={len(str(input_data)) if input_data else 0}"
+            )
+            return
+
+        if not isinstance(input_data, str):
+            # input_data must be a string to encode; log and skip non-strings
+            logger.debug(
+                f"Invalid terminal_input type: run_id={run_id}, data_type={type(input_data).__name__}"
+            )
+            return
+
+        registry = get_running_agent_registry()
+        # Look up by run_id
+        agent = registry.get(run_id)
+
+        if not agent:
+            # Be silent on missing agent to avoid spamming errors if frontend is out of sync
+            # or if agent just died.
+            return
+
+        if agent.master_fd is None:
+            logger.warning(f"Agent {run_id} has no PTY master_fd")
+            return
+
+        try:
+            # Write key/input to PTY off the event loop
+            encoded_data = input_data.encode("utf-8")
+            await asyncio.to_thread(os.write, agent.master_fd, encoded_data)
+        except OSError as e:
+            logger.warning(f"Failed to write to agent {run_id} PTY: {e}")
+
     async def broadcast(self, message: dict[str, Any]) -> None:
         """
         Broadcast message to all connected clients.

gobby/sessions/analyzer.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import UTC, datetime
 from typing import Any
 
 from gobby.sessions.transcripts.base import TranscriptParser
@@ -32,8 +32,8 @@ class HandoffContext:
     key_decisions: list[str] | None = None
     active_worktree: dict[str, Any] | None = None
     """Worktree context if session is operating in a worktree."""
-    active_skills: list[str] = field(default_factory=list)
-    """List of skill names that were active/injected during the session."""
+    # Note: active_skills field removed - redundant with _build_skill_injection_context()
+    # which already handles skill restoration on session start
 
 
 class TranscriptAnalyzer:
@@ -207,7 +207,7 @@ class TranscriptAnalyzer:
                 context.git_commits.append(
                     {
                         "command": command,
-                        "timestamp": datetime.now().isoformat(),  # Approx time
+                        "timestamp": datetime.now(UTC).isoformat(),  # Approx time
                     }
                 )
 

gobby/sessions/manager.py

@@ -82,6 +82,8 @@ class SessionManager:
         git_branch: str | None = None,
         project_path: str | None = None,
         terminal_context: dict[str, Any] | None = None,
+        workflow_name: str | None = None,
+        agent_depth: int = 0,
     ) -> str:
         """
         Register new session with local storage.
@@ -96,6 +98,9 @@ class SessionManager:
             title: Optional session title/summary
             git_branch: Optional git branch name
             project_path: Optional project path (for git extraction if git_branch not provided)
+            terminal_context: Optional terminal context for correlation
+            workflow_name: Optional workflow to auto-activate for this session
+            agent_depth: Depth in agent hierarchy (0 = root session)
 
         Returns:
             session_id (database UUID)
@@ -125,6 +130,8 @@ class SessionManager:
                 git_branch=git_branch,
                 parent_session_id=parent_session_id,
                 terminal_context=terminal_context,
+                workflow_name=workflow_name,
+                agent_depth=agent_depth,
             )
 
             session_id: str = session.id
@@ -143,6 +150,8 @@ class SessionManager:
                     "project_id": project_id,
                     "title": title,
                     "git_branch": git_branch,
+                    "workflow_name": workflow_name,
+                    "agent_depth": agent_depth,
                 }
 
             self.logger.debug(f"Registered session {session_id} (external_id={external_id})")

gobby/sessions/transcripts/gemini.py

@@ -38,13 +38,34 @@ class GeminiTranscriptParser:
     ) -> list[dict[str, Any]]:
         """
         Extract last N user<>agent message pairs.
+
+        Handles both Gemini CLI's type-based format and legacy role/content format.
         """
         messages: list[dict[str, str]] = []
         for turn in reversed(turns):
-            # Adapt to generic turn structure
-            # Assumes generic schema: {"role": "...", "content": "..."} or nested in "message"
-            role = turn.get("role") or turn.get("message", {}).get("role")
-            content = turn.get("content") or turn.get("message", {}).get("content")
+            # Handle Gemini CLI's type-based format
+            event_type = turn.get("type")
+            role: str | None = None
+            content: str | Any = None
+
+            if event_type == "message":
+                role = turn.get("role")
+                content = turn.get("content")
+            elif event_type in ("init", "result"):
+                # Skip non-message events
+                continue
+            elif event_type == "tool_use":
+                # Include tool calls as assistant messages
+                role = "assistant"
+                tool_name = turn.get("tool_name") or turn.get("function_name", "unknown")
+                content = f"[Tool call: {tool_name}]"
+            elif event_type == "tool_result":
+                # Skip tool results for message extraction
+                continue
+            else:
+                # Fallback: legacy format with role/content at top level
+                role = turn.get("role") or turn.get("message", {}).get("role")
+                content = turn.get("content") or turn.get("message", {}).get("content")
 
             if role in ["user", "model", "assistant"]:
                 norm_role = "assistant" if role == "model" else role
@@ -53,7 +74,7 @@ class GeminiTranscriptParser:
                 if isinstance(content, list):
                     content = " ".join(str(part) for part in content)
 
-                messages.insert(0, {"role": norm_role, "content": str(content)})
+                messages.insert(0, {"role": norm_role, "content": str(content or "")})
                 if len(messages) >= num_pairs * 2:
                     break
         return messages
@@ -78,6 +99,13 @@ class GeminiTranscriptParser:
     def parse_line(self, line: str, index: int) -> ParsedMessage | None:
         """
         Parse a single line from the transcript JSONL.
+
+        Gemini CLI uses type-based events in JSONL format:
+        - {"type":"init", "session_id":"...", "model":"...", "timestamp":"..."}
+        - {"type":"message", "role":"user"|"model", "content":"...", ...}
+        - {"type":"tool_use", "tool_name":"Bash", "parameters":{...}, ...}
+        - {"type":"tool_result", "tool_id":"...", "status":"success", "output":"...", ...}
+        - {"type":"result", "status":"success", "stats":{...}, ...}
         """
         if not line.strip():
             return None
@@ -95,45 +123,83 @@ class GeminiTranscriptParser:
         except ValueError:
             timestamp = datetime.now(UTC)
 
-        # Determine role and content
-        # Check top-level or nested 'message'
-        role = data.get("role")
-        content = data.get("content")
+        # Handle Gemini CLI's type-based event format
+        event_type = data.get("type")
 
-        if not role and "message" in data:
-            msg = data["message"]
-            role = msg.get("role")
-            content = msg.get("content")
+        # Initialize defaults
+        role: str | None = None
+        content: str | Any = ""
+        content_type = "text"
+        tool_name: str | None = None
+        tool_input: dict[str, Any] | None = None
+        tool_result: dict[str, Any] | None = None
 
-        if not role:
-            # Try type field common in other schemas
-            msg_type = data.get("type")
-            if msg_type == "user":
-                role = "user"
-            elif msg_type == "model":
-                role = "assistant"
+        if event_type == "init":
+            # Session initialization event - skip or treat as system
+            return None
 
-        # Normalize role
-        if role == "model":
+        elif event_type == "message":
+            # Message event with role (user/model)
+            role = data.get("role")
+            content = data.get("content", "")
+
+        elif event_type in ("user", "model"):
+            # Role specified directly in type field
+            role = event_type
+            content = data.get("content", "")
+
+        elif event_type == "tool_use":
+            # Tool invocation event
             role = "assistant"
+            content_type = "tool_use"
+            tool_name = data.get("tool_name") or data.get("function_name")
+            tool_input = data.get("parameters") or data.get("args") or data.get("input")
+            content = f"Tool call: {tool_name}"
+
+        elif event_type == "tool_result":
+            # Tool result event
+            role = "tool"
+            content_type = "tool_result"
+            tool_name = data.get("tool_name")
+            output = data.get("output") or data.get("result") or ""
+            tool_result = {"output": output, "status": data.get("status", "unknown")}
+            content = str(output)[:500] if output else ""  # Truncate long outputs
+
+        elif event_type == "result":
+            # Final result event - skip
+            return None
 
-        if not role:
-            # Maybe a tool result or system event
-            if "tool_result" in data:
+        else:
+            # Fallback: try legacy format with role/content at top level
+            role = data.get("role")
+            content = data.get("content")
+
+            # Check nested message structure
+            if not role and "message" in data:
+                msg = data["message"]
+                role = msg.get("role")
+                content = msg.get("content")
+
+            # Handle tool_result at top level (legacy)
+            if not role and "tool_result" in data:
                 role = "tool"
+                content_type = "tool_result"
                 content = str(data["tool_result"])
-            else:
-                # Unknown or uninteresting line
+
+            # If still no role in fallback, skip this line
+            if not role:
                 return None
 
-        # Normalize content
-        content_type = "text"
-        tool_name = None
-        tool_input = None
-        tool_result = None
+        # Validate role is set - skip lines with missing role
+        if not role:
+            return None
+
+        # Normalize role: model -> assistant
+        if role == "model":
+            role = "assistant"
 
+        # Normalize content - handle list content (rich parts)
         if isinstance(content, list):
-            # Handle potential rich content
             text_parts: list[str] = []
             for part in content:
                 if isinstance(part, str):
@@ -141,7 +207,7 @@ class GeminiTranscriptParser:
                 elif isinstance(part, dict):
                     if "text" in part:
                         text_parts.append(str(part["text"]))
-                    # Check for tool calls
+                    # Check for tool calls embedded in content
                     if "functionCall" in part:
                         content_type = "tool_use"
                         tool_name = part["functionCall"].get("name")

gobby/skills/parser.py

@@ -64,6 +64,8 @@ class ParsedSkill:
         scripts: List of script file paths (relative to skill dir)
         references: List of reference file paths (relative to skill dir)
         assets: List of asset file paths (relative to skill dir)
+        always_apply: Whether skill should always be injected at session start
+        injection_format: How to inject skill (summary, full, content)
     """
 
     name: str
@@ -80,6 +82,8 @@ class ParsedSkill:
     scripts: list[str] | None = None
     references: list[str] | None = None
     assets: list[str] | None = None
+    always_apply: bool = False
+    injection_format: str = "summary"
 
     def get_category(self) -> str | None:
         """Get category from top-level or metadata.skillport.category."""
@@ -139,6 +143,8 @@ class ParsedSkill:
             "scripts": self.scripts,
             "references": self.references,
             "assets": self.assets,
+            "always_apply": self.always_apply,
+            "injection_format": self.injection_format,
         }
 
 
@@ -232,6 +238,7 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     # This allows both top-level and nested formats to work
     top_level_always_apply = frontmatter.get("alwaysApply")
     top_level_category = frontmatter.get("category")
+    top_level_injection_format = frontmatter.get("injectionFormat")
 
     if top_level_always_apply is not None or top_level_category is not None:
         if metadata is None:
@@ -251,6 +258,20 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     if version is not None:
         version = str(version)
 
+    # Extract always_apply: check top-level first, then metadata.skillport.alwaysApply
+    always_apply = False
+    if top_level_always_apply is not None:
+        always_apply = bool(top_level_always_apply)
+    elif metadata and isinstance(metadata, dict):
+        skillport = metadata.get("skillport", {})
+        if isinstance(skillport, dict) and skillport.get("alwaysApply"):
+            always_apply = bool(skillport["alwaysApply"])
+
+    # Extract injection_format: check top-level first, default to "summary"
+    injection_format = "summary"
+    if top_level_injection_format is not None:
+        injection_format = str(top_level_injection_format)
+
     return ParsedSkill(
         name=name,
         description=description,
@@ -261,6 +282,8 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
         allowed_tools=allowed_tools,
         metadata=metadata,
         source_path=source_path,
+        always_apply=always_apply,
+        injection_format=injection_format,
     )
 
 

gobby/skills/sync.py

@@ -23,10 +23,9 @@ def get_bundled_skills_path() -> Path:
     Returns:
         Path to src/gobby/install/shared/skills/
     """
-    # Navigate from this file to install/shared/skills/
-    # This file: src/gobby/skills/sync.py
-    # Target: src/gobby/install/shared/skills/
-    return Path(__file__).parent.parent / "install" / "shared" / "skills"
+    from gobby.paths import get_install_dir
+
+    return get_install_dir() / "shared" / "skills"
 
 
 def sync_bundled_skills(db: DatabaseProtocol) -> dict[str, Any]:
@@ -101,6 +100,8 @@ def sync_bundled_skills(db: DatabaseProtocol) -> dict[str, Any]:
                 source_ref=None,
                 project_id=None,  # Global scope
                 enabled=True,
+                always_apply=parsed.always_apply,
+                injection_format=parsed.injection_format,
             )
 
             logger.info(f"Synced bundled skill: {parsed.name}")

gobby/storage/artifacts.py

@@ -283,3 +283,22 @@ class LocalArtifactManager:
 
         rows = self.db.fetchall(sql, tuple(params))
         return [Artifact.from_row(row) for row in rows]
+
+    def count_artifacts(self, session_id: str | None = None) -> int:
+        """Count total artifacts, optionally filtered by session.
+
+        Args:
+            session_id: Optional session ID to filter by
+
+        Returns:
+            Total artifact count
+        """
+        if session_id:
+            row = self.db.fetchone(
+                "SELECT COUNT(*) FROM session_artifacts WHERE session_id = ?",
+                (session_id,),
+            )
+        else:
+            row = self.db.fetchone("SELECT COUNT(*) FROM session_artifacts")
+
+        return row[0] if row else 0