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

autocoder/common/auto_coder_lang.py

@@ -849,6 +849,84 @@ MESSAGES = {
     "/agent/edit/apply_changes":{
         "en":"Commit the changes in preview steps",
         "zh":"提交前面步骤的修改"
+    },
+    "/agent/edit/pull_request/branch_name_failed": {
+        "en": "Unable to get current branch name, skipping PR creation",
+        "zh": "无法获取当前分支名，跳过 PR 创建"
+    },
+    "/agent/edit/pull_request/title": {
+        "en": "AutoCoder: {{query}}",
+        "zh": "AutoCoder: {{query}}"
+    },
+    "/agent/edit/pull_request/default_query": {
+        "en": "Code auto generation",
+        "zh": "代码自动生成"
+    },
+    "/agent/edit/pull_request/description": {
+        "en": """## 🤖 AutoCoder Generated Pull Request
+
+**Task Description**: {{query}}
+
+### 📝 Change Summary
+- Modified {{file_count}} files
+- Commit Hash: `{{commit_hash}}`
+
+### 📂 Changed Files List
+{{file_list}}
+
+### ⚙️ Generation Configuration
+- Source Branch: `{{source_branch}}`
+- Target Branch: `{{target_branch}}`
+- Auto-generated Time: {{timestamp}}
+
+### 🔍 Next Steps
+- [ ] Code Review
+- [ ] Test Verification
+- [ ] Merge to Main Branch
+
+---
+*This PR was automatically created by AutoCoder*
+""",
+        "zh": """## 🤖 AutoCoder 自动生成的 Pull Request
+
+**任务描述**: {{query}}
+
+### 📝 变更摘要
+- 共修改 {{file_count}} 个文件
+- 提交哈希: `{{commit_hash}}`
+
+### 📂 变更文件列表
+{{file_list}}
+
+### ⚙️ 生成配置
+- 源分支: `{{source_branch}}`
+- 目标分支: `{{target_branch}}`
+- 自动生成时间: {{timestamp}}
+
+### 🔍 下一步
+- [ ] 代码审查
+- [ ] 测试验证
+- [ ] 合并到主分支
+
+---
+*此 PR 由 AutoCoder 自动创建*
+"""
+    },
+    "/agent/edit/pull_request/creating": {
+        "en": "Creating Pull Request: {{title}}",
+        "zh": "正在创建 Pull Request: {{title}}"
+    },
+    "/agent/edit/pull_request/success": {
+        "en": "✅ Pull Request created successfully",
+        "zh": "✅ Pull Request 创建成功"
+    },
+    "/agent/edit/pull_request/failed": {
+        "en": "❌ Pull Request creation failed: {{error}}",
+        "zh": "❌ Pull Request 创建失败: {{error}}"
+    },
+    "/agent/edit/pull_request/exception": {
+        "en": "❌ Exception occurred while creating Pull Request: {{error}}",
+        "zh": "❌ 创建 Pull Request 时发生异常: {{error}}"
     }
 }
 

autocoder/common/command_completer_v2.py

