auto-coder 0.1.205__tar.gz → 0.1.206__tar.gz

{auto_coder-0.1.205 → auto_coder-0.1.206}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.205
+Version: 0.1.206
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.205 → auto_coder-0.1.206}/setup.py

@@ -41,7 +41,8 @@ setup(
     },
     package_dir={"": "src"},
     packages=find_packages("src"),    
-    package_data={        
+    package_data={
+        "autocoder": ["data/**/*"],
     },
     install_requires=install_requires,
     classifiers=[        

{auto_coder-0.1.205 → auto_coder-0.1.206}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.205
+Version: 0.1.206
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.205 → auto_coder-0.1.206}/src/auto_coder.egg-info/SOURCES.txt

@@ -12,12 +12,14 @@ src/autocoder/auto_coder.py
 src/autocoder/auto_coder_lang.py
 src/autocoder/auto_coder_rag.py
 src/autocoder/auto_coder_server.py
+src/autocoder/benchmark.py
 src/autocoder/chat_auto_coder.py
 src/autocoder/chat_auto_coder_lang.py
 src/autocoder/command_args.py
 src/autocoder/lang.py
 src/autocoder/version.py
 src/autocoder/agent/__init__.py
+src/autocoder/agent/auto_filegroup.py
 src/autocoder/agent/auto_tool.py
 src/autocoder/agent/coder.py
 src/autocoder/agent/designer.py
@@ -29,6 +31,7 @@ src/autocoder/common/ShellClient.py
 src/autocoder/common/__init__.py
 src/autocoder/common/anything2images.py
 src/autocoder/common/audio.py
+src/autocoder/common/chunk_validation.py
 src/autocoder/common/cleaner.py
 src/autocoder/common/code_auto_execute.py
 src/autocoder/common/code_auto_generate.py
@@ -47,12 +50,14 @@ src/autocoder/common/git_utils.py
 src/autocoder/common/image_to_page.py
 src/autocoder/common/interpreter.py
 src/autocoder/common/llm_rerank.py
+src/autocoder/common/recall_validation.py
 src/autocoder/common/screenshots.py
 src/autocoder/common/search.py
 src/autocoder/common/search_replace.py
 src/autocoder/common/sys_prompt.py
 src/autocoder/common/text.py
 src/autocoder/common/types.py
+src/autocoder/data/tokenizer.json
 src/autocoder/db/__init__.py
 src/autocoder/db/store.py
 src/autocoder/dispacher/__init__.py
@@ -107,6 +112,7 @@ src/autocoder/utils/conversation_store.py
 src/autocoder/utils/llm_client_interceptors.py
 src/autocoder/utils/log_capture.py
 src/autocoder/utils/multi_turn.py
+src/autocoder/utils/operate_config_api.py
 src/autocoder/utils/print_table.py
 src/autocoder/utils/queue_communicate.py
 src/autocoder/utils/request_event_queue.py

auto_coder-0.1.206/src/autocoder/agent/auto_filegroup.py

@@ -0,0 +1,202 @@
+from typing import List, Dict, Optional, Any, Tuple
+import os
+import yaml
+from loguru import logger
+import byzerllm
+import pydantic
+
+
+class FileGroup(pydantic.BaseModel):
+    name: str
+    description: str
+    queries: List[str]
+    urls: List[str]    
+
+
+class FileGroups(pydantic.BaseModel):
+    groups: List[FileGroup]
+
+
+def load_yaml_config(yaml_file: str) -> Dict:
+    """加载YAML配置文件"""
+    try:
+        with open(yaml_file, 'r', encoding='utf-8') as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        logger.error(f"Error loading yaml file {yaml_file}: {str(e)}")
+        return {}
+
+
+class AutoFileGroup:
+    def __init__(self, llm: byzerllm.ByzerLLM, 
+                 project_dir: str, 
+                 skip_diff: bool = False,
+                 group_num_limit: int = 10,
+                 file_size_limit: int = 100):
+        """
+        初始化AutoFileGroup
+
+        Args:
+            actions_dir: 包含YAML文件的目录
+        """
+        self.project_dir = project_dir
+        self.actions_dir = os.path.join(project_dir, "actions")
+        self.llm = llm
+        self.file_size_limit = file_size_limit
+        self.skip_diff = skip_diff
+        self.group_num_limit = group_num_limit
+
+    @byzerllm.prompt()
+    def group_by_similarity(self, querie_with_urls: List[Tuple[str, List[str], str]]) -> str:
+        """
+        分析多个开发任务的关联性，将相互关联的任务进行分组。
+
+        输入说明：
+        querie_with_urls 包含多个开发任务信息，每个任务由以下部分组成：
+        1. query: 任务需求描述
+        2. urls: 需要修改的文件路径列表
+        3. diff: Git diff信息，展示具体的代码修改
+
+        示例数据：
+        <queries>
+        {% for query,urls,diff in querie_with_urls %}
+        ## {{ query }}        
+
+        修改的文件:
+        {% for url in urls %}
+        - {{ url }}
+        {% endfor %}
+        {% if diff %}
+
+        代码变更:
+        ```diff
+        {{ diff }}
+        ```
+        {% endif %}        
+        {% endfor %}
+        </queries>
+
+        分组规则：
+        1. 每个分组至少包含2个query
+        2. 根据以下维度判断任务的关联性：
+           - 功能相似性：任务是否属于同一个功能模块
+           - 文件关联：修改的文件是否有重叠或紧密关联
+           - 代码依赖：代码修改是否存在依赖关系
+           - 业务目的：任务的最终业务目标是否一致
+        3. 输出的分组数量最多不超过 {{ group_num_limit }}
+
+        期望输出：
+        返回符合以下格式的JSON:
+        {
+          "groups": [
+            {
+              "name": "分组名称",
+              "description": "分组的功能概述，描述该组任务的共同目标",
+              "queries": ["相关的query1", "相关的query2"],
+              "urls": ["相关的文件1", "相关的文件2"]
+            }
+          ]
+        }
+
+        特别说明：
+        1. 分组名称应该简洁且具有描述性，能反映该组任务的主要特征
+        2. 分组描述应突出任务间的共同点和关联性
+        3. 返回的urls应该是该组任务涉及的所有相关文件的并集
+        """
+        return {
+            "group_num_limit": self.group_num_limit
+        }
+
+
+    def group_files(self) -> List[Dict]:
+        """
+        根据YAML文件中的query和urls进行文件分组，并获取相关的git commit信息
+
+        Returns:
+            List[Dict]: 分组结果列表
+        """
+        import git
+        import hashlib
+
+        # 获取所有YAML文件
+        action_files = [
+            f for f in os.listdir(self.actions_dir)
+            if f[:3].isdigit() and "_" in f and f.endswith('.yml')
+        ]
+
+        # 按序号排序
+        def get_seq(name):
+            return int(name.split("_")[0])
+        
+        # 获取最新的action文件列表
+        action_files = sorted(action_files, key=get_seq)
+        action_files.reverse()
+
+        action_files = action_files[:self.file_size_limit]
+
+        querie_with_urls_and_diffs = []
+        repo = git.Repo(self.project_dir)
+
+        # 收集所有query、urls和对应的commit diff
+        for yaml_file in action_files:
+            yaml_path = os.path.join(self.actions_dir, yaml_file)
+            config = load_yaml_config(yaml_path)
+
+            if not config:
+                continue
+
+            query = config.get('query', '')
+            urls = config.get('urls', [])
+
+            if query and urls:  
+                commit_diff = ""
+                if not self.skip_diff:
+                    # 计算文件的MD5用于匹配commit
+                    file_md5 = hashlib.md5(open(yaml_path, 'rb').read()).hexdigest()
+                    response_id = f"auto_coder_{yaml_file}_{file_md5}"
+                    # 查找对应的commit                   
+                    try:
+                        for commit in repo.iter_commits():
+                            if response_id in commit.message:
+                                if commit.parents:
+                                    parent = commit.parents[0]
+                                    commit_diff = repo.git.diff(
+                                        parent.hexsha, commit.hexsha)
+                                else:
+                                    commit_diff = repo.git.show(commit.hexsha)
+                                break
+                    except git.exc.GitCommandError as e:
+                        logger.error(f"Git命令执行错误: {str(e)}")
+                    except Exception as e:
+                        logger.error(f"获取commit diff时出错: {str(e)}")
+
+                querie_with_urls_and_diffs.append((query, urls, commit_diff))
+
+        if not querie_with_urls_and_diffs:
+            return []
+
+        # 使用LLM进行分组
+        try:            
+            result = self.group_by_similarity.with_llm(self.llm).with_return_type(FileGroups).run(
+                querie_with_urls=querie_with_urls_and_diffs
+            )
+            return result.groups
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            logger.error(f"Error during grouping: {str(e)}")
+            return []
+
+
+def create_file_groups(actions_dir: str) -> List[Dict]:
+    """
+    创建文件分组的便捷函数
+
+    Args:
+        actions_dir: YAML文件所在目录
+
+    Returns:
+        List[Dict]: 分组结果，每个字典包含name, queries和urls
+    """
+    grouper = AutoFileGroup(actions_dir)
+    return grouper.group_files()

{auto_coder-0.1.205 → auto_coder-0.1.206}/src/autocoder/auto_coder_rag.py

@@ -18,8 +18,10 @@ from rich.console import Console
 from rich.table import Table
 import os
 from loguru import logger
+import asyncio
 
 from autocoder.rag.document_retriever import process_file_local
+import pkg_resources
 from autocoder.rag.token_counter import TokenCounter
 
 if platform.system() == "Windows":
@@ -139,6 +141,13 @@ def initialize_system():
 
 def main(input_args: Optional[List[str]] = None):
 
+    try:
+        tokenizer_path = pkg_resources.resource_filename(
+            "autocoder", "data/tokenizer.json"
+        )
+    except FileNotFoundError:
+        tokenizer_path = None
+
     system_lang, _ = locale.getdefaultlocale()
     lang = "zh" if system_lang and system_lang.startswith("zh") else "en"
     desc = lang_desc[lang]
@@ -146,18 +155,38 @@ def main(input_args: Optional[List[str]] = None):
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
     # Build hybrid index command
-    build_index_parser = subparsers.add_parser("build_hybrid_index", help="Build hybrid index for RAG")
-    build_index_parser.add_argument("--quick", action="store_true", help="Skip system initialization")
+    build_index_parser = subparsers.add_parser(
+        "build_hybrid_index", help="Build hybrid index for RAG"
+    )
+    build_index_parser.add_argument(
+        "--quick", action="store_true", help="Skip system initialization"
+    )
     build_index_parser.add_argument("--file", default="", help=desc["file"])
-    build_index_parser.add_argument("--model", default="deepseek_chat", help=desc["model"])
-    build_index_parser.add_argument("--index_model", default="", help=desc["index_model"])
+    build_index_parser.add_argument(
+        "--model", default="deepseek_chat", help=desc["model"]
+    )
+    build_index_parser.add_argument(
+        "--index_model", default="", help=desc["index_model"]
+    )
     build_index_parser.add_argument("--emb_model", default="", help=desc["emb_model"])
-    build_index_parser.add_argument("--ray_address", default="auto", help=desc["ray_address"])
-    build_index_parser.add_argument("--required_exts", default="", help=desc["doc_build_parse_required_exts"])
-    build_index_parser.add_argument("--source_dir", default=".", help="Source directory path")
-    build_index_parser.add_argument("--tokenizer_path", default="", help="Path to tokenizer file")
-    build_index_parser.add_argument("--doc_dir", default="", help="Document directory path")
-    build_index_parser.add_argument("--enable_hybrid_index", action="store_true", help="Enable hybrid index")
+    build_index_parser.add_argument(
+        "--ray_address", default="auto", help=desc["ray_address"]
+    )
+    build_index_parser.add_argument(
+        "--required_exts", default="", help=desc["doc_build_parse_required_exts"]
+    )
+    build_index_parser.add_argument(
+        "--source_dir", default=".", help="Source directory path"
+    )
+    build_index_parser.add_argument(
+        "--tokenizer_path", default=tokenizer_path, help="Path to tokenizer file"
+    )
+    build_index_parser.add_argument(
+        "--doc_dir", default="", help="Document directory path"
+    )
+    build_index_parser.add_argument(
+        "--enable_hybrid_index", action="store_true", help="Enable hybrid index"
+    )
 
     # Serve command
     serve_parser = subparsers.add_parser("serve", help="Start the RAG server")
@@ -220,7 +249,7 @@ def main(input_args: Optional[List[str]] = None):
     serve_parser.add_argument("--ssl_certfile", default="", help="")
     serve_parser.add_argument("--response_role", default="assistant", help="")
     serve_parser.add_argument("--doc_dir", default="", help="")
-    serve_parser.add_argument("--tokenizer_path", default="", help="")
+    serve_parser.add_argument("--tokenizer_path", default=tokenizer_path, help="")
     serve_parser.add_argument(
         "--collections", default="", help="Collection name for indexing"
     )
@@ -282,7 +311,7 @@ def main(input_args: Optional[List[str]] = None):
 
     serve_parser.add_argument(
         "--without_contexts",
-        action="store_true", 
+        action="store_true",
         help="Whether to return responses without contexts. only works when pro plugin is installed",
     )
 
@@ -304,14 +333,70 @@ def main(input_args: Optional[List[str]] = None):
         help="The model used for question answering",
     )
 
