kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/llm/conversation_logger.py

@@ -14,6 +14,8 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
+from ..utils.session_naming import generate_session_name
+
 logger = logging.getLogger(__name__)
 
 
@@ -33,9 +35,8 @@ class KollaborConversationLogger:
         self.conversations_dir = conversations_dir
         self.conversations_dir.mkdir(parents=True, exist_ok=True)
         
-        # Session management
-        timestamp = datetime.now().strftime('%Y-%m-%d_%H%M%S')
-        self.session_id = f"session_{timestamp}"
+        # Session management - use memorable session names
+        self.session_id = generate_session_name()
         self.session_file = self.conversations_dir / f"{self.session_id}.jsonl"
         
         # Conversation state
@@ -47,19 +48,24 @@ class KollaborConversationLogger:
         self.user_patterns = []
         self.project_context = {}
         self.conversation_themes = []
+
+        # Dynamic context (set by llm_service before log_conversation_start)
+        self.app_version = "unknown"
+        self.active_plugins = []
         self.file_interactions = {}
         
-        # Memory management
-        self.memory_dir = self.conversations_dir.parent / "conversation_memory"
+        # Memory management (inside conversations/)
+        self.memory_dir = self.conversations_dir / "memory"
         self.memory_dir.mkdir(parents=True, exist_ok=True)
         self._load_conversation_memory()
         
         logger.info(f"Conversation logger initialized: {self.session_id}")
     
-    async def initialize(self):
+    async def initialize(self) -> bool:
         """Initialize async resources for conversation logger."""
         # Any async initialization can happen here
         logger.debug("Conversation logger async initialization complete")
+        return True
     
     async def shutdown(self):
         """Shutdown conversation logger and save state."""
@@ -299,6 +305,38 @@ class KollaborConversationLogger:
             logger.warning(f"Failed to find related sessions: {e}")
         return related
     
+    def log_message(self, role: str, content: str, parent_uuid: Optional[str] = None,
+                    metadata: Optional[Dict] = None) -> None:
+        """Generic message logging - routes to appropriate role-specific method.
+
+        This is a synchronous wrapper that schedules the async logging.
+
+        Args:
+            role: Message role (user, assistant, system)
+            content: Message content
+            parent_uuid: Optional parent message UUID
+            metadata: Optional additional metadata
+        """
+        import asyncio
+
+        async def _log():
+            if role == "user":
+                await self.log_user_message(content, parent_uuid, metadata)
+            elif role == "assistant":
+                await self.log_assistant_message(content, parent_uuid or "", metadata)
+            elif role == "system":
+                await self.log_system_message(content, parent_uuid or "", metadata)
+            else:
+                logger.warning(f"Unknown role for logging: {role}")
+
+        # Try to get running loop and schedule, otherwise log synchronously
+        try:
+            loop = asyncio.get_running_loop()
+            loop.create_task(_log())
+        except RuntimeError:
+            # No running loop - skip async logging
+            logger.debug(f"Skipping async log for {role} message (no event loop)")
+
     async def log_conversation_start(self):
         """Log conversation root structure with metadata."""
         root_message = {
@@ -310,15 +348,9 @@ class KollaborConversationLogger:
             "timestamp": datetime.now().isoformat() + "Z",
             "cwd": self._get_working_directory(),
             "gitBranch": self._get_git_branch(),
-            "version": "1.0.0",
+            "version": self.app_version,
             "conversation_context": {
-                "project_type": "python_terminal_app",
-                "active_plugins": ["llm_service", "hook_system", "conversation_logger"],
-                "user_profile": {
-                    "expertise_level": "advanced",
-                    "preferred_communication": "direct",
-                    "coding_style": "pythonic"
-                },
+                "active_plugins": self.active_plugins,
                 "session_goals": [],
                 "conversation_summary": ""
             },
@@ -330,7 +362,7 @@ class KollaborConversationLogger:
                 }
             }
         }
-        
+
         await self._append_to_jsonl(root_message)
         logger.info(f"Logged conversation start: {self.session_id}")
     
@@ -470,4 +502,278 @@ class KollaborConversationLogger:
         # Save conversation memory
         self._save_conversation_memory()
         
