auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/conversations/manager.py

@@ -22,6 +22,7 @@ from .exceptions import (
     DataIntegrityError
 )
 from .models import Conversation, ConversationMessage
+from .llm_stats_models import LLMCallMetadata
 from .file_locker import FileLocker
 from .storage import FileStorage, IndexManager
 from .cache import CacheManager
@@ -133,7 +134,8 @@ class PersistConversationManager:
         name: str,
         description: Optional[str] = None,
         initial_messages: Optional[List[Dict[str, Any]]] = None,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
+        conversation_id: Optional[str] = None
     ) -> str:
         """
         Create a new conversation.
@@ -143,6 +145,7 @@ class PersistConversationManager:
             description: Optional description
             initial_messages: Optional list of initial messages
             metadata: Optional metadata dictionary
+            conversation_id: Optional conversation ID. If not provided, will be auto-generated
             
         Returns:
             ID of the created conversation
@@ -152,11 +155,23 @@ class PersistConversationManager:
         """
         try:
             # Create conversation object
-            conversation = Conversation(
-                name=name,
-                description=description,
-                metadata=metadata or {}
-            )
+            if conversation_id:
+                # Check if conversation ID already exists
+                if self.storage.conversation_exists(conversation_id):
+                    raise ConversationManagerError(f"Conversation with ID {conversation_id} already exists")
+                
+                conversation = Conversation(
+                    name=name,
+                    description=description,
+                    metadata=metadata or {},
+                    conversation_id=conversation_id
+                )
+            else:
+                conversation = Conversation(
+                    name=name,
+                    description=description,
+                    metadata=metadata or {}
+                )
             
             # Add initial messages if provided
             if initial_messages:
@@ -258,6 +273,8 @@ class PersistConversationManager:
                 if description is not None:
                     conversation.description = description
                 if metadata is not None:
+                    if conversation.metadata is None:
+                        conversation.metadata = {}
                     conversation.metadata.update(metadata)
                 
                 conversation.updated_at = time.time()
@@ -358,7 +375,8 @@ class PersistConversationManager:
         conversation_id: str,
         role: str,
         content: Union[str, Dict[str, Any], List[Any]],
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
+        llm_metadata: Optional['LLMCallMetadata'] = None
     ) -> str:
         """
         Append a message to a conversation.
@@ -368,6 +386,7 @@ class PersistConversationManager:
             role: Role of the message sender
             content: Message content
             metadata: Optional message metadata
+            llm_metadata: Optional LLM call metadata (tokens, cache info, etc.)
             
         Returns:
             ID of the added message
@@ -380,7 +399,8 @@ class PersistConversationManager:
             message = ConversationMessage(
                 role=role,
                 content=content,
-                metadata=metadata or {}
+                metadata=metadata or {},
+                llm_metadata=llm_metadata
             )
             
             with self._conversation_lock(conversation_id):
@@ -424,7 +444,11 @@ class PersistConversationManager:
         
         Args:
             conversation_id: ID of the conversation
-            messages: List of message data dictionaries
+            messages: List of message data dictionaries. Each dictionary can contain:
+                - role: Message role (required)
+                - content: Message content (required)
+                - metadata: Message metadata (optional)
+                - llm_metadata: LLM call metadata (optional)
             
         Returns:
             List of message IDs
@@ -436,7 +460,8 @@ class PersistConversationManager:
                 conversation_id,
                 msg_data['role'],
                 msg_data['content'],
-                msg_data.get('metadata')
+                msg_data.get('metadata'),
+                msg_data.get('llm_metadata')
             )
             message_ids.append(message_id)
         
@@ -526,7 +551,8 @@ class PersistConversationManager:
         conversation_id: str,
         message_id: str,
         content: Optional[Union[str, Dict[str, Any], List[Any]]] = None,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
+        llm_metadata: Optional["LLMCallMetadata"] = None
     ) -> bool:
         """
         Update a message.
@@ -536,6 +562,7 @@ class PersistConversationManager:
             message_id: ID of the message to update
             content: New content (optional)
             metadata: New metadata (optional)
+            llm_metadata: LLM call metadata (optional)
             
         Returns:
             True if update was successful
@@ -557,7 +584,11 @@ class PersistConversationManager:
                         if content is not None:
                             msg.content = content
                         if metadata is not None:
+                            if msg.metadata is None:
+                                msg.metadata = {}
                             msg.metadata.update(metadata)
