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

gobby/runner.py

@@ -471,6 +471,19 @@ class GobbyRunner:
                 except (asyncio.CancelledError, TimeoutError):
                     pass
 
+            # Export memories to JSONL backup on shutdown
+            if self.memory_sync_manager:
+                try:
+                    count = await asyncio.wait_for(
+                        self.memory_sync_manager.export_to_files(), timeout=5.0
+                    )
+                    if count > 0:
+                        logger.info(f"Shutdown memory backup: exported {count} memories")
+                except TimeoutError:
+                    logger.warning("Memory backup on shutdown timed out")
+                except Exception as e:
+                    logger.warning(f"Memory backup on shutdown failed: {e}")
+
             try:
                 await asyncio.wait_for(self.mcp_proxy.disconnect_all(), timeout=3.0)
             except TimeoutError:

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
@@ -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/storage/database.py

@@ -11,7 +11,7 @@ import threading
 import weakref
 from collections.abc import Iterator
 from contextlib import AbstractContextManager, contextmanager
-from datetime import date, datetime
+from datetime import UTC, date, datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
 
@@ -21,6 +21,9 @@ from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
 
 def _adapt_datetime(val: datetime) -> str:
     """Adapt datetime to ISO format string for SQLite storage."""
+    # If naive datetime, assume UTC and add timezone info for RFC3339 compliance
+    if val.tzinfo is None:
+        val = val.replace(tzinfo=UTC)
     return val.isoformat()
 
 
@@ -31,7 +34,11 @@ def _adapt_date(val: date) -> str:
 
 def _convert_datetime(val: bytes) -> datetime:
     """Convert SQLite datetime string back to datetime object."""
-    return datetime.fromisoformat(val.decode())
+    dt = datetime.fromisoformat(val.decode())
+    # Ensure timezone-aware (treat naive as UTC) for consistency
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return dt
 
 
 def _convert_date(val: bytes) -> date:

gobby/storage/memories.py

@@ -197,40 +197,51 @@ class LocalMemoryManager:
         return row is not None
 
     def content_exists(self, content: str, project_id: str | None = None) -> bool:
-        """Check if a memory with identical content already exists."""
-        # Normalize content same way as ID generation in create_memory
-        normalized_content = content.strip()
-        project_str = project_id if project_id else ""
-        # Use delimiter to match create_memory ID generation
-        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
+        """Check if a memory with identical content already exists.
 
-        # Check by ID (content-hash based) for consistent dedup
-        row = self.db.fetchone("SELECT 1 FROM memories WHERE id = ?", (memory_id,))
+        Uses global deduplication - checks if any memory has the same content,
+        regardless of project_id. This prevents duplicates when the same content
+        is stored with different or NULL project_ids.
+
+        Args:
+            content: The content to check for
+            project_id: Ignored (kept for backward compatibility)
+
+        Returns:
+            True if a memory with identical content exists
+        """
+        # Global deduplication: check by content directly, ignoring project_id
+        # This fixes the duplicate issue where same content + different project_id
+        # would create different memory IDs
+        normalized_content = content.strip()
+        row = self.db.fetchone(
+            "SELECT 1 FROM memories WHERE content = ? LIMIT 1",
+            (normalized_content,),
+        )
         return row is not None
 
     def get_memory_by_content(self, content: str, project_id: str | None = None) -> Memory | None:
-        """Get a memory by its exact content, using the content-derived ID.
+        """Get a memory by its exact content.
 
-        This provides a reliable way to fetch an existing memory without
-        relying on search result ordering.
+        Uses global lookup - finds any memory with matching content regardless
+        of project_id. This matches the behavior of content_exists().
 
         Args:
             content: The exact content to look up (will be normalized)