-        logger.info(f"Logged conversation end: {self.session_id}")
+        logger.info(f"Logged conversation end: {self.session_id}")
+    
+    def list_sessions(self, filters: Dict = None) -> List[Dict]:
+        """List available sessions with metadata.
+        
+        Args:
+            filters: Optional filters for sessions
+            
+        Returns:
+            List of session metadata
+        """
+        sessions = []
+
+        try:
+            # Find both old format (session_*) and new format (YYMMDDHHMM-*) files
+            all_files = (
+                list(self.conversations_dir.glob("session_*.jsonl")) +
+                list(self.conversations_dir.glob("[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]-*.jsonl"))
+            )
+
+            for session_file in all_files:
+                try:
+                    session_info = self._parse_session_file(session_file, filters)
+                    if session_info:
+                        sessions.append(session_info)
+                except Exception as e:
+                    logger.warning(f"Failed to parse session file {session_file}: {e}")
+                    continue
+            
+            # Sort by start time (newest first)
+            sessions.sort(key=lambda x: x.get("start_time", ""), reverse=True)
+            
+        except Exception as e:
+            logger.error(f"Failed to scan sessions directory: {e}")
+        
+        return sessions
+    
+    def _parse_session_file(self, session_file: Path, filters: Dict = None) -> Optional[Dict]:
+        """Parse a session file and extract metadata.
+        
+        Args:
+            session_file: Path to session JSONL file
+            filters: Optional filters
+            
+        Returns:
+            Session metadata or None if should be filtered out
+        """
+        try:
+            session_info = {
+                "session_id": session_file.stem,
+                "file_path": str(session_file),
+                "start_time": None,
+                "end_time": None,
+                "message_count": 0,
+                "working_directory": "unknown",
+                "git_branch": "unknown",
+                "topics": [],
+                "duration": None,
+                "size_bytes": session_file.stat().st_size,
+                "preview_messages": []
+            }
+            
+            with open(session_file, 'r') as f:
+                lines = f.readlines()
+            
+            user_messages = []
+            assistant_messages = []
+            
+            for line in lines:
+                try:
+                    data = json.loads(line.strip())
+                    
+                    # Extract metadata from conversation start
+                    if data.get("type") == "conversation_metadata":
+                        session_info["start_time"] = data.get("startTime")
+                        session_info["working_directory"] = data.get("cwd", "unknown")
+                        session_info["git_branch"] = data.get("gitBranch", "unknown")
+                    
+                    # Extract end time
+                    elif data.get("type") == "conversation_end":
+                        session_info["end_time"] = data.get("endTime")
+                        summary = data.get("summary", {})
+                        session_info["topics"] = summary.get("themes", [])
+                    
+                    # Count messages
+                    elif data.get("type") == "user":
+                        user_messages.append(data)
+                        session_info["message_count"] += 1
+                        
+                        # Store preview messages (first 3 user messages)
+                        if len(user_messages) <= 3:
+                            content = data.get("message", {}).get("content", "")
+                            preview = content[:100] + "..." if len(content) > 100 else content
+                            session_info["preview_messages"].append({
+                                "role": "user",
+                                "content": preview,
+                                "timestamp": data.get("timestamp")
+                            })
+                    
+                    elif data.get("type") == "assistant":
+                        assistant_messages.append(data)
+                        session_info["message_count"] += 1
+                        
+                        # Store preview assistant messages
+                        if len(assistant_messages) <= 2:
+                            content = data.get("message", {}).get("content", [])
+                            if isinstance(content, list) and content:
+                                text_content = content[0].get("text", "")
+                            else:
+                                text_content = str(content)
+                            
+                            preview = text_content[:100] + "..." if len(text_content) > 100 else text_content
+                            session_info["preview_messages"].append({
+                                "role": "assistant", 
+                                "content": preview,
+                                "timestamp": data.get("timestamp")
+                            })
+                
+                except json.JSONDecodeError:
+                    continue
+            
+            # Calculate duration
+            if session_info["start_time"] and session_info["end_time"]:
+                try:
+                    start = datetime.fromisoformat(session_info["start_time"].replace('Z', '+00:00'))
+                    end = datetime.fromisoformat(session_info["end_time"].replace('Z', '+00:00'))
+                    duration = end - start
+                    session_info["duration"] = str(int(duration.total_seconds() / 60)) + "m"
+                except:
+                    session_info["duration"] = "unknown"
+            
+            # Apply filters
+            if filters:
+                if "date_range" in filters:
+                    # Filter by date range
+                    pass  # TODO: Implement date filtering
+                
+                if "working_directory" in filters:
+                    if session_info["working_directory"] != filters["working_directory"]:
+                        return None
+                
+                if "git_branch" in filters:
+                    if session_info["git_branch"] != filters["git_branch"]:
+                        return None
+            
+            return session_info
+            
+        except Exception as e:
+            logger.warning(f"Failed to parse session file {session_file}: {e}")
+            return None
+    
+    def get_session_summary(self, session_id: str) -> Dict:
+        """Get session summary for preview.
+        
+        Args:
+            session_id: Session identifier
+            
+        Returns:
+            Session summary
+        """
+        try:
+            # Find session file
+            session_file = None
+            for file_path in self.conversations_dir.glob(f"{session_id}*.jsonl"):
+                session_file = file_path
+                break
+            
+            if not session_file:
+                return {}
+            
+            session_info = self._parse_session_file(session_file)
+            if not session_info:
+                return {}
+            
+            # Extract additional summary information
+            summary = {
+                "metadata": session_info,
+                "key_topics": session_info.get("topics", []),
+                "user_patterns": [],  # TODO: Extract from memory
+                "project_context": {
+                    "working_directory": session_info.get("working_directory"),
+                    "git_branch": session_info.get("git_branch"),
+                    "files_mentioned": []  # TODO: Extract from messages
+                },
+                "compatibility_score": 1.0  # TODO: Calculate based on environment
+            }
+            
+            return summary
+            
+        except Exception as e:
+            logger.error(f"Failed to get session summary for {session_id}: {e}")
+            return {}
+    
+    def search_sessions(self, query: str) -> List[Dict]:
+        """Search sessions by content.
+        
+        Args:
+            query: Search query
+            
+        Returns:
+            List of matching sessions
+        """
+        results = []
+        query_lower = query.lower()
+
+        try:
+            # Search both old format (session_*) and new format (YYMMDDHHMM-*) files
+            all_files = (
+                list(self.conversations_dir.glob("session_*.jsonl")) +
+                list(self.conversations_dir.glob("[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]-*.jsonl"))
+            )
+
+            for session_file in all_files:
+                try:
+                    # Quick filename check first
+                    if query_lower in session_file.name.lower():
+                        session_info = self._parse_session_file(session_file)
+                        if session_info:
+                            results.append(session_info)
+                        continue
+
+                    # Content search
+                    with open(session_file, 'r') as f:
+                        content = f.read().lower()
+
+                    if query_lower in content:
+                        session_info = self._parse_session_file(session_file)
+                        if session_info:
+                            # Add search relevance info
+                            session_info["search_relevance"] = self._calculate_search_relevance(
+                                content, query_lower
+                            )
+                            results.append(session_info)
+
+                except Exception as e:
+                    logger.warning(f"Failed to search session file {session_file}: {e}")
+                    continue
+            
+            # Sort by relevance (most relevant first)
+            results.sort(key=lambda x: x.get("search_relevance", 0), reverse=True)
+            
+        except Exception as e:
+            logger.error(f"Failed to search sessions: {e}")
+        
+        return results
+    
+    def _calculate_search_relevance(self, content: str, query: str) -> float:
+        """Calculate search relevance score.
+        
+        Args:
+            content: Session content
+            query: Search query
+            
+        Returns:
+            Relevance score (0.0 to 1.0)
+        """
+        # Simple relevance calculation
+        query_words = query.split()
+        content_words = content.split()
+        
+        if not query_words:
+            return 0.0
+        if not content_words:
+            return 0.0
+        
+        # Count exact matches
+        exact_matches = content.count(query)
+        
+        # Count word matches
+        word_matches = sum(1 for word in query_words if word in content)
+        
+        # Calculate relevance based on frequency and coverage
+        relevance = (exact_matches * 0.5 + word_matches * 0.1) / len(content_words)
+        
+        return min(relevance * 100, 1.0)  # Normalize to 0-1