+                        if llm_metadata is not None:
+                            msg.llm_metadata = llm_metadata
                         
                         # Update timestamp
                         msg.timestamp = time.time()
@@ -817,6 +848,9 @@ class PersistConversationManager:
             'cache_stats': cache_stats,
             'total_conversations': len(self.index_manager.list_conversations()),
             'current_conversation_id': self.get_current_conversation_id(),
+            'all_current_conversations': self.get_all_current_conversations(),
+            'namespaces': self.list_namespaces(),
+            'default_namespace': self.config.default_namespace,
             'storage_path': self.config.storage_path
         }
     
@@ -894,14 +928,13 @@ class PersistConversationManager:
         """Rebuild the conversation index from storage."""
         try:
             # Clear existing index
-            self.index_manager._index.clear()
+            self.index_manager._index_data.clear()
             
             # Load all conversations from storage and rebuild index
-            conversation_ids = self.storage.list_conversations()
+            conversations = self.storage.list_conversations()
             
-            for conv_id in conversation_ids:
-                conversation_data = self.storage.load_conversation(conv_id)
-                if conversation_data:
+            for conversation_data in conversations:
+                if conversation_data and conversation_data.get('conversation_id'):
                     self.index_manager.add_conversation(conversation_data)
             
         except Exception as e:
@@ -920,12 +953,13 @@ class PersistConversationManager:
 
     # Current Conversation Management Methods
     
-    def set_current_conversation(self, conversation_id: str) -> bool:
+    def set_current_conversation(self, conversation_id: str, namespace: Optional[str] = None) -> bool:
         """
         设置当前对话。
         
         Args:
             conversation_id: 要设置为当前对话的ID
+            namespace: 命名空间，None表示使用默认命名空间
             
         Returns:
             True if setting was successful
@@ -934,13 +968,17 @@ class PersistConversationManager:
             ConversationNotFoundError: 如果对话不存在
         """
         try:
+            # 如果没有指定命名空间，使用配置中的默认命名空间
+            if namespace is None:
+                namespace = self.config.default_namespace
+            
             # 验证对话是否存在
             conversation_data = self.get_conversation(conversation_id)
             if not conversation_data:
                 raise ConversationNotFoundError(conversation_id)
             
             # 设置当前对话
-            success = self.index_manager.set_current_conversation(conversation_id)
+            success = self.index_manager.set_current_conversation(conversation_id, namespace)
             if not success:
                 raise ConversationManagerError(f"Failed to set current conversation: {conversation_id}")
             
@@ -951,27 +989,37 @@ class PersistConversationManager:
         except Exception as e:
             raise ConversationManagerError(f"Failed to set current conversation {conversation_id}: {e}")
     
-    def get_current_conversation_id(self) -> Optional[str]:
+    def get_current_conversation_id(self, namespace: Optional[str] = None) -> Optional[str]:
         """
         获取当前对话ID。
         
+        Args:
+            namespace: 命名空间，None表示使用默认命名空间
+            
         Returns:
             当前对话ID，如果未设置返回None
         """
         try:
-            return self.index_manager.get_current_conversation_id()
+            # 如果没有指定命名空间，使用配置中的默认命名空间
+            if namespace is None:
+                namespace = self.config.default_namespace
+            
+            return self.index_manager.get_current_conversation_id(namespace)
         except Exception as e:
             raise ConversationManagerError(f"Failed to get current conversation ID: {e}")
     
-    def get_current_conversation(self) -> Optional[Dict[str, Any]]:
+    def get_current_conversation(self, namespace: Optional[str] = None) -> Optional[Dict[str, Any]]:
         """
         获取当前对话的完整数据。
         
+        Args:
+            namespace: 命名空间，None表示使用默认命名空间
+            
         Returns:
             当前对话的数据字典，如果未设置或对话不存在返回None
         """
         try:
-            current_id = self.get_current_conversation_id()
+            current_id = self.get_current_conversation_id(namespace)
             if not current_id:
                 return None
             
@@ -980,15 +1028,22 @@ class PersistConversationManager:
         except Exception as e:
             raise ConversationManagerError(f"Failed to get current conversation: {e}")
     
-    def clear_current_conversation(self) -> bool:
+    def clear_current_conversation(self, namespace: Optional[str] = None) -> bool:
         """
         清除当前对话设置。
         
+        Args:
+            namespace: 命名空间，None表示使用默认命名空间
+            
         Returns:
             True if clearing was successful
         """
         try:
