auto-coder 0.1.367__py3-none-any.whl → 0.1.370__py3-none-any.whl

{auto_coder-0.1.367.dist-info → auto_coder-0.1.370.dist-info}/METADATA

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

{auto_coder-0.1.367.dist-info → auto_coder-0.1.370.dist-info}/RECORD

@@ -14,7 +14,7 @@ autocoder/command_parser.py,sha256=fx1g9E6GaM273lGTcJqaFQ-hoksS_Ik2glBMnVltPCE,1
 autocoder/lang.py,sha256=PFtATuOhHRnfpqHQkXr6p4C893JvpsgwTMif3l-GEi0,14321
 autocoder/models.py,sha256=Gu50IATQtZtgEir1PpCfwgH6o4ygw6XqqbQRj3lx5dU,13798
 autocoder/run_context.py,sha256=IUfSO6_gp2Wt1blFWAmOpN0b0nDrTTk4LmtCYUBIoro,1643
-autocoder/version.py,sha256=h8-NqRVaMTNeO7d427-He9JWyfNB1qAzKWEkF2GN9dw,25
+autocoder/version.py,sha256=zqOBO5WdpPJ-GjzRIIEqPqlEUWeZxaPhquf25C1uUHw,25
 autocoder/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/agent/agentic_edit.py,sha256=XsfePZ-t6M-uBSdG1VLZXk1goqXk2HPeJ_A8IYyBuWQ,58896
 autocoder/agent/agentic_edit_types.py,sha256=oFcDd_cxJ2yH9Ed1uTpD3BipudgoIEWDMPb5pAkq4gI,3288
@@ -22,7 +22,7 @@ autocoder/agent/agentic_filter.py,sha256=zlInIRhawKIYTJjCiJBWqPCOV5UtMbh5VnvszfT
 autocoder/agent/auto_demand_organizer.py,sha256=URAq0gSEiHeV_W4zwhOI_83kHz0Ryfj1gcfh5jwCv_w,6501
 autocoder/agent/auto_filegroup.py,sha256=pBsAkBcpFTff-9L5OwI8xhf2xPKpl-aZwz-skF2B6dc,6296
 autocoder/agent/auto_guess_query.py,sha256=rDSdhpPHcOGE5MuDXvIrhCXAPR4ARS1LqpyoLsx2Jhw,11374
-autocoder/agent/auto_learn.py,sha256=yZTapSm3kQ9zHnGknDUWGju6_Q9GE7EY0qfDJgV_Fls,23281
+autocoder/agent/auto_learn.py,sha256=EMSbIVo2DK9Lp4sxFtpK4HRxqclGVKHYex51SG7SJpM,13942
 autocoder/agent/auto_learn_from_commit.py,sha256=edD4GQJyO2qvVnTKyldeswWoNeKe1Aaua6ieJzlGlFI,10662
 autocoder/agent/auto_review_commit.py,sha256=1z9FOUDPZTWnrPmJ-TwUlXLOTDPmRcAlYqXbUj1pi08,11015
 autocoder/agent/auto_tool.py,sha256=DBzip-P_T6ZtT2eHexPcusmKYD0h7ufzp7TLwXAY10E,11554
@@ -142,6 +142,11 @@ autocoder/common/text.py,sha256=KGRQq314GHBmY4MWG8ossRoQi1_DTotvhxchpn78c-k,1003
 autocoder/common/token_cost_caculate.py,sha256=MSWJtl7YpQSUt-gFQoqUcJMblyPqHXe2ZioiZOFkV80,10085
 autocoder/common/types.py,sha256=Cw_4RH-rGmAgQE-Ck69maMAMqlPCDA4Yj37QmuUY0mQ,713
 autocoder/common/utils_code_auto_generate.py,sha256=sqtLmVxRveRwqLwJ8UlDgwngwmh2AAo3vgl-I-ALcDQ,4597