+    # Benchmark command
+    benchmark_parser = subparsers.add_parser(
+        "benchmark", help="Benchmark LLM client performance"
+    )
+    benchmark_parser.add_argument(
+        "--model", default="deepseek_chat", help="Model to benchmark"
+    )
+    benchmark_parser.add_argument(
+        "--parallel", type=int, default=10, help="Number of parallel requests"
+    )
+    benchmark_parser.add_argument(
+        "--rounds", type=int, default=1, help="Number of rounds to run"
+    )
+    benchmark_parser.add_argument(
+        "--type",
+        choices=["openai", "byzerllm"],
+        default="byzerllm",
+        help="Client type to benchmark",
+    )
+    benchmark_parser.add_argument(
+        "--api_key", default="", help="OpenAI API key for OpenAI client"
+    )
+    benchmark_parser.add_argument(
+        "--base_url", default="", help="Base URL for OpenAI client"
+    )
+
     # Tools command
     tools_parser = subparsers.add_parser("tools", help="Various tools")
     tools_subparsers = tools_parser.add_subparsers(dest="tool", help="Available tools")
 
     # Count tool
     count_parser = tools_subparsers.add_parser("count", help="Count tokens in a file")
+
+    # Recall validation tool
+    recall_parser = tools_subparsers.add_parser(
+        "recall", help="Validate recall model performance"
+    )
+    recall_parser.add_argument(
+        "--model", required=True, help="Model to use for recall validation"
+    )
+    recall_parser.add_argument(
+        "--content", default=None, help="Content to validate against"
+    )
+    recall_parser.add_argument(
+        "--query", default=None, help="Query to use for validation"
+    )
+
+    # Add chunk model validation tool
+    chunk_parser = tools_subparsers.add_parser(
+        "chunk", help="Validate chunk model performance"
+    )
+    chunk_parser.add_argument(
+        "--model", required=True, help="Model to use for chunk validation"
+    )
+    chunk_parser.add_argument(
+        "--content", default=None, help="Content to validate against"
+    )
+    chunk_parser.add_argument(
+        "--query", default=None, help="Query to use for validation"
+    )
     count_parser.add_argument(
-        "--tokenizer_path", required=True, help="Path to the tokenizer"
+        "--tokenizer_path",
+        default=tokenizer_path,        
+        help="Path to the tokenizer",
     )
     count_parser.add_argument(
         "--file", required=True, help="Path to the file to count tokens"
@@ -319,7 +404,22 @@ def main(input_args: Optional[List[str]] = None):
 
     args = parser.parse_args(input_args)
 
-    if args.command == "serve":
+    if args.command == "benchmark":
+        from .benchmark import benchmark_openai, benchmark_byzerllm
+
+        if args.type == "openai":
+            if not args.api_key:
+                print("OpenAI API key is required for OpenAI client benchmark")
+                return
+            asyncio.run(
+                benchmark_openai(
+                    args.model, args.parallel, args.api_key, args.base_url, args.rounds
+                )
+            )
+        else:  # byzerllm
+            benchmark_byzerllm(args.model, args.parallel, args.rounds)
+
+    elif args.command == "serve":
         if not args.quick:
             initialize_system()
         server_args = ServerArgs(
@@ -337,14 +437,17 @@ def main(input_args: Optional[List[str]] = None):
             }
         )
 
