auto-coder 0.1.366__tar.gz → 0.1.369__tar.gz

{auto_coder-0.1.366 → auto_coder-0.1.369}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.366
+Version: 0.1.369
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.366 → auto_coder-0.1.369}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.366
+Version: 0.1.369
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.366 → auto_coder-0.1.369}/src/auto_coder.egg-info/SOURCES.txt

@@ -132,6 +132,11 @@ src/autocoder/common/text.py
 src/autocoder/common/token_cost_caculate.py
 src/autocoder/common/types.py
 src/autocoder/common/utils_code_auto_generate.py
+src/autocoder/common/command_file_manager/__init__.py
+src/autocoder/common/command_file_manager/examples.py
+src/autocoder/common/command_file_manager/manager.py
+src/autocoder/common/command_file_manager/models.py
+src/autocoder/common/command_file_manager/utils.py
 src/autocoder/common/conversations/__init__.py
 src/autocoder/common/conversations/compatibility.py
 src/autocoder/common/conversations/conversation_manager.py

auto_coder-0.1.369/src/autocoder/common/command_file_manager/__init__.py

@@ -0,0 +1,25 @@
+"""
+命令管理模块
+
+该模块提供了一种机制来管理和分析 .autocodercommands 目录中的命令文件。
+主要功能包括：
+1. 列出命令目录中的所有命令文件
+2. 读取指定的命令文件内容
+3. 分析命令文件，提取其中的Jinja2变量
+4. 提供简单直观的API，便于集成到现有的项目中
+"""
+
+from autocoder.common.command_file_manager.models import (
+    CommandFile, JinjaVariable, CommandFileAnalysisResult, ListCommandsResult
+)
+from autocoder.common.command_file_manager.manager import CommandManager
+from autocoder.common.command_file_manager.utils import (
+    extract_jinja2_variables, extract_jinja2_variables_with_metadata,
+    analyze_command_file, is_command_file
+)
+
+__all__ = [
+    'CommandFile', 'JinjaVariable', 'CommandFileAnalysisResult', 'ListCommandsResult',
+    'CommandManager', 'extract_jinja2_variables', 'extract_jinja2_variables_with_metadata',
+    'analyze_command_file', 'is_command_file'
+]

auto_coder-0.1.369/src/autocoder/common/command_file_manager/examples.py

