auto-coder 0.1.347__py3-none-any.whl → 0.1.349__py3-none-any.whl

autocoder/ignorefiles/__init__.py

@@ -0,0 +1,4 @@
+
+from .ignore_file_utils import should_ignore
+
+__all__ = ["should_ignore"]

autocoder/ignorefiles/ignore_file_utils.py

@@ -0,0 +1,63 @@
+
+import os
+from pathlib import Path
+from threading import Lock
+import pathspec
+
+DEFAULT_EXCLUDES = [
+    '.git', '.auto-coder', 'node_modules', '.mvn', '.idea',
+    '__pycache__', '.venv', 'venv', 'dist', 'build', '.gradle',".next"
+]
+
+
+class IgnoreFileManager:
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(IgnoreFileManager, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._spec = None
+        self._load_ignore_spec()
+
+    def _load_ignore_spec(self):
+        ignore_patterns = []
+        project_root = Path(os.getcwd())
+
+        ignore_file_paths = [
+            project_root / '.autocoderignore',
+            project_root / '.auto-coder' / '.autocoderignore'
+        ]
+
+        for ignore_file in ignore_file_paths:
+            if ignore_file.is_file():
+                with open(ignore_file, 'r', encoding='utf-8') as f:
+                    ignore_patterns = f.read().splitlines()
+                break
+
+        # 添加默认排除目录
+        ignore_patterns.extend(DEFAULT_EXCLUDES)
+
+        self._spec = pathspec.PathSpec.from_lines('gitwildmatch', ignore_patterns)
+
+    def should_ignore(self, path: str) -> bool:
+        rel_path = os.path.relpath(path, os.getcwd())
+        # 标准化分隔符
+        rel_path = rel_path.replace(os.sep, '/')
+        return self._spec.match_file(rel_path)
+
+
+# 对外提供单例
+_ignore_manager = IgnoreFileManager()
+
+def should_ignore(path: str) -> bool:
+    return _ignore_manager.should_ignore(path)

autocoder/ignorefiles/test_ignore_file_utils.py

@@ -0,0 +1,91 @@
+
+import os
+import shutil
+from pathlib import Path
+
+import pytest
+
+from src.autocoder.ignorefiles import ignore_file_utils
+
+@pytest.fixture(autouse=True)
+def cleanup_ignore_manager(monkeypatch):
+    """
+    在每个测试前后清理 IgnoreFileManager 的单例状态，保证测试隔离
+    """
+    # 备份原始实例
+    original_instance = ignore_file_utils._ignore_manager
+    # 强制重新加载忽略规则
+    def reset_ignore_manager():
+        ignore_file_utils.IgnoreFileManager._instance = None
+        return ignore_file_utils.IgnoreFileManager()
+
+    monkeypatch.setattr(ignore_file_utils, "_ignore_manager", reset_ignore_manager())
+    yield
+    # 恢复原始实例
+    ignore_file_utils._ignore_manager = original_instance
+
+
+def test_default_excludes(tmp_path, monkeypatch):
+    # 切换当前工作目录
+    monkeypatch.chdir(tmp_path)
+
+    # 不创建任何 .autocoderignore 文件，使用默认排除规则
+    # 创建默认排除目录
+    for dirname in ignore_file_utils.DEFAULT_EXCLUDES:
+        (tmp_path / dirname).mkdir(parents=True, exist_ok=True)
+        # 应该被忽略
+        assert ignore_file_utils.should_ignore(str(tmp_path / dirname)) is True
+
+    # 创建不会被忽略的文件
+    normal_file = tmp_path / "myfile.txt"
+    normal_file.write_text("hello")
+    assert ignore_file_utils.should_ignore(str(normal_file)) is False
+
+
+def test_custom_ignore_file(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    # 创建自定义忽略文件
+    ignore_file = tmp_path / ".autocoderignore"
+    ignore_file.write_text("data/**\nsecret.txt")
+
+    # 重新初始化忽略管理器以加载新规则
+    ignore_file_utils.IgnoreFileManager._instance = None
+    ignore_file_utils._ignore_manager = ignore_file_utils.IgnoreFileManager()
+
+    # 符合忽略规则的路径
+    ignored_dir = tmp_path / "data" / "subdir"
+    ignored_dir.mkdir(parents=True)
+    ignored_file = tmp_path / "secret.txt"
+    ignored_file.write_text("secret")
+
+    assert ignore_file_utils.should_ignore(str(ignored_dir)) is True
+    assert ignore_file_utils.should_ignore(str(ignored_file)) is True
+
+    # 不应被忽略的文件
+    normal_file = tmp_path / "keepme.txt"
+    normal_file.write_text("keep me")
+    assert ignore_file_utils.should_ignore(str(normal_file)) is False
+
+
+def test_nested_ignore_file(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    # 没有根目录的.ignore，创建.auto-coder/.autocoderignore
+    nested_dir = tmp_path / ".auto-coder"
+    nested_dir.mkdir()
+
+    ignore_file = nested_dir / ".autocoderignore"
+    ignore_file.write_text("logs/**")
+
+    # 重新初始化忽略管理器以加载新规则
+    ignore_file_utils.IgnoreFileManager._instance = None
+    ignore_file_utils._ignore_manager = ignore_file_utils.IgnoreFileManager()
+
+    ignored_dir = tmp_path / "logs" / "2024"
+    ignored_dir.mkdir(parents=True)
+    assert ignore_file_utils.should_ignore(str(ignored_dir)) is True
+
+    normal_file = tmp_path / "main.py"
+    normal_file.write_text("# main")
+    assert ignore_file_utils.should_ignore(str(normal_file)) is False

autocoder/models.py

@@ -8,7 +8,7 @@ MODELS_JSON = os.path.expanduser("~/.auto-coder/keys/models.json")
 # Default built-in models
 default_models_list = [
     {
-        "name": "deepseek_r1_chat",
+        "name": "deepseek/r1",
         "description": "DeepSeek Reasoner is for design/review",
         "model_name": "deepseek-reasoner",
         "model_type": "saas/openai",
@@ -21,7 +21,7 @@ default_models_list = [
         "max_output_tokens": 8096
     },    
     {
-        "name": "deepseek_chat",
+        "name": "deepseek/v3",
         "description": "DeepSeek Chat is for coding",
         "model_name": "deepseek-chat",
         "model_type": "saas/openai",
@@ -34,16 +34,56 @@ default_models_list = [
         "max_output_tokens": 8096
     },
     {
-        "name":"o1",
-        "description": "o1 is for design/review",
-        "model_name": "o1-2024-12-17",
+        "name": "ark/deepseek-v3-250324",
+        "description": "DeepSeek Chat is for coding",
+        "model_name": "deepseek-v3-250324",
         "model_type": "saas/openai",
-        "base_url": "https://api.openai.com/v1",
+        "base_url": "https://ark.cn-beijing.volces.com/api/v3",
         "api_key_path": "",
-        "is_reasoning": True,
+        "is_reasoning": False,
+        "input_price": 2.0,
+        "output_price": 8.0,
+        "average_speed": 0.0,
+        "max_output_tokens": 8096
+    },    
+    {
+        "name": "ark/deepseek-v3-250324",
+        "description": "DeepSeek Chat is for coding",
+        "model_name": "deepseek-v3-250324",
+        "model_type": "saas/openai",
+        "base_url": "https://ark.cn-beijing.volces.com/api/v3",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 2.0,
+        "output_price": 8.0,
+        "average_speed": 0.0,
+        "max_output_tokens": 8096
+    },    
+    {
+        "name": "openrouter/quasar-alpha",
+        "description": "",
+        "model_name": "openrouter/quasar-alpha",
+        "model_type": "saas/openai",
+        "base_url": "https://openrouter.ai/api/v1",
+        "api_key_path": "",
+        "is_reasoning": False,
         "input_price": 0.0,
         "output_price": 0.0,
-        "average_speed": 0.0
+        "average_speed": 0.0,
+        "max_output_tokens": 8096*2
+    },    
+    {
+        "name": "openrouter/google/gemini-2.5-pro-preview-03-25",
+        "description": "",
+        "model_name": "google/gemini-2.5-pro-preview-03-25",
+        "model_type": "saas/openai",
+        "base_url": "https://openrouter.ai/api/v1",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 0.0,
+        "output_price": 0.0,
+        "average_speed": 0.0,
+        "max_output_tokens": 8096*2
     }
 ]
 
@@ -263,7 +303,7 @@ def update_model_with_api_key(name: str, api_key: str) -> Dict:
     if not found_model:
         return None
             
-    api_key_path = name
+    api_key_path = name.replace("/", "_")  # 替换 / 为 _，保证文件名合法
     if api_key_path:
         found_model["api_key_path"] = api_key_path
         

autocoder/plugins/__init__.py

@@ -256,6 +256,7 @@ class PluginManager:
             "/plugins/dirs /remove",
             "/plugins/dirs /clear",
         ]
+        self._wrapped_functions: Dict[str, Callable] = {}
 
     @property
     def cached_discover_plugins(self) -> List[Type[Plugin]]:
@@ -561,6 +562,7 @@ class PluginManager:
                 return result
             return None
 
+        self._wrapped_functions[func_name] = wrapped
         return wrapped
 
     def register_function_interception(self, plugin_name: str, func_name: str) -> None:
@@ -1107,6 +1109,24 @@ class PluginManager:
 
         return processed_completions
 
+    def get_wrapped_functions(self) -> Dict[str, Callable]:
+        """获取所有已包装的函数。
+
+        Returns:
+            Dict[str, Callable]: 包含所有已包装函数的字典，键为函数名，值为包装后的函数
+        """
+        return self._wrapped_functions
+
+    def get_wrapped_function(self, func_name: str) -> Callable:
+        """获取已包装的函数。
+
+        Args:
+            func_name: 函数名
+
+        Returns:
+            已包装的函数，如果未找到则返回 None
+        """
+        return self._wrapped_functions.get(func_name)
 
 def register_global_plugin_dir(plugin_dir: str) -> None:
     """注册一个全局插件目录。

autocoder/rag/cache/byzer_storage_cache.py

@@ -1,3 +1,4 @@
+from token import OP
 from autocoder.rag.cache.base_cache import (
     BaseCacheManager,
     DeleteEvent,
@@ -31,6 +32,8 @@ from pydantic import BaseModel
 from autocoder.rag.cache.cache_result_merge import CacheResultMerger, MergeStrategy
 from .failed_files_utils import save_failed_files, load_failed_files
 import time
+from byzerllm import ByzerLLM, SimpleByzerLLM
+from autocoder.utils.llms import get_llm_names
 
 if platform.system() != "Windows":
     import fcntl
@@ -66,8 +69,8 @@ class ByzerStorageCache(BaseCacheManager):
         ignore_spec,
         required_exts,
         extra_params: Optional[AutoCoderArgs] = None,
-        args=None,
-        llm=None,
+        args:Optional[AutoCoderArgs]=None,
+        llm:Optional[Union[ByzerLLM,SimpleByzerLLM,str]]=None,
     ):
         """
         初始化基于云端 Byzer Storage 的 RAG 缓存管理器。
@@ -78,6 +81,7 @@ class ByzerStorageCache(BaseCacheManager):
         self.extra_params = extra_params
         self.args = args
         self.llm = llm
+        self.product_mode = self.args.product_mode
         self.rag_build_name = extra_params.rag_build_name
         self.storage = ByzerStorage("byzerai_store", "rag", self.rag_build_name)
         self.queue = []
@@ -218,6 +222,8 @@ class ByzerStorageCache(BaseCacheManager):
         from autocoder.rag.token_counter import initialize_tokenizer
 
         logger.info("[BUILD CACHE] Starting parallel file processing...")
+        llm_name = get_llm_names(self.llm)[0] if self.llm else None
+        product_mode = self.product_mode
         start_time = time.time()
         with Pool(
             processes=os.cpu_count(),
@@ -227,7 +233,7 @@ class ByzerStorageCache(BaseCacheManager):
             target_files_to_process = []
             for file_info in files_to_process:
                 target_files_to_process.append(self.fileinfo_to_tuple(file_info))
-            results = pool.map(process_file_in_multi_process, target_files_to_process)
+            results = pool.map(process_file_in_multi_process, target_files_to_process, llm=llm_name, product_mode=product_mode)
         processing_time = time.time() - start_time
         logger.info(f"[BUILD CACHE] File processing completed, time elapsed: {processing_time:.2f}s")
 
@@ -417,7 +423,7 @@ class ByzerStorageCache(BaseCacheManager):
                 for file_info in file_list.file_infos:
                     logger.info(f"[QUEUE PROCESSING] Processing file update: {file_info.file_path}")
                     try:
-                        content = process_file_local(self.fileinfo_to_tuple(file_info))
+                        content = process_file_local(self.fileinfo_to_tuple(file_info), llm=self.llm, product_mode=self.product_mode)
                         if content:
                             self.cache[file_info.file_path] = CacheItem(
                                 file_path=file_info.file_path,

autocoder/rag/cache/file_monitor_cache.py

@@ -1,22 +1,24 @@
 from autocoder.rag.cache.base_cache import BaseCacheManager
-from typing import Dict, List,Any,Optional
+from typing import Dict, List, Any, Optional, Union
 import os
 import threading
 from loguru import logger
 from watchfiles import watch, Change
 from autocoder.rag.variable_holder import VariableHolder
 from autocoder.common import SourceCode
-from autocoder.rag.utils import process_file_in_multi_process,process_file_local
+from autocoder.rag.utils import process_file_in_multi_process, process_file_local
 from watchfiles import Change, DefaultFilter, awatch, watch
+from byzerllm import SimpleByzerLLM, ByzerLLM
+from autocoder.common import AutoCoderArgs
 
 
 class AutoCoderRAGDocListener(BaseCacheManager):
     """
     基于文件系统实时监控的代码缓存管理器。
-    
+
     此类实现了对代码库的实时监控，当文件发生变化时（新增、修改、删除）自动更新缓存。
     与其他缓存管理器不同，它使用 watchfiles 库进行文件变更监控，无需定期扫描文件系统。
-    
+
     类属性:
         cache: 缓存字典，存储处理后的文件内容
         ignore_dirs: 需要忽略的目录列表
@@ -48,15 +50,15 @@ class AutoCoderRAGDocListener(BaseCacheManager):
         r"^test.*$",
     ]
 
-    def __init__(self, path: str, ignore_spec, required_exts: List, args=None, llm=None) -> None:
+    def __init__(self, path: str, ignore_spec, required_exts: List, args: Optional[AutoCoderArgs] = None, llm: Optional[Union[ByzerLLM, SimpleByzerLLM, str]] = None) -> None:
         """
         初始化文件监控缓存管理器。
-        
+
         参数:
             path: 需要监控的代码库根目录
             ignore_spec: 指定哪些文件/目录应被忽略的规则
             required_exts: 需要处理的文件扩展名列表
-            
+
         缓存结构 (self.cache):
             self.cache 是一个字典，其结构比其他缓存管理器更简单:
             {
@@ -67,19 +69,19 @@ class AutoCoderRAGDocListener(BaseCacheManager):
                 "file_path2": { ... },
                 ...
             }
-            
+
             与其他缓存管理器的主要区别:
             1. 不需要存储 MD5 哈希或修改时间，因为文件变更通过监控系统直接获取
             2. 没有本地持久化机制，所有缓存在内存中维护
             3. 缓存更新基于事件驱动，而非定期扫描
-            
+
         文件监控机制:
             - 使用 watchfiles 库监控文件系统变更
             - 支持三种事件类型: 添加(added)、修改(modified)、删除(deleted)
             - 使用单独线程进行监控，不阻塞主线程
             - 监控遵循配置的忽略规则和所需扩展名过滤
             - 初始化时会先加载所有符合条件的文件
-            
+
         源代码处理:
             使用 process_file_local 函数处理单个文件:
             - 参数: file_path (文件路径)
@@ -111,7 +113,7 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def stop(self):
         """
         停止文件监控线程。
-        
+
         设置停止事件并等待监控线程结束，用于在对象销毁前优雅地关闭监控。
         """
         self.stop_event.set()
@@ -126,7 +128,7 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def load_first(self):
         """
         初始化时加载所有符合条件的文件。
-        
+
         获取所有符合过滤条件的文件，并将它们添加到缓存中。
         这确保了缓存在开始监控前已经包含所有现有文件。
         """
@@ -139,16 +141,17 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def update_cache(self, file_path):
         """
         处理单个文件并更新缓存。
-        
+
         参数:
             file_path: 文件的绝对路径
-            
+
         处理流程:
             1. 使用 process_file_local 函数解析文件内容
             2. 将解析结果序列化并存储在缓存中
             3. 日志记录更新的文件及当前缓存状态
         """
-        source_code = process_file_local(file_path)
+        source_code = process_file_local(
+            file_path, llm=self.llm, product_mode=self.product_mode)
         self.cache[file_path] = {
             "file_path": file_path,
             "content": [c.model_dump() for c in source_code],
@@ -159,7 +162,7 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def remove_cache(self, file_path):
         """
         从缓存中移除指定文件。
-        
+
         参数:
             file_path: 要移除的文件的绝对路径
         """
@@ -170,7 +173,7 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def open_watch(self):
         """
         启动文件系统监控线程。
-        
+
         此方法会持续监控文件系统变更，直到 stop_event 被设置。
         当检测到文件变更时，会根据变更类型执行相应的操作:
         - 添加/修改文件: 调用 update_cache 更新缓存
@@ -190,10 +193,10 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def get_cache(self, options: Optional[Dict[str, Any]] = None):
         """
         获取当前缓存。
-        
+
         参数:
             options: 可选的参数，指定获取缓存时的选项
-            
+
         返回:
             当前内存中的缓存字典
         """
@@ -202,9 +205,9 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def _load_ignore_file(self):
         """
         加载忽略文件规则。
-        
+
         首先尝试加载 .serveignore 文件，如果不存在，则尝试加载 .gitignore 文件。
-        
+
         返回:
             包含忽略规则的字符串列表
         """
@@ -224,10 +227,10 @@ class AutoCoderRAGDocListener(BaseCacheManager):
     def get_all_files(self) -> List[str]:
         """
         获取所有符合条件的文件路径。
-        
+
         遍历指定目录，应用忽略规则和扩展名过滤，
         返回所有符合条件的文件的绝对路径。
-        
+
         返回:
             符合条件的文件路径列表
         """
@@ -258,4 +261,4 @@ class AutoCoderRAGDocListener(BaseCacheManager):
                 absolute_path = os.path.abspath(file_path)
                 all_files.append(absolute_path)
 
-        return all_files
+        return all_files

autocoder/rag/cache/local_byzer_storage_cache.py

@@ -8,6 +8,7 @@ from autocoder.rag.cache.base_cache import (
 from typing import Generator, List, Dict, Any, Optional, Tuple
 from autocoder.common import SourceCode
 from loguru import logger
+import functools
 import pathspec
 import os
 import uuid
@@ -30,7 +31,9 @@ from typing import Union
 from byzerllm import SimpleByzerLLM, ByzerLLM
 from autocoder.rag.cache.cache_result_merge import CacheResultMerger, MergeStrategy
 import time
+from typing import Optional,Union
 from .failed_files_utils import save_failed_files, load_failed_files
+from autocoder.utils.llms import get_llm_names
 
 if platform.system() != "Windows":
     import fcntl
@@ -71,8 +74,8 @@ class LocalByzerStorageCache(BaseCacheManager):
         emb_llm: Union[ByzerLLM, SimpleByzerLLM] = None,
         host: str = "127.0.0.1",
         port: int = 33333,
-        args=None,
-        llm=None,
+        args:Optional[AutoCoderArgs]=None,
+        llm:Optional[Union[ByzerLLM,SimpleByzerLLM,str]]=None,
     ):
         """
         初始化基于 Byzer Storage 的 RAG 缓存管理器。
@@ -225,6 +228,8 @@ class LocalByzerStorageCache(BaseCacheManager):
         from autocoder.rag.token_counter import initialize_tokenizer
 
         logger.info("[BUILD CACHE] Starting parallel file processing...")
+        llm_name = get_llm_names(self.llm)[0] if self.llm else None
+        product_mode = self.args.product_mode
         start_time = time.time()
         with Pool(
             processes=os.cpu_count(),
@@ -235,8 +240,9 @@ class LocalByzerStorageCache(BaseCacheManager):
             for file_info in files_to_process:
                 target_files_to_process.append(
                     self.fileinfo_to_tuple(file_info))
-            results = pool.map(process_file_in_multi_process,
-                               target_files_to_process)
+            worker_func = functools.partial(process_file_in_multi_process, llm=llm_name, product_mode=product_mode)
+            results = pool.map(worker_func, target_files_to_process)
+        
         processing_time = time.time() - start_time
         logger.info(f"[BUILD CACHE] File processing completed, time elapsed: {processing_time:.2f}s")
 
@@ -452,7 +458,7 @@ class LocalByzerStorageCache(BaseCacheManager):
                         f"[QUEUE PROCESSING] Processing file update: {file_info.file_path}")
                     try:
                         content = process_file_local(
-                            self.fileinfo_to_tuple(file_info))
+                            self.fileinfo_to_tuple(file_info), llm=self.llm, product_mode=self.product_mode)
                         if content:
                             self.cache[file_info.file_path] = CacheItem(
                                 file_path=file_info.file_path,