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

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/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/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):