-        if auto_coder_args.enable_hybrid_index:     
-            # 尝试连接storage                
+        if auto_coder_args.enable_hybrid_index:
+            # 尝试连接storage
             try:
                 from byzerllm.apps.byzer_storage.simple_api import ByzerStorage
+
                 storage = ByzerStorage("byzerai_store", "rag", "files")
                 storage.retrieval.cluster_info("byzerai_store")
             except Exception as e:
-                logger.error("When enable_hybrid_index is true, ByzerStorage must be started")
+                logger.error(
+                    "When enable_hybrid_index is true, ByzerStorage must be started"
+                )
                 logger.error("Please run 'byzerllm storage start' first")
                 return
         else:
@@ -369,12 +472,14 @@ def main(input_args: Optional[List[str]] = None):
             llm.setup_sub_client("qa_model", qa_model)
 
         # 当启用hybrid_index时,检查必要的组件
-        if auto_coder_args.enable_hybrid_index:                           
+        if auto_coder_args.enable_hybrid_index:
             if not llm.is_model_exist("emb"):
-                logger.error("When enable_hybrid_index is true, an 'emb' model must be deployed")
+                logger.error(
+                    "When enable_hybrid_index is true, an 'emb' model must be deployed"
+                )
                 return
             llm.setup_default_emb_model_name("emb")