-            project_id: Optional project ID for scoping
+            project_id: Ignored (kept for backward compatibility)
 
         Returns:
             The Memory object if found, None otherwise
         """
-        # Normalize content same way as ID generation in create_memory
+        # Global lookup: find by content directly, ignoring project_id
         normalized_content = content.strip()
-        project_str = project_id if project_id else ""
-        # Use delimiter to match create_memory ID generation
-        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
-
-        try:
-            return self.get_memory(memory_id)
-        except ValueError:
-            return None
+        row = self.db.fetchone(
+            "SELECT * FROM memories WHERE content = ? LIMIT 1",
+            (normalized_content,),
+        )
+        if row:
+            return Memory.from_row(row)
+        return None
 
     def update_memory(
         self,

gobby/storage/migrations.py

@@ -43,11 +43,11 @@ class MigrationUnsupportedError(Exception):
 # Migration can be SQL string or a callable that takes LocalDatabase
 MigrationAction = str | Callable[[LocalDatabase], None]
 
-# Baseline version - the schema state after all legacy migrations
-# Baseline version - the schema state at v75 (flattened)
-BASELINE_VERSION = 75
+# Baseline version - the schema state at v78 (flattened)
+# This is applied for new databases directly
+BASELINE_VERSION = 78
 
-# Baseline schema - flattened from v75 production state
+# Baseline schema - flattened from v78 production state, includes hub tracking fields
 # This is applied for new databases directly
 # Generated by: sqlite3 ~/.gobby/gobby-hub.db .schema
 BASELINE_SCHEMA = """
@@ -583,6 +583,9 @@ CREATE TABLE skills (
     source_path TEXT,
     source_type TEXT,
     source_ref TEXT,
+    hub_name TEXT,
+    hub_slug TEXT,
+    hub_version TEXT,
     enabled INTEGER DEFAULT 1,
     project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
     created_at TEXT NOT NULL,
@@ -692,11 +695,27 @@ def _migrate_backfill_session_seq_num_per_project(db: LocalDatabase) -> None:
     logger.info(f"Re-numbered {updated} sessions with per-project seq_num")
 
 
+def _migrate_add_hub_tracking_to_skills(db: LocalDatabase) -> None:
+    """Add hub tracking fields to skills table.
+
+    Adds hub_name, hub_slug, and hub_version columns to track which hub
+    a skill was installed from.
+    """
+    with db.transaction() as conn:
+        conn.execute("ALTER TABLE skills ADD COLUMN hub_name TEXT")
+        conn.execute("ALTER TABLE skills ADD COLUMN hub_slug TEXT")
+        conn.execute("ALTER TABLE skills ADD COLUMN hub_version TEXT")
+
+    logger.info("Added hub tracking fields to skills table")
+
+
 MIGRATIONS: list[tuple[int, str, MigrationAction]] = [
     # Project-scoped session refs: Change seq_num index from global to project-scoped
     (76, "Make sessions.seq_num project-scoped", _migrate_session_seq_num_project_scoped),
     # Project-scoped session refs: Re-backfill seq_num per project
     (77, "Backfill sessions.seq_num per project", _migrate_backfill_session_seq_num_per_project),
+    # Hub tracking: Add hub_name, hub_slug, hub_version to skills table
+    (78, "Add hub tracking fields to skills", _migrate_add_hub_tracking_to_skills),
 ]
 
 

gobby/storage/sessions.py

@@ -166,6 +166,7 @@ class LocalSessionManager:
         agent_depth: int = 0,
         spawned_by_agent_id: str | None = None,
         terminal_context: dict[str, Any] | None = None,
+        workflow_name: str | None = None,
     ) -> Session:
         """
         Register a new session or return existing one.
@@ -241,9 +242,9 @@ class LocalSessionManager:
                         id, external_id, machine_id, source, project_id, title,
                         jsonl_path, git_branch, parent_session_id,
                         agent_depth, spawned_by_agent_id, terminal_context,
-                        status, created_at, updated_at, seq_num, had_edits
+                        workflow_name, status, created_at, updated_at, seq_num, had_edits
                     )
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 0)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 0)
                     """,
                     (
                         session_id,
@@ -258,6 +259,7 @@ class LocalSessionManager:
                         agent_depth,
                         spawned_by_agent_id,
                         json.dumps(terminal_context) if terminal_context else None,
+                        workflow_name,
                         now,
                         now,
                         next_seq_num,