@@ -0,0 +1,142 @@
+"""
+命令管理模块的使用示例
+
+展示如何使用命令管理模块的主要功能。
+"""
+
+import os
+import sys
+import json
+from typing import Dict, Set, List
+
+from autocoder.common.command_manager import (
+    CommandManager, CommandFile, JinjaVariable, CommandFileAnalysisResult
+)
+
+
+def setup_test_environment():
+    """设置测试环境，创建示例命令文件"""
+    # 创建临时命令目录
+    test_dir = os.path.join(os.path.dirname(__file__), "test_commands")
+    os.makedirs(test_dir, exist_ok=True)
+    
+    # 创建示例命令文件
+    example1 = os.path.join(test_dir, "example1.autocodercommand")
+    with open(example1, "w") as f:
+        f.write("""
+{# @var: project_name, default: MyProject, description: 项目名称 #}
+{# @var: author, default: User, description: 作者姓名 #}
+# {{ project_name }}
+
+这是一个由 {{ author }} 创建的项目。
+
+{% if include_license %}
+## 许可证
+本项目使用 {{ license_type }} 许可证。
+{% endif %}
+        """)
+    
+    # 创建子目录和另一个示例文件
+    sub_dir = os.path.join(test_dir, "subdir")
+    os.makedirs(sub_dir, exist_ok=True)
+    
+    example2 = os.path.join(sub_dir, "example2.j2")
+    with open(example2, "w") as f:
+        f.write("""
+# {{ project_name }} 配置
+
+version: {{ version }}
+environment: {{ env }}
+        """)
+    
+    return test_dir
+
+
+def list_command_files_example(manager: CommandManager):
+    """列出命令文件示例"""
+    print("\n=== 列出命令文件 ===")
+    
+    # 不递归列出
+    print("不递归列出:")
+    result = manager.list_command_files(recursive=False)
+    if result.success:
+        for file in result.command_files:
+            print(f"- {file}")
+    else:
+        print(f"错误: {result.errors}")
+    
+    # 递归列出
+    print("\n递归列出:")
+    result = manager.list_command_files(recursive=True)
+    if result.success:
+        for file in result.command_files:
+            print(f"- {file}")
+    else:
+        print(f"错误: {result.errors}")
+
+
+def read_command_file_example(manager: CommandManager):
+    """读取命令文件示例"""
+    print("\n=== 读取命令文件 ===")
+    
+    # 读取第一个示例文件
+    command_file = manager.read_command_file("example1.autocodercommand")
+    if command_file:
+        print(f"文件名: {command_file.file_name}")
+        print(f"文件路径: {command_file.file_path}")
+        print("文件内容:")
+        print(command_file.content)
+    else:
+        print("文件不存在或读取失败")
+
+
+def analyze_command_file_example(manager: CommandManager):
+    """分析命令文件示例"""
+    print("\n=== 分析命令文件 ===")
+    
+    # 分析第一个示例文件
+    analysis = manager.analyze_command_file("example1.autocodercommand")
+    if analysis:
+        print(f"文件名: {analysis.file_name}")
+        print(f"原始变量: {', '.join(analysis.raw_variables)}")
+        print("变量详情:")
+        for var in analysis.variables:
+            print(f"  - {var.name}")
+            if var.default_value:
+                print(f"    默认值: {var.default_value}")
+            if var.description:
+                print(f"    描述: {var.description}")
+    else:
+        print("文件分析失败")
+
+
+def get_all_variables_example(manager: CommandManager):
+    """获取所有变量示例"""
+    print("\n=== 获取所有变量 ===")
+    
+    # 获取所有命令文件中的变量
+    variables_map = manager.get_all_variables(recursive=True)
+    for file, variables in variables_map.items():
+        print(f"文件: {file}")
+        print(f"变量: {', '.join(variables)}")
+        print()
+
+
+def main():
+    """主函数"""
+    # 设置测试环境
+    test_dir = setup_test_environment()
+    print(f"测试目录: {test_dir}")
+    
+    # 创建命令管理器
+    manager = CommandManager(test_dir)
+    
+    # 运行示例
+    list_command_files_example(manager)
+    read_command_file_example(manager)
+    analyze_command_file_example(manager)
+    get_all_variables_example(manager)
+
+
+if __name__ == "__main__":
+    main()

auto_coder-0.1.369/src/autocoder/common/command_file_manager/manager.py