+autocoder/common/command_file_manager/__init__.py,sha256=ardiG_iuWhurfbN6RO4wij2U7Dmafnxn2vgWYYxKqDM,970
+autocoder/common/command_file_manager/examples.py,sha256=kWNVK_iDvQn5NtA8D791Oxkj8xP5DWSD72PcMYIgwBQ,4067
+autocoder/common/command_file_manager/manager.py,sha256=XmCOaWgGo3RemU1ubYOoNr40eaRqGHCwX7GS2vt3voo,5935
+autocoder/common/command_file_manager/models.py,sha256=cDYRSQGK5O4nFI0GGHQvHcPeNKUxKePZQCgy7Mfw3kU,3471
+autocoder/common/command_file_manager/utils.py,sha256=OA9OhB1VnkvnFGof9p6jGfIVx31usUcqucXZCkqNm4I,3488
 autocoder/common/conversations/__init__.py,sha256=xGZeOFrDsgg2fkPK1zmvYBDhAyX66FtgOcZaxhYKJXU,1338
 autocoder/common/conversations/compatibility.py,sha256=WuBXB4-dw5X9LUMsB16VWbihvRZQ1tT99m6zuBwDfqE,9606
 autocoder/common/conversations/conversation_manager.py,sha256=ZhuhfSdOTncqgy3nHPoEU7Cg0dCsSl-VPcvLbUlL2Tk,18295
@@ -354,9 +359,9 @@ autocoder/utils/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/utils/auto_coder_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/utils/auto_coder_utils/chat_stream_out.py,sha256=t902pKxQ5xM7zgIHiAOsTPLwxhE6VuvXAqPy751S7fg,14096
 autocoder/utils/chat_auto_coder_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auto_coder-0.1.367.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-auto_coder-0.1.367.dist-info/METADATA,sha256=1M8FJDPaqao8EERBqrdN-p7V-VykNvS2imDrncLh63Y,2775
-auto_coder-0.1.367.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-auto_coder-0.1.367.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
-auto_coder-0.1.367.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
-auto_coder-0.1.367.dist-info/RECORD,,
+auto_coder-0.1.370.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+auto_coder-0.1.370.dist-info/METADATA,sha256=XG9OcN3l6UOPuZbFKubCHYv_-sf3NipSc_TkeAPnoS8,2775
+auto_coder-0.1.370.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+auto_coder-0.1.370.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
+auto_coder-0.1.370.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
+auto_coder-0.1.370.dist-info/RECORD,,

autocoder/agent/auto_learn.py

@@ -33,17 +33,8 @@ class AutoLearn:
                        querie_with_urls_and_changes: List[Tuple[str, List[str], Dict[str, Tuple[str, str]]]],                       
                        new_query:str,            
                        ) -> str:
-        """
-        作为高级软件工程师，请对提供的代码提交变更进行深入分析，提取具有通用价值的功能模式和设计模式，转化为可在其他项目中复用的代码规则（rules）。
-
-        ## 任务目标
-        - 识别代码变更中具有普遍应用价值的功能点和模式
-        - 将这些功能点提炼为结构化规则，便于在其他项目中快速复用
-        - 生成清晰的使用示例，包含完整依赖和调用方式
-        - 这些规则将被存储在项目的 {{ project_root }}/.autocoderrules 目录，供后续自动化代码生成使用        
-
-        ## 分析对象        
-        下面是本次提交的代码变更：
+        """        
+        下面是用户一次提交的代码变更：
         <changes>
         {% for query,urls,changes in querie_with_urls_and_changes %}
         ## 原始的任务需求
@@ -69,360 +60,124 @@ class AutoLearn:
         {% endfor %}
         {% endfor %}
         </changes>
+        
 