-            success = self.index_manager.clear_current_conversation()
+            # 如果没有指定命名空间，使用配置中的默认命名空间
+            if namespace is None:
+                namespace = self.config.default_namespace
+            
+            success = self.index_manager.clear_current_conversation(namespace)
             if not success:
                 raise ConversationManagerError("Failed to clear current conversation")
             
@@ -1001,7 +1056,9 @@ class PersistConversationManager:
         self,
         role: str,
         content: Union[str, Dict[str, Any], List[Any]],
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
+        llm_metadata: Optional[LLMCallMetadata] = None,
+        namespace: Optional[str] = None
     ) -> str:
         """
         向当前对话添加消息。
@@ -1010,6 +1067,8 @@ class PersistConversationManager:
             role: 消息角色
             content: 消息内容
             metadata: 可选的消息元数据
+            llm_metadata: 可选的 LLM 调用元数据
+            namespace: 命名空间，None表示使用默认命名空间
             
         Returns:
             消息ID
@@ -1018,11 +1077,36 @@ class PersistConversationManager:
             ConversationManagerError: 如果没有设置当前对话或添加失败
         """
         try:
-            current_id = self.get_current_conversation_id()
+            current_id = self.get_current_conversation_id(namespace)
             if not current_id:
-                raise ConversationManagerError("No current conversation set")
+                ns_desc = f"namespace '{namespace}'" if namespace else "default namespace"
+                raise ConversationManagerError(f"No current conversation set for {ns_desc}")
             
-            return self.append_message(current_id, role, content, metadata)
+            return self.append_message(current_id, role, content, metadata, llm_metadata)
             
         except Exception as e:
             raise ConversationManagerError(f"Failed to append message to current conversation: {e}")
+    
+    def list_namespaces(self) -> List[Optional[str]]:
+        """
+        列出所有已使用的命名空间。
+        
+        Returns:
+            命名空间列表，None 表示默认命名空间
+        """
+        try:
+            return self.index_manager.list_namespaces()
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to list namespaces: {e}")
+    
+    def get_all_current_conversations(self) -> Dict[Optional[str], str]:
+        """
+        获取所有命名空间的当前对话ID。
+        
+        Returns:
+            命名空间到对话ID的映射
+        """
+        try:
+            return self.index_manager.get_all_current_conversations()
+        except Exception as e:
+            raise ConversationManagerError(f"Failed to get all current conversations: {e}")

autocoder/common/conversations/models.py

@@ -6,6 +6,7 @@ import time
 import uuid
 from typing import Union, Dict, List, Optional, Any
 from dataclasses import dataclass, field
+from .llm_stats_models import LLMCallMetadata
 
 
 @dataclass
@@ -17,6 +18,7 @@ class ConversationMessage:
     timestamp: float = field(default_factory=time.time)
     message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
     metadata: Optional[dict] = None
+    llm_metadata: Optional[LLMCallMetadata] = None
     
     def __post_init__(self):
         """数据验证"""
@@ -43,23 +45,35 @@ class ConversationMessage:
     
     def to_dict(self) -> dict:
         """序列化为字典"""
