auto-coder 0.1.398__py3-none-any.whl → 0.1.399__py3-none-any.whl

autocoder/common/conversations/get_conversation_manager.py

@@ -0,0 +1,143 @@
+import os
+import threading
+from typing import Optional
+from .manager import PersistConversationManager
+from .config import ConversationManagerConfig
+
+
+class ConversationManagerSingleton:
+    """对话管理器的单例类，确保全局只有一个实例"""
+    
+    _instance: Optional[PersistConversationManager] = None
+    _lock = threading.Lock()
+    _config: Optional[ConversationManagerConfig] = None
+    
+    @classmethod
+    def get_instance(cls, config: Optional[ConversationManagerConfig] = None) -> PersistConversationManager:
+        """
+        获取对话管理器实例
+        
+        Args:
+            config: 配置对象，如果为None则使用默认配置
+            
+        Returns:
+            PersistConversationManager实例
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    if config is None:
+                        config = cls._get_default_config()
+                    cls._config = config
+                    cls._instance = PersistConversationManager(config)
+        return cls._instance
+    
+    @classmethod
+    def reset_instance(cls, config: Optional[ConversationManagerConfig] = None):
+        """
+        重置实例，用于测试或配置更改时
+        
+        Args:
+            config: 新的配置对象
+        """
+        with cls._lock:
+            cls._instance = None
+            cls._config = None
+            if config is not None:
+                cls._instance = PersistConversationManager(config)
+                cls._config = config
+    
+    @classmethod
+    def _get_default_config(cls) -> ConversationManagerConfig:
+        """获取默认配置"""
+        # 默认存储路径为当前工作目录下的 .auto-coder/conversations
+        default_storage_path = os.path.join(os.getcwd(), ".auto-coder", "conversations")
+        
+        return ConversationManagerConfig(
+            storage_path=default_storage_path,
+            max_cache_size=100,
+            cache_ttl=300.0,
+            lock_timeout=10.0,
+            backup_enabled=True,
+            backup_interval=3600.0,
+            max_backups=10
+        )
+    
+    @classmethod
+    def get_config(cls) -> Optional[ConversationManagerConfig]:
+        """获取当前使用的配置"""
+        return cls._config
+
+
+def get_conversation_manager(config: Optional[ConversationManagerConfig] = None) -> PersistConversationManager:
+    """
+    获取全局对话管理器实例
+    
+    这是一个便捷函数，内部使用单例模式确保全局只有一个实例。
+    首次调用时会创建实例，后续调用会返回同一个实例。
+    
+    Args:
+        config: 可选的配置对象。如果为None，将使用默认配置。
+               注意：只有在首次调用时，config参数才会生效。
+    
+    Returns:
+        PersistConversationManager: 对话管理器实例
+        
+    Example:
+        ```python
+        # 使用默认配置
+        manager = get_conversation_manager()
+        
+        # 使用自定义配置（仅在首次调用时生效）
+        config = ConversationManagerConfig(
+            storage_path="./my_conversations",
+            max_cache_size=200
+        )
+        manager = get_conversation_manager(config)
+        
+        # 创建对话
+        conv_id = manager.create_conversation(
+            name="测试对话",
+            description="这是一个测试对话"
+        )
+        ```
+    """
+    return ConversationManagerSingleton.get_instance(config)
+
+
+def reset_conversation_manager(config: Optional[ConversationManagerConfig] = None):
+    """
+    重置全局对话管理器实例
+    
+    用于测试或需要更改配置时重置实例。
+    
+    Args:
+        config: 新的配置对象，如果为None则在下次调用get_conversation_manager时使用默认配置
+        
+    Example:
+        ```python
+        # 重置为默认配置
+        reset_conversation_manager()
+        
+        # 重置为新配置
+        new_config = ConversationManagerConfig(storage_path="./new_path")
+        reset_conversation_manager(new_config)
+        ```
+    """
+    ConversationManagerSingleton.reset_instance(config)
+
+
+def get_conversation_manager_config() -> Optional[ConversationManagerConfig]:
+    """
+    获取当前对话管理器使用的配置
+    
+    Returns:
+        当前配置对象，如果还未初始化则返回None
+    """
+    return ConversationManagerSingleton.get_config()
+
+
+# 便捷别名
+get_manager = get_conversation_manager
+reset_manager = reset_conversation_manager
+get_manager_config = get_conversation_manager_config

autocoder/common/conversations/manager.py

@@ -331,21 +331,22 @@ class PersistConversationManager:
             List of conversation data
         """
         try:
-            # Get conversations from index
-            conversations = self.index_manager.list_conversations()
+            # Convert sort_desc boolean to sort_order string
+            sort_order = 'desc' if sort_desc else 'asc'
+            
+            # Get conversations from index with sorting and pagination
+            conversations = self.index_manager.list_conversations(
+                limit=limit,
+                offset=offset,
+                sort_by=sort_by,
+                sort_order=sort_order
+            )
             
             # Apply filters if provided
             if filters:
                 conversations = self.filter_manager.apply_filters(conversations, filters)
             
-            # Sort conversations
-            conversations = self.index_manager.sort_conversations(
-                conversations, sort_by, sort_desc
-            )
-            
-            # Apply pagination
-            end_idx = offset + limit if limit else None
-            return conversations[offset:end_idx]
+            return conversations
             
         except Exception as e:
             raise ConversationManagerError(f"Failed to list conversations: {e}")
@@ -815,6 +816,7 @@ class PersistConversationManager:
             **self._stats,
             'cache_stats': cache_stats,
             'total_conversations': len(self.index_manager.list_conversations()),
+            'current_conversation_id': self.get_current_conversation_id(),
             'storage_path': self.config.storage_path
         }
     
@@ -914,4 +916,113 @@ class PersistConversationManager:
         try:
             self.index_manager._save_index()
         except Exception:
-            pass  # Ignore errors during cleanup 
+            pass  # Ignore errors during cleanup 
+
+    # Current Conversation Management Methods
+    
+    def set_current_conversation(self, conversation_id: str) -> bool:
+        """
+        设置当前对话。
+        
+        Args:
+            conversation_id: 要设置为当前对话的ID
+            
+        Returns:
+            True if setting was successful
+            
+        Raises:
+            ConversationNotFoundError: 如果对话不存在
+        """
+        try:
+            # 验证对话是否存在
+            conversation_data = self.get_conversation(conversation_id)
+            if not conversation_data:
+                raise ConversationNotFoundError(conversation_id)
+            
+            # 设置当前对话
+            success = self.index_manager.set_current_conversation(conversation_id)
+            if not success:
+                raise ConversationManagerError(f"Failed to set current conversation: {conversation_id}")
+            
+            return True
+            
+        except ConversationNotFoundError:
+            raise
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to set current conversation {conversation_id}: {e}")
+    
+    def get_current_conversation_id(self) -> Optional[str]:
+        """
+        获取当前对话ID。
+        
+        Returns:
+            当前对话ID，如果未设置返回None
+        """
+        try:
+            return self.index_manager.get_current_conversation_id()
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to get current conversation ID: {e}")
+    
+    def get_current_conversation(self) -> Optional[Dict[str, Any]]:
+        """
+        获取当前对话的完整数据。
+        
+        Returns:
+            当前对话的数据字典，如果未设置或对话不存在返回None
+        """
+        try:
+            current_id = self.get_current_conversation_id()
+            if not current_id:
+                return None
+            
+            return self.get_conversation(current_id)
+            
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to get current conversation: {e}")
+    
+    def clear_current_conversation(self) -> bool:
+        """
+        清除当前对话设置。
+        
+        Returns:
+            True if clearing was successful
+        """
+        try:
+            success = self.index_manager.clear_current_conversation()
+            if not success:
+                raise ConversationManagerError("Failed to clear current conversation")
+            
+            return True
+            
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to clear current conversation: {e}")
+    
+    def append_message_to_current(
+        self,
+        role: str,
+        content: Union[str, Dict[str, Any], List[Any]],
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        向当前对话添加消息。
+        
+        Args:
+            role: 消息角色
+            content: 消息内容
+            metadata: 可选的消息元数据
+            
+        Returns:
+            消息ID
+            
+        Raises:
+            ConversationManagerError: 如果没有设置当前对话或添加失败
+        """
+        try:
+            current_id = self.get_current_conversation_id()
+            if not current_id:
+                raise ConversationManagerError("No current conversation set")
+            
+            return self.append_message(current_id, role, content, metadata)
+            
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to append message to current conversation: {e}")

autocoder/common/conversations/storage/index_manager.py

@@ -26,10 +26,12 @@ class IndexManager:
         """
         self.index_path = Path(index_path)
         self.index_file = self.index_path / "conversations.idx"
+        self.config_file = self.index_path / "config.json"
         self.lock_file = self.index_path / "index.lock"
         
         self._ensure_index_directory()
         self._load_index()
+        self._load_config()
     
     def _ensure_index_directory(self):
         """确保索引目录存在"""
@@ -47,6 +49,18 @@ class IndexManager:
             # 如果索引损坏，重建空索引
             self._index_data = {}
     
+    def _load_config(self):
+        """加载配置数据"""
+        try:
+            if self.config_file.exists():
+                with open(self.config_file, 'r', encoding='utf-8') as f:
+                    self._config_data = json.load(f)
+            else:
+                self._config_data = {}
+        except (json.JSONDecodeError, OSError, IOError):
+            # 如果配置损坏，重建空配置
+            self._config_data = {}
+    
     def _save_index(self) -> bool:
         """
         保存索引数据
@@ -68,6 +82,81 @@ class IndexManager:
         except (OSError, IOError):
             return False
     
+    def _save_config(self) -> bool:
+        """
+        保存配置数据
+        
+        Returns:
+            bool: 保存成功返回True
+        """
+        try:
+            # 使用临时文件进行原子写入
+            temp_file = self.config_file.with_suffix('.tmp')
+            
+            with open(temp_file, 'w', encoding='utf-8') as f:
+                json.dump(self._config_data, f, ensure_ascii=False, indent=2)
+            
+            # 原子重命名
+            temp_file.replace(self.config_file)
+            return True
+            
+        except (OSError, IOError):
+            return False
+    
+    def set_current_conversation(self, conversation_id: Optional[str]) -> bool:
+        """
+        设置当前对话ID
+        
+        Args:
+            conversation_id: 对话ID，None表示清除当前对话
+            
+        Returns:
+            bool: 设置成功返回True
+        """
+        try:
+            # 重新加载配置以获取最新数据
+            self._load_config()
+            
+            # 设置或清除当前对话ID
+            if conversation_id is None:
+                self._config_data.pop('current_conversation_id', None)
+            else:
+                self._config_data['current_conversation_id'] = conversation_id
+            
+            # 更新时间戳
+            self._config_data['last_updated'] = time.time()
+            
+            # 保存配置
+            return self._save_config()
+            
+        except Exception:
+            return False
+    
+    def get_current_conversation_id(self) -> Optional[str]:
+        """
+        获取当前对话ID
+        
+        Returns:
+            Optional[str]: 当前对话ID，未设置返回None
+        """
+        try:
+            # 重新加载配置以获取最新数据
+            self._load_config()
+            
+            return self._config_data.get('current_conversation_id')
+            
+        except Exception:
+            return None
+    
+    def clear_current_conversation(self) -> bool:
+        """
+        清除当前对话设置
+        
+        Returns:
+            bool: 清除成功返回True
+        """
+        return self.set_current_conversation(None)
+    
     def add_conversation(self, conversation_metadata: Dict[str, Any]) -> bool:
         """
         添加对话到索引