-        {% if index_file_content %}
-        ## 现有索引内容
-        index.md 当前内容:        
-        <files>  
-        <file>
-        ##File: 
+        请对根据上面的代码变更进行深入分析，提取具有通用价值的功能模式和设计模式，转化为可在其他项目中复用的代码规则（rules）。
+        
+        - 识别代码变更中具有普遍应用价值的功能点和模式
+        - 将这些功能点提炼为结构化规则，便于在其他项目中快速复用
+        - 生成清晰的使用示例，包含完整依赖和调用方式
+        - 这些规则将被存储在项目的 {{ rules_path }} 目录，供后续自动化代码生成使用   
+        - 更新 {{rules_index_path}} 文件,确保改文件有新增文件的描述信息
+        
+        当前 {{rules_index_path}} 文件内容:
+        {% if index_file_content %}                                
         {{ index_file_content }}      
-        </file>
-        </files>
+        {% else %}
+        <为空>
         {% endif %}
-
-        ## 用户需求
-        {{ new_query }}
-
-        ## 生成或者更新的规则文件结构
-
-            ---
-            description: [简明描述规则的功能，20字以内]
-            globs: [匹配应用此规则的文件路径，如"src/services/*.py"]
-            alwaysApply: [是否总是应用，通常为false]
-            ---
-
-            # [规则主标题]
-
-            ## 简要说明
-            [该规则的功能、适用场景和价值，100字以内]
-
-            ## 典型用法
-            ```python
-            # 完整的代码示例，包含:
-            # 1. 必要的import语句
-            # 2. 类/函数定义
-            # 3. 参数说明
-            # 4. 调用方式
-            # 5. 关键注释        
-            ```
-
-            ## 依赖说明
-            - [必要的依赖库及版本]
-            - [环境要求]
-            - [初始化流程(如有)]
-
-            ## 学习来源
-            [从哪个提交变更的哪部分代码中提取的该功能点]                
-
-        ## 生成或者更新的规则文件示例
-        
-            ---
-            description: Git提交分析工具
-            globs: "src/utils/git_analyzer.py"
-            alwaysApply: false
-            ---
-
-            # Git提交分析工具
-
-            ## 简要说明
-            提供从Git仓库中获取提交变更并分析差异的工具函数，支持首次提交和普通提交的差异获取，适用于代码审查、变更追踪和自动化分析场景。
-
-            ## 典型用法
-            ```python
-            import git
-            from typing import Dict, Tuple, List, Optional
-
-            def get_commit_changes(repo_path: str, commit_id: str) -> Dict[str, Tuple[Optional[str], Optional[str]]]:
-                '''
-                获取指定commit的文件变更内容
-
-                Args:
-                    repo_path: Git仓库路径
-                    commit_id: 提交ID
-
-                Returns:
-                    Dict[str, Tuple[Optional[str], Optional[str]]]: 文件路径到(变更前内容,变更后内容)的映射
-                '''
-                changes = {}
-                try:
-                    repo = git.Repo(repo_path)
-                    commit = repo.commit(commit_id)
-
-                    # 检查是否是首次提交（没有父提交）
-                    if not commit.parents:
-                        # 首次提交，获取所有文件
-                        for item in commit.tree.traverse():
-                            if item.type == 'blob':  # 只处理文件，不处理目录
-                                file_path = item.path
-                                # 首次提交前没有内容
-                                before_content = None
-                                # 获取提交后的内容
-                                after_content = repo.git.show(f"{commit.hexsha}:{file_path}")
-                                changes[file_path] = (before_content, after_content)
-                    else:
-                        # 获取parent commit
-                        parent = commit.parents[0]
-                        # 获取变更的文件列表
-                        for diff_item in parent.diff(commit):
-                            file_path = diff_item.a_path if diff_item.a_path else diff_item.b_path
-
-                            # 获取变更前内容
-                            before_content = None
-                            try:
-                                if diff_item.a_blob:
-                                    before_content = repo.git.show(f"{parent.hexsha}:{file_path}")
-                            except git.exc.GitCommandError:
-                                pass  # 文件可能是新增的
-
-                            # 获取变更后内容
-                            after_content = None
-                            try:
-                                if diff_item.b_blob:
-                                    after_content = repo.git.show(f"{commit.hexsha}:{file_path}")
-                            except git.exc.GitCommandError:
-                                pass  # 文件可能被删除
-
-                            changes[file_path] = (before_content, after_content)
-
-                    return changes
-                except Exception as e:
-                    print(f"获取提交变更时出错: {str(e)}")
-                    return {}
-            ```
-
-            ## 依赖说明
-            - GitPython>=3.1.0
-            - Python>=3.7
-
-            ## 学习来源
-            从代码提交变更中提取的Git仓库差异分析功能        
-
-        ## 索引文件更新说明
-
-        除了生成规则文件外，请务必更新index.md索引文件，记录所有规则及其作用。如果 index.md 当前内容为空，请按如下格式创建:
-              
-        # Rules索引
-
-        本文档记录项目中所有可用的代码规则(rules)及其用途。
-
-        ## [规则文件路径]
-        [规则文件的主要功能和适用场景简述]    
-
-        ## 评价标准
-        - 提取的功能点必须具备独立价值，能在其他项目中实际复用
-        - 代码示例必须完整、可执行，包含所有必要组件
-        - 文档结构清晰，遵循规定格式
-        - 依赖说明明确具体，便于用户快速配置环境
-
-        请根据要求生成或者更新规则文件(markdown文件)，并将规则文件存储在项目的 {{ project_root }}/.autocoderrules 目录，供后续自动化代码生成使用。
+        - {{ new_query }} 
+                                
+
+        最后，新生成的文件格式要是这种形态的：
+    
+       <example_rules>
+        ---
+        description: [简明描述规则的功能，20字以内]
+        globs: [匹配应用此规则的文件路径，如"src/services/*.py"]
+        alwaysApply: [是否总是应用，通常为false]
+        ---
+
+        # [规则主标题]
+
+        ## 简要说明
+        [该规则的功能、适用场景和价值，100字以内]
+
+        ## 典型用法
+        ```python
+        # 完整的代码示例，包含:
+        # 1. 必要的import语句
+        # 2. 类/函数定义
+        # 3. 参数说明
+        # 4. 调用方式
+        # 5. 关键注释        
+        ```
+
+        ## 依赖说明
+        - [必要的依赖库及版本]
+        - [环境要求]
+        - [初始化流程(如有)]
+
+        ## 学习来源
+        [从哪个提交变更的哪部分代码中提取的该功能点]    
+        </example_rules>                
         """
         return {
             "project_root": os.path.abspath(self.args.source_dir),
-            "index_file_content": self._get_index_file_content()
+            "index_file_content": self._get_index_file_content(),
+            "rules_path": os.path.join(os.path.abspath(self.args.source_dir), ".autocoderrules"),
+            "rules_index_path": os.path.join(os.path.abspath(self.args.source_dir), ".autocoderrules", "index.md")
         }
 
     @byzerllm.prompt()
     def analyze_modules(self, sources: SourceCodeList, query: str) -> str:
         """