-        return {
+        result = {
             "role": self.role,
             "content": self.content,
             "timestamp": self.timestamp,
             "message_id": self.message_id,
             "metadata": self.metadata
         }
+        
+        # 序列化 LLM 元数据
+        if self.llm_metadata is not None:
+            result["llm_metadata"] = self.llm_metadata.to_dict()
+        
+        return result
     
     @classmethod
     def from_dict(cls, data: dict) -> "ConversationMessage":
         """从字典反序列化"""
+        # 处理 LLM 元数据
+        llm_metadata = None
+        if "llm_metadata" in data and data["llm_metadata"] is not None:
+            llm_metadata = LLMCallMetadata.from_dict(data["llm_metadata"])
+        
         return cls(
             role=data["role"],
             content=data["content"],
             timestamp=data["timestamp"],
             message_id=data["message_id"],
-            metadata=data.get("metadata")
+            metadata=data.get("metadata"),
+            llm_metadata=llm_metadata
         )
 
 

autocoder/common/conversations/storage/index_manager.py

@@ -10,8 +10,8 @@ import time
 from typing import Optional, List, Dict, Any
 from pathlib import Path
 
-from ..file_locker import FileLocker
-from ..exceptions import DataIntegrityError
+from typing import Optional, List, Dict, Any
+from pathlib import Path
 
 
 class IndexManager:
@@ -60,6 +60,25 @@ class IndexManager:
         except (json.JSONDecodeError, OSError, IOError):
             # 如果配置损坏，重建空配置
             self._config_data = {}
+        
+        # 规范化配置：避免在 JSON 中使用 None 作为键（会被序列化为字符串 "null"）
+        # 将默认命名空间的当前对话仅存储在 legacy 字段 current_conversation_id 中
+        namespaced = self._config_data.get('namespaced_current_conversations')
+        if isinstance(namespaced, dict):
+            # 将可能存在的 "null" 或 None 键迁移到 current_conversation_id，并从映射中移除
+            migrated_default = False
+            default_keys = []
+            for key in list(namespaced.keys()):
+                if key is None or key == "null":
+                    if not migrated_default and namespaced.get(key) is not None:
+                        # 仅在未设置 legacy 字段时迁移
+                        if self._config_data.get('current_conversation_id') is None:
+                            self._config_data['current_conversation_id'] = namespaced.get(key)
+                    default_keys.append(key)
+            for k in default_keys:
+                del namespaced[k]
+            if default_keys:
+                self._config_data['namespaced_current_conversations'] = namespaced
     
     def _save_index(self) -> bool:
         """
@@ -103,12 +122,13 @@ class IndexManager:
         except (OSError, IOError):
             return False
     
-    def set_current_conversation(self, conversation_id: Optional[str]) -> bool:
+    def set_current_conversation(self, conversation_id: Optional[str], namespace: Optional[str] = None) -> bool:
         """
         设置当前对话ID
         
         Args:
             conversation_id: 对话ID，None表示清除当前对话
+            namespace: 命名空间，None表示默认命名空间
             
         Returns:
             bool: 设置成功返回True
@@ -117,11 +137,39 @@ class IndexManager:
             # 重新加载配置以获取最新数据
             self._load_config()
             
+            # 确保 namespaced_current_conversations 字段存在
+            if 'namespaced_current_conversations' not in self._config_data:
+                self._config_data['namespaced_current_conversations'] = {}
+            namespaced = self._config_data['namespaced_current_conversations']
+
             # 设置或清除当前对话ID
             if conversation_id is None:
-                self._config_data.pop('current_conversation_id', None)
+                # 清除
+                if namespace is None:
+                    # 默认命名空间：仅使用向后兼容字段
+                    self._config_data.pop('current_conversation_id', None)
+                    # 兼容历史：移除可能存在的 None/"null" 键
+                    if None in namespaced:
+                        del namespaced[None]
+                    if 'null' in namespaced:
+                        del namespaced['null']
+                else:
+                    # 指定命名空间
+                    if namespace in namespaced:
+                        del namespaced[namespace]
             else:
-                self._config_data['current_conversation_id'] = conversation_id
+                # 设置
+                if namespace is None:
+                    # 默认命名空间：仅设置 legacy 字段，避免在 JSON 中出现 "null" 键
+                    self._config_data['current_conversation_id'] = conversation_id
+                    # 兼容清理：移除可能存在的 None/"null" 键
+                    if None in namespaced:
+                        del namespaced[None]
+                    if 'null' in namespaced:
+                        del namespaced['null']
+                else:
+                    # 指定命名空间
+                    namespaced[namespace] = conversation_id
             
             # 更新时间戳
             self._config_data['last_updated'] = time.time()
@@ -132,10 +180,13 @@ class IndexManager:
         except Exception:
             return False
     
-    def get_current_conversation_id(self) -> Optional[str]:
+    def get_current_conversation_id(self, namespace: Optional[str] = None) -> Optional[str]:
         """
         获取当前对话ID
         
+        Args:
+            namespace: 命名空间，None表示默认命名空间
+            
         Returns:
             Optional[str]: 当前对话ID，未设置返回None
         """
@@ -143,19 +194,30 @@ class IndexManager:
             # 重新加载配置以获取最新数据
             self._load_config()
             
-            return self._config_data.get('current_conversation_id')
+            # 默认命名空间：使用向后兼容字段
+            if namespace is None:
+                return self._config_data.get('current_conversation_id')
+            
+            # 指定命名空间：从 namespaced_current_conversations 中获取
+            namespaced_conversations = self._config_data.get('namespaced_current_conversations', {})
+            return namespaced_conversations.get(namespace)
+            
+            return None
             
         except Exception:
             return None
     
-    def clear_current_conversation(self) -> bool:
+    def clear_current_conversation(self, namespace: Optional[str] = None) -> bool:
         """
         清除当前对话设置
         
+        Args:
+            namespace: 命名空间，None表示默认命名空间
+            
         Returns:
             bool: 清除成功返回True
         """
-        return self.set_current_conversation(None)
+        return self.set_current_conversation(None, namespace)
     
     def add_conversation(self, conversation_metadata: Dict[str, Any]) -> bool:
         """
@@ -403,4 +465,66 @@ class IndexManager:
             return results
             
         except Exception:
-            return [] 
+            return []
+    
+    def list_namespaces(self) -> List[Optional[str]]:
+        """
+        列出所有已使用的命名空间
+        
+        Returns:
+            List[Optional[str]]: 命名空间列表，None 表示默认命名空间
+        """
+        try:
+            # 重新加载配置以获取最新数据
+            self._load_config()
+            
+            namespaces: List[Optional[str]] = []
+            namespaced_conversations = self._config_data.get('namespaced_current_conversations', {})
+            
+            # 添加所有已配置的命名空间
+            for namespace in namespaced_conversations.keys():
+                # 忽略历史遗留的 None/"null" 键
+                if namespace is None or namespace == 'null':
+                    continue
+                namespaces.append(namespace)
+            
+            # 如果存在旧的 current_conversation_id，添加默认命名空间
+            if (self._config_data.get('current_conversation_id') is not None and
+                None not in namespaces):
+                namespaces.append(None)
+            
+            return namespaces
+            
+        except Exception:
+            return []
+    
+    def get_all_current_conversations(self) -> Dict[Optional[str], str]:
+        """
+        获取所有命名空间的当前对话ID
+        
+        Returns:
+            Dict[Optional[str], str]: 命名空间到对话ID的映射
+        """
+        try:
+            # 重新加载配置以获取最新数据
+            self._load_config()
+            
+            result: Dict[Optional[str], str] = {}
+            namespaced_conversations = self._config_data.get('namespaced_current_conversations', {})
+            
+            # 添加所有已配置的命名空间对话
+            for namespace, conversation_id in namespaced_conversations.items():
+                # 忽略历史遗留的 None/"null" 键
+                if namespace is None or namespace == 'null':
+                    continue
+                if conversation_id is not None:
+                    result[namespace] = conversation_id
+            
+            # 默认命名空间（向后兼容字段）
+            if self._config_data.get('current_conversation_id') is not None:
+                result[None] = self._config_data['current_conversation_id']
+            
+            return result
+            
+        except Exception:
+            return {}

autocoder/common/core_config/__init__.py

@@ -0,0 +1,63 @@
+"""
+Core Config Module
+
+Provides centralized configuration and memory management for auto-coder.
+
+This module has been refactored into multiple specialized modules for better
+maintainability and separation of concerns:
+
+- models.py: Core data structures
+- base_manager.py: Base persistence functionality  
+- config_manager.py: Configuration management
+- file_manager.py: File and file group management
+- exclude_manager.py: Exclude patterns management
+- lib_manager.py: Library management
+- conversation_manager.py: Conversation management
+- mode_manager.py: Mode management functionality
+- human_as_model_manager.py: Human as model configuration management
+- main_manager.py: Combined MemoryManager class
+- compatibility.py: Backward compatibility functions
+"""
+
+# Import core classes and functions
+from .models import CoreMemory
+from .main_manager import MemoryManager, get_memory_manager
+from .compatibility import (
+    save_memory,
+    save_memory_with_new_memory,
+    load_memory,
+    get_memory,
+    get_mode,
+    set_mode,
+    cycle_mode,
+    get_human_as_model,
+    set_human_as_model,
+    toggle_human_as_model,
+    get_human_as_model_string,
+    get_agentic_mode,
+    set_agentic_mode,
+    toggle_agentic_mode,
+    get_agentic_mode_string,
+)
+
+# Export all public interfaces
+__all__ = [
+    'MemoryManager',
+    'CoreMemory', 
+    'get_memory_manager',
+    'save_memory',
+    'save_memory_with_new_memory',
+    'load_memory',
+    'get_memory',
+    'get_mode',
+    'set_mode',
+    'cycle_mode',
+    'get_human_as_model',
+    'set_human_as_model',
+    'toggle_human_as_model',
+    'get_human_as_model_string',
+    'get_agentic_mode',
+    'set_agentic_mode',
+    'toggle_agentic_mode',
+    'get_agentic_mode_string',
+]