@@ -0,0 +1,175 @@
+"""
+命令管理器
+
+整个模块的主入口，提供高层次的API接口，用于列出、读取和分析命令文件。
+"""
+
+import os
+import logging
+from typing import Dict, List, Optional, Set, Tuple
+
+from autocoder.common.command_file_manager.models import (
+    CommandFile, JinjaVariable, CommandFileAnalysisResult, ListCommandsResult
+)
+from autocoder.common.command_file_manager.utils import (
+    extract_jinja2_variables, extract_jinja2_variables_with_metadata,
+    analyze_command_file, is_command_file
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CommandManager:
+    """命令管理器，提供高层次的API接口"""
+    
+    def __init__(self, commands_dir: str):
+        """
+        初始化命令管理器
+        
+        Args:
+            commands_dir: 命令文件目录路径
+        """
+        self.commands_dir = os.path.abspath(commands_dir)
+        
+        # 确保目录存在
+        if not os.path.exists(self.commands_dir):
+            logger.warning(f"命令目录不存在: {self.commands_dir}")
+            os.makedirs(self.commands_dir, exist_ok=True)
+            logger.info(f"已创建命令目录: {self.commands_dir}")
+    
+    def list_command_files(self, recursive: bool = False) -> ListCommandsResult:
+        """
+        列出命令目录中的所有命令文件
+        
+        Args:
+            recursive: 是否递归搜索子目录
+            
+        Returns:
+            ListCommandsResult: 列出结果
+        """
+        result = ListCommandsResult(success=True)
+        
+        try:
+            if recursive:
+                for root, _, files in os.walk(self.commands_dir):
+                    for file in files:
+                        if is_command_file(file):
+                            file_path = os.path.join(root, file)
+                            rel_path = os.path.relpath(file_path, self.commands_dir)
+                            result.add_command_file(rel_path)
+            else:
+                for item in os.listdir(self.commands_dir):
+                    item_path = os.path.join(self.commands_dir, item)
+                    if os.path.isfile(item_path) and is_command_file(item):
+                        result.add_command_file(item)
+        except Exception as e:
+            logger.error(f"列出命令文件时出错: {str(e)}")
+            result.add_error(self.commands_dir, f"列出命令文件时出错: {str(e)}")
+        
+        return result
+    
+    def read_command_file(self, file_name: str) -> Optional[CommandFile]:
+        """
+        读取指定的命令文件
+        
+        Args:
+            file_name: 命令文件名或相对路径
+            
+        Returns:
+            Optional[CommandFile]: 命令文件对象，如果文件不存在则返回None
+        """
+        file_path = os.path.join(self.commands_dir, file_name)
+        
+        if not os.path.isfile(file_path):
+            logger.warning(f"命令文件不存在: {file_path}")
+            return None
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            return CommandFile(
+                file_path=file_path,
+                file_name=os.path.basename(file_path),
+                content=content
+            )
+        except Exception as e:
+            logger.error(f"读取命令文件时出错: {str(e)}")
+            return None
+    
+    def analyze_command_file(self, file_name: str) -> Optional[CommandFileAnalysisResult]:
+        """
+        分析指定的命令文件，提取其中的Jinja2变量
+        
+        Args:
+            file_name: 命令文件名或相对路径
+            
+        Returns:
+            Optional[CommandFileAnalysisResult]: 分析结果，如果文件不存在则返回None
+        """
+        command_file = self.read_command_file(file_name)
+        if command_file is None:
+            return None
+        
+        try:
+            return analyze_command_file(command_file.file_path, command_file.content)
+        except Exception as e:
+            logger.error(f"分析命令文件时出错: {str(e)}")
+            return None
+    
+    def get_all_variables(self, recursive: bool = False) -> Dict[str, Set[str]]:
+        """
+        获取所有命令文件中的变量
+        
+        Args:
+            recursive: 是否递归搜索子目录
+            
+        Returns:
+            Dict[str, Set[str]]: 文件路径到变量集合的映射
+        """
+        result: Dict[str, Set[str]] = {}
+        
+        list_result = self.list_command_files(recursive)
+        if not list_result.success:
+            logger.error("获取命令文件列表失败")
+            return result
+        
+        for file_name in list_result.command_files:
+            command_file = self.read_command_file(file_name)
+            if command_file is None:
+                continue
+            
+            try:
+                variables = extract_jinja2_variables(command_file.content)
+                result[file_name] = variables
+            except Exception as e:
+                logger.error(f"提取文件 {file_name} 的变量时出错: {str(e)}")
+        
+        return result
+    
+    def get_command_file_path(self, file_name: str) -> str:
+        """
+        获取命令文件的完整路径
+        
+        Args:
+            file_name: 命令文件名或相对路径
+            
+        Returns:
+            str: 命令文件的完整路径
+        """
+        return os.path.join(self.commands_dir, file_name)
+    
+    def _get_absolute_path(self, file_path: str) -> str:
+        """
+        获取文件的绝对路径
+        
+        Args:
+            file_path: 文件相对路径或绝对路径
+            
+        Returns:
+            str: 文件的绝对路径
+        """
+        if os.path.isabs(file_path):
+            return file_path
+        else:
+            return os.path.join(self.commands_dir, file_path)

auto_coder-0.1.369/src/autocoder/common/command_file_manager/models.py

@@ -0,0 +1,119 @@
+"""
+命令管理模块的数据模型
+
+定义了表示命令文件、命令内容和操作结果的数据类。
+"""
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+
+@dataclass
+class CommandFile:
+    """表示单个命令文件的信息"""
+    file_path: str
+    file_name: str
+    content: str
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'CommandFile':
+        """从字典创建CommandFile对象"""
+        return cls(
+            file_path=data['file_path'],
+            file_name=data['file_name'],
+            content=data['content']
+        )
+    
+    def to_dict(self) -> Dict:
+        """将CommandFile对象转换为字典"""
+        return {
+            'file_path': self.file_path,
+            'file_name': self.file_name,
+            'content': self.content
+        }
+
+
+@dataclass
+class JinjaVariable:
+    """表示从命令文件中提取的Jinja2变量"""
+    name: str
+    default_value: Optional[str] = None
+    description: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'JinjaVariable':
+        """从字典创建JinjaVariable对象"""
+        return cls(
+            name=data['name'],
+            default_value=data.get('default_value'),
+            description=data.get('description')
+        )
+    
+    def to_dict(self) -> Dict:
+        """将JinjaVariable对象转换为字典"""
+        return {
+            'name': self.name,
+            'default_value': self.default_value,
+            'description': self.description
+        }
+
+
+@dataclass
+class CommandFileAnalysisResult:
+    """表示命令文件分析的结果"""
+    file_path: str
+    file_name: str
+    variables: List[JinjaVariable] = field(default_factory=list)
+    raw_variables: Set[str] = field(default_factory=set)
+    
+    def add_variable(self, variable: JinjaVariable) -> None:
+        """添加一个变量"""
+        self.variables.append(variable)
+        self.raw_variables.add(variable.name)
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'CommandFileAnalysisResult':
+        """从字典创建CommandFileAnalysisResult对象"""
+        result = cls(
+            file_path=data['file_path'],
+            file_name=data['file_name'],
+            raw_variables=set(data.get('raw_variables', []))
+        )
+        
+        for var_data in data.get('variables', []):
+            result.variables.append(JinjaVariable.from_dict(var_data))
+        
+        return result
+    
+    def to_dict(self) -> Dict:
+        """将CommandFileAnalysisResult对象转换为字典"""
+        return {
+            'file_path': self.file_path,
+            'file_name': self.file_name,
+            'variables': [var.to_dict() for var in self.variables],
+            'raw_variables': list(self.raw_variables)
+        }
+
+
+@dataclass
+class ListCommandsResult:
+    """表示列出命令文件的结果"""
+    success: bool
+    command_files: List[str] = field(default_factory=list)
+    errors: Dict[str, str] = field(default_factory=dict)
+    
+    @property
+    def has_errors(self) -> bool:
+        """是否有错误"""
+        return len(self.errors) > 0
+    
+    def add_error(self, path: str, error_message: str) -> None:
+        """添加错误信息"""
+        self.errors[path] = error_message
+        self.success = False
+    
+    def add_command_file(self, file_path: str) -> None:
+        """添加命令文件路径"""
+        self.command_files.append(file_path)

auto_coder-0.1.369/src/autocoder/common/command_file_manager/utils.py

@@ -0,0 +1,119 @@
+"""
+命令管理模块的工具函数
+
+提供用于处理命令文件和提取Jinja2变量的工具函数。
+"""
+
+import os
+import re
+from typing import List, Set, Dict, Optional, Tuple
+
+from autocoder.common.command_file_manager.models import JinjaVariable, CommandFileAnalysisResult
+
+
+def extract_jinja2_variables(content: str) -> Set[str]:
+    """
+    从文本内容中提取Jinja2变量名
+    
+    Args:
+        content: 文本内容
+        
+    Returns:
+        Set[str]: 变量名集合
+    """
+    # 匹配 {{ variable }} 格式的变量
+    pattern = r'{{\s*([a-zA-Z0-9_]+)\s*}}'
+    variables = set(re.findall(pattern, content))
+    
+    # 匹配 {% if variable %} 等控制结构中的变量
+    control_pattern = r'{%\s*(?:if|for|elif|unless)\s+(?:not\s+)?([a-zA-Z0-9_]+)'
+    control_vars = set(re.findall(control_pattern, content))
+    
+    # 合并结果
+    variables.update(control_vars)
+    
+    return variables
+
+
+def extract_jinja2_variables_with_metadata(content: str) -> List[JinjaVariable]:
+    """
+    从文本内容中提取Jinja2变量及其元数据（如默认值和描述）
+    
+    此函数会查找特殊注释格式来提取变量的元数据：
+    {# @var: variable_name, default: default_value, description: variable description #}
+    
+    Args:
+        content: 文本内容
+        
+    Returns:
+        List[JinjaVariable]: 变量对象列表
+    """
+    # 首先提取所有原始变量名
+    raw_variables = extract_jinja2_variables(content)
+    
+    # 查找变量元数据注释
+    metadata_pattern = r'{#\s*@var:\s*([a-zA-Z0-9_]+)(?:\s*,\s*default:\s*([^,]+))?(?:\s*,\s*description:\s*([^#]+))?\s*#}'
+    metadata_matches = re.finditer(metadata_pattern, content)
+    
+    # 创建变量字典，键为变量名
+    variables_dict: Dict[str, JinjaVariable] = {}
+    
+    # 处理元数据注释
+    for match in metadata_matches:
+        var_name = match.group(1).strip()
+        default_value = match.group(2).strip() if match.group(2) else None
+        description = match.group(3).strip() if match.group(3) else None
+        
+        variables_dict[var_name] = JinjaVariable(
+            name=var_name,
+            default_value=default_value,
+            description=description
+        )
+    
+    # 为没有元数据的变量创建基本对象
+    for var_name in raw_variables:
+        if var_name not in variables_dict:
+            variables_dict[var_name] = JinjaVariable(name=var_name)
+    
+    return list(variables_dict.values())
+
+
+def analyze_command_file(file_path: str, file_content: str) -> CommandFileAnalysisResult:
+    """
+    分析命令文件，提取其中的Jinja2变量
+    
+    Args:
+        file_path: 文件路径
+        file_content: 文件内容
+        
+    Returns:
+        CommandFileAnalysisResult: 分析结果
+    """
+    file_name = os.path.basename(file_path)
+    
+    # 提取变量及其元数据
+    variables = extract_jinja2_variables_with_metadata(file_content)
+    raw_variable_names = extract_jinja2_variables(file_content)
+    
+    # 创建分析结果
+    result = CommandFileAnalysisResult(
+        file_path=file_path,
+        file_name=file_name,
+        variables=variables,
+        raw_variables=raw_variable_names
+    )
+    
+    return result
+
+
+def is_command_file(file_name: str) -> bool:
+    """
+    检查文件是否为命令文件
+    
+    Args:
+        file_name: 文件名
+        
+    Returns:
+        bool: 是否为命令文件
+    """
+    return file_name.endswith('.md')

{auto_coder-0.1.366 → auto_coder-0.1.369}/src/autocoder/common/v2/agent/agentic_edit.py

@@ -936,7 +936,8 @@ class AgenticEdit:
                         logger.info(
                             "AgenticEdit analyze loop finished due to AttemptCompletion.")
                         save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")        
-                        return
+                        mark_event_should_finish = True
+                        continue
 
                     if isinstance(tool_obj, PlanModeRespondTool):
                         logger.info(
@@ -946,7 +947,8 @@ class AgenticEdit:
                         logger.info(
                             "AgenticEdit analyze loop finished due to PlanModeRespond.")
                         save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")        
-                        return
+                        mark_event_should_finish = True
+                        continue
 
                     # Resolve the tool
                     resolver_cls = TOOL_RESOLVER_MAP.get(type(tool_obj))

{auto_coder-0.1.366 → auto_coder-0.1.369}/src/autocoder/events/event_manager.py

@@ -147,7 +147,7 @@ class EventManager:
         logger.debug(f"Waiting for response to event: {event.event_id}")
         
         # 无限等待响应，不设超时
-        wait_result = blocker.wait(timeout=60.0)  # 设置一个较长的超时时间（60秒）
+        wait_result = blocker.wait(timeout=60.0*60)  # 设置一个较长的超时时间（60秒）
         
         if not wait_result:
             logger.warning(f"Timeout waiting for response to event: {event.event_id}")

auto_coder-0.1.369/src/autocoder/version.py

@@ -0,0 +1,2 @@
+
+__version__ = "0.1.369"

auto_coder-0.1.366/src/autocoder/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.366"