-        作为高级软件工程师，请对提供的模块代码进行深入分析，提取具有通用价值的功能模式和设计模式，转化为可在其他项目中复用的代码规则（rules）。
-
-        ## 任务目标
-        - 识别代码中具有普遍应用价值的功能点和模式
-        - 将这些功能点提炼为结构化规则，便于在其他项目中快速复用
-        - 生成清晰的使用示例，包含完整依赖和调用方式
-        - 这些规则将被存储在项目的 {{ project_root }}/.autocoderrules 目录，供后续自动化代码生成使用
-
-        项目根目录: {{ project_root }}
-
-        ## 分析对象                
-        {% if sources.sources %}
-        分析目标文件:
-        {% for source in sources.sources %}
-        - {{ source.module_name }}
-        {% endfor %}
-        {% else %}
-        前面提供的文件。
-        {% endif %}
-
-        {% if sources.sources %}
-        ## 源代码内容
+        下面是用户提供的需要抽取规则的代码：
         <files>
         {% for source in sources.sources %}
         ##File: {{ source.module_name }}        
         {{ source.source_code }}        
         {% endfor %}
         </files>
-        {% endif %}
-
-        {% if index_file_content %}
-        ## 现有索引内容
-        index.md 当前内容:        
-        <files>  
-        <file>
-        ##File: 
-        {{ index_file_content }}      
-        </file>
-        </files>
-        {% endif %}
 
