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

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/lifecycle.py

@@ -11,7 +11,7 @@ import logging
 import os
 from typing import Any
 
-from gobby.config.app import SessionLifecycleConfig
+from gobby.config.sessions import SessionLifecycleConfig
 from gobby.sessions.transcripts.claude import ClaudeTranscriptParser
 from gobby.sessions.transcripts.codex import CodexTranscriptParser
 from gobby.sessions.transcripts.gemini import GeminiTranscriptParser

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/processor.py

@@ -12,6 +12,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from gobby.servers.websocket import WebSocketServer
+    from gobby.storage.sessions import LocalSessionManager
 
 from gobby.sessions.transcripts import get_parser
 from gobby.sessions.transcripts.base import TranscriptParser
@@ -36,11 +37,13 @@ class SessionMessageProcessor:
         db: DatabaseProtocol,
         poll_interval: float = 2.0,
         websocket_server: "WebSocketServer | None" = None,
+        session_manager: "LocalSessionManager | None" = None,
     ):
         self.db = db
         self.message_manager = LocalSessionMessageManager(db)
         self.poll_interval = poll_interval
         self.websocket_server: WebSocketServer | None = websocket_server
+        self.session_manager: LocalSessionManager | None = session_manager
 
         # Track active sessions: session_id -> transcript_path
         self._active_sessions: dict[str, str] = {}
@@ -196,6 +199,13 @@ class SessionMessageProcessor:
         # Store messages
         await self.message_manager.store_messages(session_id, parsed_messages)
 
+        # Extract and store model from parsed messages (if present)
+        if self.session_manager:
+            for msg in parsed_messages:
+                if msg.model:
+                    self.session_manager.update_model(session_id, msg.model)
+                    break  # Only need the first model found
+
         # Broadcast new messages
         if self.websocket_server:
             for msg in parsed_messages:

gobby/sessions/transcripts/base.py

@@ -40,6 +40,7 @@ class ParsedMessage:
     raw_json: dict[str, Any]
     usage: TokenUsage | None = None
     tool_use_id: str | None = None
+    model: str | None = None
 
 
 @runtime_checkable

gobby/sessions/transcripts/claude.py

@@ -355,6 +355,8 @@ class ClaudeTranscriptParser:
             # Skip unknown message types (e.g., 'progress', 'error' internal events)
             return None
 
+        usage, model = self._extract_usage(data)
+
         return ParsedMessage(
             index=index,
             role=role,
@@ -365,12 +367,20 @@ class ClaudeTranscriptParser:
             tool_result=tool_result,
             timestamp=timestamp,
             raw_json=data,
-            usage=self._extract_usage(data),
+            usage=usage,
             tool_use_id=tool_use_id,
+            model=model,
         )
 
-    def _extract_usage(self, data: dict[str, Any]) -> TokenUsage | None:
-        """Extract token usage from message data."""
+    def _extract_usage(self, data: dict[str, Any]) -> tuple[TokenUsage | None, str | None]:
+        """Extract token usage and model from message data.
+
+        Returns:
+            Tuple of (TokenUsage | None, model string | None)
+        """
+        # Extract model from message object
+        model = data.get("message", {}).get("model")
+
         # Check for top-level usage field (some formats)
         usage_data = data.get("usage")
 
@@ -379,7 +389,7 @@ class ClaudeTranscriptParser:
             usage_data = data.get("message", {}).get("usage")
 
         if not usage_data:
-            return None
+            return None, model
 
         # Use explicit presence checks to handle 0 correctly
         input_tokens = (
@@ -413,7 +423,7 @@ class ClaudeTranscriptParser:
             cache_creation_tokens=cache_creation_tokens,
             cache_read_tokens=cache_read_tokens,
             total_cost_usd=total_cost_usd,
-        )
+        ), model
 
     def parse_lines(self, lines: list[str], start_index: int = 0) -> list[ParsedMessage]:
         """

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

@@ -82,9 +82,14 @@ class ParsedSkill:
     assets: list[str] | None = None
 
     def get_category(self) -> str | None:
-        """Get category from metadata.skillport.category."""
+        """Get category from top-level or metadata.skillport.category."""
         if not self.metadata:
             return None
+        # Check top-level first (from frontmatter)
+        result = self.metadata.get("category")
+        if result is not None:
+            return str(result)
+        # Fall back to nested skillport.category
         skillport = self.metadata.get("skillport", {})
         result = skillport.get("category")
         return str(result) if result is not None else None
@@ -102,9 +107,18 @@ class ParsedSkill:
         return []
 
     def is_always_apply(self) -> bool:
-        """Check if this is a core skill (alwaysApply=true)."""
+        """Check if this is a core skill (alwaysApply=true).
+
+        Supports both top-level alwaysApply and nested metadata.skillport.alwaysApply.
+        Top-level takes precedence.
+        """
         if not self.metadata:
             return False
+        # Check top-level first (from frontmatter)
+        top_level = self.metadata.get("alwaysApply")
+        if top_level is not None:
+            return bool(top_level)
+        # Fall back to nested skillport.alwaysApply
         skillport = self.metadata.get("skillport", {})
         return bool(skillport.get("alwaysApply", False))
 
@@ -214,6 +228,20 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     # Extract metadata (may contain version, skillport, gobby namespaces)
     metadata = frontmatter.get("metadata")
 
+    # Handle top-level alwaysApply and category by including them in metadata
+    # This allows both top-level and nested formats to work
+    top_level_always_apply = frontmatter.get("alwaysApply")
+    top_level_category = frontmatter.get("category")
+
+    if top_level_always_apply is not None or top_level_category is not None:
+        if metadata is None:
+            metadata = {}
+        # Store at top level of metadata (not nested in skillport)
+        if top_level_always_apply is not None:
+            metadata["alwaysApply"] = top_level_always_apply
+        if top_level_category is not None:
+            metadata["category"] = top_level_category
+
     # Version can be at top level or in metadata
     version = frontmatter.get("version")
     if version is None and metadata and isinstance(metadata, dict):

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,