@@ -22,7 +22,7 @@ COMMAND_HIERARCHY = {
     "/mcp": {"/add": {}, "/remove": {}, "/list": {}, "/list_running": {}, "/refresh": {}, "/info": {}},
     "/lib": {"/add": {}, "/remove": {}, "/list": {}, "/set-proxy": {}, "/refresh": {}, "/get": {}},
     "/models": {"/chat": {}, "/add": {}, "/add_model": {}, "/remove": {}, "/list": {}, "/speed": {}, "/speed-test": {}, "/input_price": {}, "/output_price": {}, "/activate": {}},
-    "/auto": {},
+    "/auto": {"/new": {}, "/resume": {}, "/list": {},"/command":{}},
     "/shell": {"/chat": {}},
     "/active_context": {"/list": {}, "/run": {}},
     "/index": {"/query": {}, "/build": {}, "/export": {}, "/import": {}},

autocoder/common/command_file_manager/examples.py

@@ -9,7 +9,7 @@ import sys
 import json
 from typing import Dict, Set, List
 
-from autocoder.common.command_manager import (
+from autocoder.common.command_file_manager import (
     CommandManager, CommandFile, JinjaVariable, CommandFileAnalysisResult
 )
 
@@ -122,16 +122,30 @@ def get_all_variables_example(manager: CommandManager):
         print()
 
 
-def main():
-    """主函数"""
-    # 设置测试环境
+def initialization_examples():
+    """初始化示例"""
+    print("\n=== CommandManager 初始化示例 ===")
+    
+    # 方式1: 使用默认目录（工作目录下的.autocodercommands目录）
+    print("方式1: 使用默认目录")
+    default_manager = CommandManager()
+    print(f"默认命令目录: {default_manager.commands_dir}")
+    
+    # 方式2: 指定自定义目录
+    print("\n方式2: 指定自定义目录")
     test_dir = setup_test_environment()
-    print(f"测试目录: {test_dir}")
+    custom_manager = CommandManager(test_dir)
+    print(f"自定义命令目录: {custom_manager.commands_dir}")
     
-    # 创建命令管理器
-    manager = CommandManager(test_dir)
+    return custom_manager
+
+
+def main():
+    """主函数"""
+    # 展示初始化示例
+    manager = initialization_examples()
     
-    # 运行示例
+    # 运行其他示例
     list_command_files_example(manager)
     read_command_file_example(manager)
     analyze_command_file_example(manager)

autocoder/common/command_file_manager/manager.py

@@ -5,8 +5,9 @@
 """
 
 import os
-import logging
-from typing import Dict, List, Optional, Set, Tuple
+from loguru import logger
+from typing import Dict, List, Optional, Set, Tuple, Any
+from byzerllm.utils import format_str_jinja2
 
 from autocoder.common.command_file_manager.models import (
     CommandFile, JinjaVariable, CommandFileAnalysisResult, ListCommandsResult
@@ -16,19 +17,19 @@ from autocoder.common.command_file_manager.utils import (
     analyze_command_file, is_command_file
 )
 
-logger = logging.getLogger(__name__)
-
 
 class CommandManager:
     """命令管理器，提供高层次的API接口"""
     
-    def __init__(self, commands_dir: str):
+    def __init__(self, commands_dir: Optional[str] = None):
         """
         初始化命令管理器
         
         Args:
-            commands_dir: 命令文件目录路径
+            commands_dir: 命令文件目录路径，如果为None则默认使用工作目录下的.autocodercommands目录
         """
+        if commands_dir is None:
+            commands_dir = os.path.join(os.getcwd(), ".autocodercommands")
         self.commands_dir = os.path.abspath(commands_dir)
         
         # 确保目录存在
@@ -97,6 +98,36 @@ class CommandManager:
             logger.error(f"读取命令文件时出错: {str(e)}")
             return None
     
+    def read_command_file_with_render(self, file_name: str, render_variables: Dict[str, Any] = {}) -> Optional[str]:
+        """
+        读取指定的命令文件并使用 Jinja2 进行渲染
+        
+        Args:
+            file_name: 命令文件名或相对路径
+            render_variables: 用于 Jinja2 渲染的变量字典，如果为 None 则使用空字典
+            
+        Returns:
+            Optional[str]: 渲染后的文件内容，如果文件不存在或渲染失败则返回None
+        """
+        if render_variables is None:
+            render_variables = {}
+            
+        # 首先读取命令文件
+        command_file = self.read_command_file(file_name)
+        if command_file is None:
+            return None
+        
+        try:
+            # 使用 format_str_jinja2 进行渲染
+            rendered_content = format_str_jinja2(command_file.content, **render_variables)
+            
+            logger.info(f"成功渲染命令文件: {file_name}, 使用变量: {render_variables}")
+            return rendered_content
+            
+        except Exception as e:
+            logger.error(f"渲染命令文件时出错: {file_name}, 错误: {str(e)}")
+            return None
+    
     def analyze_command_file(self, file_name: str) -> Optional[CommandFileAnalysisResult]:
         """
         分析指定的命令文件，提取其中的Jinja2变量

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:
         """
         添加对话到索引