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

gobby/servers/websocket.py

@@ -44,7 +44,7 @@ class WebSocketConfig:
     """Configuration for WebSocket server."""
 
     host: str = "localhost"
-    port: int = 8765
+    port: int = 60888
     ping_interval: int = 30  # seconds
     ping_timeout: int = 10  # seconds
     max_message_size: int = 2 * 1024 * 1024  # 2MB
@@ -64,7 +64,7 @@ class WebSocketServer:
 
     Example:
         ```python
-        config = WebSocketConfig(host="0.0.0.0", port=8765)
+        config = WebSocketConfig(host="0.0.0.0", port=60888)
 
         async with WebSocketServer(config, mcp_manager) as server:
             await server.serve_forever()

gobby/sessions/analyzer.py

@@ -32,6 +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."""
 
 
 class TranscriptAnalyzer:

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

@@ -39,6 +39,8 @@ class ParsedMessage:
     timestamp: datetime
     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

@@ -123,7 +123,11 @@ class ClaudeTranscriptParser:
 
         # If no /clear found, just take the last max_turns
         if most_recent_clear_idx is None:
-            return turns[-max_turns:] if len(turns) > max_turns else turns
+            result = turns[-max_turns:] if len(turns) > max_turns else turns
+            result, removed = self._validate_tool_pairing(result)
+            if removed:
+                self.logger.debug(f"Removed {len(removed)} orphaned tool_results: {removed}")
+            return result
 
         # Start after this /clear (which is the last in any cluster since we scanned backwards)
         start_idx = most_recent_clear_idx + 1
@@ -159,7 +163,11 @@ class ClaudeTranscriptParser:
                     start_idx = max(start_idx, boundary_idx + 1)
                     break
 
-            return turns[start_idx:end_idx]
+            result = turns[start_idx:end_idx]
+            result, removed = self._validate_tool_pairing(result)
+            if removed:
+                self.logger.debug(f"Removed {len(removed)} orphaned tool_results: {removed}")
+            return result
 
         # Segment is > max_turns, so we need to limit it
         # Take the last max_turns from the segment
@@ -184,7 +192,11 @@ class ClaudeTranscriptParser:
                 start_idx = boundary_idx + 1
                 break
 
-        return turns[start_idx:end_idx]
+        result = turns[start_idx:end_idx]
+        result, removed = self._validate_tool_pairing(result)
+        if removed:
+            self.logger.debug(f"Removed {len(removed)} orphaned tool_results: {removed}")
+        return result
 
     def is_session_boundary(self, turn: dict[str, Any]) -> bool:
         """
@@ -212,6 +224,51 @@ class ClaudeTranscriptParser:
         # Check for /clear command marker
         return "<command-name>/clear</command-name>" in str(content)
 
+    def _validate_tool_pairing(
+        self, turns: list[dict[str, Any]]
+    ) -> tuple[list[dict[str, Any]], list[str]]:
+        """Remove orphaned tool_results that reference missing tool_use blocks.
+
+        This prevents Claude API validation errors when truncation cuts between
+        a tool_use and its corresponding tool_result.
+
+        Args:
+            turns: List of transcript turns to validate
+
+        Returns:
+            Tuple of (cleaned turns, list of removed tool_use_ids)
+        """
+        # Collect valid tool_use_ids from assistant messages
+        valid_ids: set[str] = set()
+        for turn in turns:
+            content = turn.get("message", {}).get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_use":
+                        if tid := block.get("id"):
+                            valid_ids.add(tid)
+
+        # Filter orphaned tool_results from user messages
+        cleaned: list[dict[str, Any]] = []
+        removed: list[str] = []
+        for turn in turns:
+            msg = turn.get("message", {})
+            content = msg.get("content", [])
+            if isinstance(content, list):
+                new_content: list[Any] = []
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_result":
+                        tid = block.get("tool_use_id")
+                        if tid and tid not in valid_ids:
+                            removed.append(tid)
+                            continue
+                    new_content.append(block)
+                if new_content != content:
+                    turn = {**turn, "message": {**msg, "content": new_content}}
+            cleaned.append(turn)
+
+        return cleaned, removed
+
     def parse_line(self, line: str, index: int) -> ParsedMessage | None:
         """
         Parse a single line from the transcript JSONL.
@@ -247,6 +304,7 @@ class ClaudeTranscriptParser:
         tool_name = None
         tool_input = None
         tool_result = None
+        tool_use_id = None
 
         if msg_type == "user":
             role = "user"
@@ -274,8 +332,7 @@ class ClaudeTranscriptParser:
                         content_type = "tool_use"
                         tool_name = block.get("name")
                         tool_input = block.get("input")
-                        # We capture the tool use ID as content if needed,
-                        # but for now we append nothing to text content
+                        tool_use_id = block.get("id")
 
                     elif block_type == "tool_result":
                         content_type = "tool_result"
@@ -291,12 +348,15 @@ class ClaudeTranscriptParser:
             content_type = "tool_result"
             tool_name = data.get("tool_name")
             tool_result = data.get("result")
+            tool_use_id = data.get("tool_use_id")
             content = str(tool_result)
 
         else:
             # Skip unknown message types (e.g., 'progress', 'error' internal events)
             return None
 
+        usage, model = self._extract_usage(data)
+
         return ParsedMessage(
             index=index,
             role=role,
@@ -307,11 +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")
 
@@ -320,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 = (
@@ -354,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/__init__.py

@@ -0,0 +1,91 @@
+"""Skills module for Agent Skills spec compliant skill management.
+
+This module provides:
+- YAML frontmatter parsing for SKILL.md files
+- Validation against Agent Skills specification
+- Search integration (TF-IDF + optional embeddings via UnifiedSearcher)
+- Skill loading from filesystem, GitHub, and ZIP archives
+- Skill updates from source
+"""
+
+# Embedding utilities are now in gobby.search
+from gobby.search import (
+    generate_embedding,
+    generate_embeddings,
+    is_embedding_available,
+)
+from gobby.skills.loader import (
+    GitHubRef,
+    SkillLoader,
+    SkillLoadError,
+    clone_skill_repo,
+    extract_zip,
+    parse_github_url,
+)
+from gobby.skills.manager import SkillManager
+from gobby.skills.parser import (
+    ParsedSkill,
+    SkillParseError,
+    parse_frontmatter,
+    parse_skill_file,
+    parse_skill_text,
+)
+from gobby.skills.search import (
+    SearchFilters,
+    SkillSearch,
+    SkillSearchResult,
+)
+from gobby.skills.updater import (
+    SkillUpdateError,
+    SkillUpdater,
+    SkillUpdateResult,
+)
+from gobby.skills.validator import (
+    SkillValidator,
+    ValidationResult,
+    validate_skill_category,
+    validate_skill_compatibility,
+    validate_skill_description,
+    validate_skill_name,
+    validate_skill_tags,
+    validate_skill_version,
+)
+
+__all__ = [
+    # Embeddings (from gobby.search)
+    "generate_embedding",
+    "generate_embeddings",
+    "is_embedding_available",
+    # Loader
+    "GitHubRef",
+    "SkillLoadError",
+    "SkillLoader",
+    "clone_skill_repo",
+    "extract_zip",
+    "parse_github_url",
+    # Manager
+    "SkillManager",
+    # Updater
+    "SkillUpdateError",
+    "SkillUpdateResult",
+    "SkillUpdater",
+    # Parser
+    "ParsedSkill",
+    "SkillParseError",
+    "parse_frontmatter",
+    "parse_skill_file",
+    "parse_skill_text",
+    # Search
+    "SearchFilters",
+    "SkillSearch",
+    "SkillSearchResult",
+    # Validator
+    "SkillValidator",
+    "ValidationResult",
+    "validate_skill_category",
+    "validate_skill_compatibility",
+    "validate_skill_description",
+    "validate_skill_name",
+    "validate_skill_tags",
+    "validate_skill_version",
+]