-        ## 用户需求
-        {{ query }}
-
-        ## 生成或者更新的规则文件结构
+        请对对上面的代码进行深入分析，提取具有通用价值的功能模式和设计模式，转化为可在其他项目中复用的代码规则（rules）。
         
-            ---
-            description: [简明描述规则的功能，20字以内]
-            globs: [匹配应用此规则的文件路径，如"src/services/*.py"]
-            alwaysApply: [是否总是应用，通常为false]
-            ---
-
-            # [规则主标题]
-
-            ## 简要说明
-            [该规则的功能、适用场景和价值，100字以内]
-
-            ## 典型用法
-            ```python
-            # 完整的代码示例，包含:
-            # 1. 必要的import语句
-            # 2. 类/函数定义
-            # 3. 参数说明
-            # 4. 调用方式
-            # 5. 关键注释        
-
-            ## 依赖说明
-            - [必要的依赖库及版本]
-            - [环境要求]
-            - [初始化流程(如有)]
-
-            ## 学习来源
-            [从哪个模块的哪部分代码中提取的该功能点]
-            </markdown>        
-
-        ## 生成或者更新的规则文件示例
+        - 识别代码变更中具有普遍应用价值的功能点和模式
+        - 将这些功能点提炼为结构化规则，便于在其他项目中快速复用
+        - 生成清晰的使用示例，包含完整依赖和调用方式
+        - 这些规则将被存储在项目的 {{ rules_path }} 目录，供后续自动化代码生成使用   
+        - 更新 {{rules_index_path}} 文件,确保改文件有新增文件的描述信息
         
-            ---
-            description: RPC服务模板
-            globs: "src/services/rpc_service.py"
-            alwaysApply: false
-            ---
-
-            # RPC服务快速实现模板
-
-            ## 简要说明
-            提供gRPC服务端与客户端的标准实现模板，包含服务定义、请求处理、错误处理和客户端调用。适用于需要高性能RPC通信的微服务架构。
-
-            ## 典型用法
-            ```python
-            # 服务端实现
-            import grpc
-            from concurrent import futures
-            import logging
-            import time
-            from typing import Dict, Any
-
-            import service_pb2
-            import service_pb2_grpc
-
-            class ServiceImplementation(service_pb2_grpc.MyServiceServicer):
-                def __init__(self, config: Dict[str, Any] = None):
-                    self.config = config or {}
-                    logging.info("RPC服务初始化完成")
-
-                def ProcessRequest(self, request, context):                
-                    try:
-                        # 业务逻辑处理
-                        result = self._process_business_logic(request)
-
-                        # 构建响应
-                        return service_pb2.Response(
-                            status=200,
-                            message="处理成功",
-                            data=result
-                        )
-                    except Exception as e:
-                        logging.error(f"处理请求时发生错误: {str(e)}")
-                        context.set_code(grpc.StatusCode.INTERNAL)
-                        context.set_details(f"服务器内部错误: {str(e)}")
-                        return service_pb2.Response(
-                            status=500,
-                            message=f"处理失败: {str(e)}",
-                            data={}
-                        )
-
-                def _process_business_logic(self, request):
-                    # 实际业务逻辑处理
-                    return {"result": request.param1 + request.param2}
-
-            def serve(port=50051, max_workers=10):            
-                server = grpc.server(futures.ThreadPoolExecutor(max_workers=max_workers))
-                service_pb2_grpc.add_MyServiceServicer_to_server(
-                    ServiceImplementation(), server
-                )
-                server.add_insecure_port(f'[::]:{port}')
-                server.start()
-                logging.info(f"服务已启动，监听端口: {port}")
-
-                try:
-                    while True:
-                        time.sleep(86400)  # 一天
-                except KeyboardInterrupt:
-                    server.stop(0)
-                    logging.info("服务已停止")
-
-            if __name__ == '__main__':
-                logging.basicConfig(level=logging.INFO)
-                serve()
-            ```
-
-            ## 依赖说明
-            - 需要安装 grpcio>=1.44.0 和 grpcio-tools>=1.44.0
-            - 需要预先定义proto文件并生成对应Python代码:
-            ```bash
-            python -m grpc_tools.protoc -I./protos --python_out=. --grpc_python_out=. ./protos/service.proto
-            ```
-            - 示例proto文件结构:
-            ```protobuf
-            syntax = "proto3";
-
-            service MyService {
-                rpc ProcessRequest (Request) returns (Response) {}
-            }
-
-            message Request {
-                int32 param1 = 1;
-                int32 param2 = 2;
-            }
-
-            message Response {
-                int32 status = 1;
-                string message = 2;
-                map<string, string> data = 3;
-            }
-            ```
-
-            ## 学习来源
-            从src/services/rpc_service.py模块中的Server类和RequestHandler实现提取        
-
-        ## 索引文件更新说明
-
-        除了生成规则文件外，请务必更新index.md索引文件，记录所有规则及其作用。如果 index.md 当前内容为空，请按如下格式创建:
-               
-        # Rules索引
-
-        本文档记录项目中所有可用的代码规则(rules)及其用途。
-
-        ## [规则文件路径]
-        [规则文件的主要功能和适用场景简述]    
-
-        ## 评价标准
-        - 提取的功能点必须具备独立价值，能在其他项目中实际复用
-        - 代码示例必须完整、可执行，包含所有必要组件
-        - 文档结构清晰，遵循规定格式
-        - 依赖说明明确具体，便于用户快速配置环境
-
-        请根据要求生成或者更新规则文件(markdown文件)，并将规则文件存储在项目的 {{ project_root }}/.autocoderrules 目录，供后续自动化代码生成使用。
+        当前 {{rules_index_path}} 文件内容:
+        {% if index_file_content %}                                
+        {{ index_file_content }}      
+        {% else %}
+        <为空>
+        {% endif %}
+        - {{ query }} 
+                                
+        最后，新生成的文件格式要是这种形态的：
+    
+        <example_rules>
+        ---
+        description: [简明描述规则的功能，20字以内]
+        globs: [匹配应用此规则的文件路径，如"src/services/*.py"]
+        alwaysApply: [是否总是应用，通常为false]
+        ---
+
+        # [规则主标题]
+
+        ## 简要说明
+        [该规则的功能、适用场景和价值，100字以内]
+
+        ## 典型用法
+        ```python
+        # 完整的代码示例，包含:
+        # 1. 必要的import语句
+        # 2. 类/函数定义
+        # 3. 参数说明
+        # 4. 调用方式
+        # 5. 关键注释        
+        ```
+
+        ## 依赖说明
+        - [必要的依赖库及版本]
+        - [环境要求]
+        - [初始化流程(如有)]
+
+        ## 学习来源
+        [从哪个提交变更的哪部分代码中提取的该功能点]    
+        </example_rules>   
         """
 
         # 获取索引文件内容
@@ -430,7 +185,9 @@ class AutoLearn:
 
         return {
             "project_root": os.path.abspath(self.args.source_dir),
-            "index_file_content": index_file_content
+            "index_file_content": index_file_content,
+            "rules_path": os.path.join(os.path.abspath(self.args.source_dir), ".autocoderrules"),
+            "rules_index_path": os.path.join(os.path.abspath(self.args.source_dir), ".autocoderrules", "index.md")
         }
 
     def get_commit_changes(self, commit_id: str) -> Tuple[List[Tuple[str, List[str], Dict[str, Tuple[str, str]]]], Optional[str]]:

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'
+]

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()

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)

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)

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')

autocoder/version.py

@@ -1,2 +1,2 @@
 
-__version__ = "0.1.367"
+__version__ = "0.1.370"