-                
+
         if server_args.doc_dir:
             auto_coder_args.rag_type = "simple"
             rag = RAGFactory.get_rag(
@@ -391,7 +496,7 @@ def main(input_args: Optional[List[str]] = None):
     elif args.command == "build_hybrid_index":
         if not args.quick:
             initialize_system()
-            
+
         auto_coder_args = AutoCoderArgs(
             **{
                 arg: getattr(args, arg)
@@ -402,25 +507,30 @@ def main(input_args: Optional[List[str]] = None):
 
         auto_coder_args.enable_hybrid_index = True
         auto_coder_args.rag_type = "simple"
-                        
+
         try:
             from byzerllm.apps.byzer_storage.simple_api import ByzerStorage
+
             storage = ByzerStorage("byzerai_store", "rag", "files")
             storage.retrieval.cluster_info("byzerai_store")
         except Exception as e:
-            logger.error("When enable_hybrid_index is true, ByzerStorage must be started")
+            logger.error(
+                "When enable_hybrid_index is true, ByzerStorage must be started"
+            )
             logger.error("Please run 'byzerllm storage start' first")
             return
-        
+
         llm = byzerllm.ByzerLLM()
         llm.setup_default_model_name(args.model)
 
         # 当启用hybrid_index时,检查必要的组件
-        if auto_coder_args.enable_hybrid_index:                           
+        if auto_coder_args.enable_hybrid_index:
             if not llm.is_model_exist("emb"):
-                logger.error("When enable_hybrid_index is true, an 'emb' model must be deployed")
+                logger.error(
+                    "When enable_hybrid_index is true, an 'emb' model must be deployed"
+                )
                 return
-            llm.setup_default_emb_model_name("emb")        
+            llm.setup_default_emb_model_name("emb")
 
         rag = RAGFactory.get_rag(
             llm=llm,
@@ -428,19 +538,41 @@ def main(input_args: Optional[List[str]] = None):
             path=args.doc_dir,
             tokenizer_path=args.tokenizer_path,
         )
-        
+
         if hasattr(rag.document_retriever, "cacher"):
             rag.document_retriever.cacher.build_cache()
         else:
-            logger.error("The document retriever does not support hybrid index building")
+            logger.error(
+                "The document retriever does not support hybrid index building"
+            )
+
+    elif args.command == "tools":
+        if args.tool == "count":
+            # auto-coder.rag tools count --tokenizer_path /Users/allwefantasy/Downloads/tokenizer.json --file /Users/allwefantasy/data/yum/schema/schema.xlsx
+            count_tokens(args.tokenizer_path, args.file)
+        elif args.tool == "recall":
+            from .common.recall_validation import validate_recall
+
+            llm = byzerllm.ByzerLLM.from_default_model(args.model)
+
+            content = None if not args.content else [args.content]
+            result = validate_recall(llm, content=content, query=args.query)
+            print(f"Recall Validation Result:\n{result}")
+        elif args.tool == "chunk":
+            from .common.chunk_validation import validate_chunk
 
-    elif args.command == "tools" and args.tool == "count":
-        # auto-coder.rag tools count --tokenizer_path /Users/allwefantasy/Downloads/tokenizer.json --file /Users/allwefantasy/data/yum/schema/schema.xlsx
-        count_tokens(args.tokenizer_path, args.file)
+            llm = byzerllm.ByzerLLM.from_default_model(args.model)
+            content = None if not args.content else [args.content]
+            result = validate_chunk(llm, content=content, query=args.query)
+            print(f"Chunk Model Validation Result:\n{result}")
 
 
 def count_tokens(tokenizer_path: str, file_path: str):
-    token_counter = TokenCounter(tokenizer_path)
+    from autocoder.rag.variable_holder import VariableHolder
+    from tokenizers import Tokenizer
+    VariableHolder.TOKENIZER_PATH = tokenizer_path
+    VariableHolder.TOKENIZER_MODEL = Tokenizer.from_file(tokenizer_path)
+    token_counter = TokenCounter(tokenizer_path)    
     source_codes = process_file_local(file_path)
 
     console = Console()