auto-coder 0.1.353__py3-none-any.whl → 0.1.355__py3-none-any.whl

autocoder/common/file_monitor/monitor.py

@@ -0,0 +1,383 @@
+# -*- coding: utf-8 -*-
+import os
+import threading
+import time
+import fnmatch
+from collections import defaultdict
+from pathlib import Path
+from typing import Callable, Dict, List, Set, Tuple, Union, Optional, Any
+from loguru import logger
+
+# 尝试导入 watchfiles，如果失败则提示用户安装
+try:
+    from watchfiles import watch, Change
+except ImportError:
+    logger.error("错误：需要安装 'watchfiles' 库。请运行: pip install watchfiles")
+    # 可以选择抛出异常或退出，这里仅打印信息
+    # raise ImportError("watchfiles is required for FileMonitor")
+    # 或者提供一个空的实现或禁用该功能
+    Change = None # type: ignore
+    watch = None # type: ignore
+
+# 尝试导入 pathspec，如果失败则提示用户安装
+try:
+    import pathspec
+except ImportError:
+    logger.error("错误：需要安装 'pathspec' 库。请运行: pip install pathspec")
+    pathspec = None  # type: ignore
+
+# 用于区分普通路径和模式路径
+class PathType:
+    LITERAL = 'literal'  # 普通的精确路径
+    PATTERN = 'pattern'  # 模式路径（glob, gitignore等）
+
+# 注册的路径信息结构
+class RegisteredPath:
+    def __init__(self, path: str, path_type: str, spec=None):
+        self.path = path
+        self.path_type = path_type
+        self.spec = spec  # pathspec规范对象，用于高效匹配
+        
+    def __eq__(self, other):
+        if not isinstance(other, RegisteredPath):
+            return False
+        return self.path == other.path and self.path_type == other.path_type
+    
+    def __hash__(self):
+        return hash((self.path, self.path_type))
+
+
+class FileMonitor:
+    """
+    使用 watchfiles 库监控指定根目录下文件或目录的变化。
+
+    允许动态注册特定路径的回调函数，当这些路径发生变化时触发。
+    支持多种路径模式，包括glob模式，如 "**/*.py" 匹配任何Python文件。
+    使用pathspec库实现高效的路径匹配。
+    
+    此类实现了单例模式，确保全局只有一个监控实例。
+    """
+    
+    # 单例实例
+    _instance = None
+    _instance_lock = threading.Lock()
+
+    def __new__(cls, root_dir: Optional[str] = None):
+        """
+        实现单例模式。确保只创建一个 FileMonitor 实例。
+        
+        :param root_dir: 需要监控的根目录。如果已存在实例且提供了新的根目录，不会更改现有实例的根目录。
+        :return: FileMonitor 的单例实例
+        """
+        with cls._instance_lock:
+            if cls._instance is None:
+                if root_dir is None:
+                    raise ValueError("First initialization of FileMonitor requires a valid root_dir")
+                cls._instance = super(FileMonitor, cls).__new__(cls)
+                cls._instance._initialized = False  # 标记是否已初始化
+            elif root_dir is not None and cls._instance.root_dir != os.path.abspath(root_dir):
+                logger.warning(f"FileMonitor is already initialized with root directory '{cls._instance.root_dir}'.")
+                logger.warning(f"New root directory '{root_dir}' will be ignored.")
+        return cls._instance
+
+    def __init__(self, root_dir: str):
+        """
+        初始化 FileMonitor。由于是单例，只有首次创建实例时才会执行初始化。
+
+        :param root_dir: 需要监控的根目录。watchfiles 将监控此目录及其所有子目录。
+        """
+        # 如果已经初始化过，则跳过
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+            
+        if watch is None:
+             raise ImportError("watchfiles is not installed or could not be imported.")
+             
+        if pathspec is None:
+             raise ImportError("pathspec is not installed or could not be imported.")
+
+        self.root_dir = os.path.abspath(root_dir)
+        if not os.path.isdir(self.root_dir):
+            raise ValueError(f"Root directory '{self.root_dir}' does not exist or is not a directory.")
+
+        # 存储回调: {registered_path: [callback1, callback2, ...]}
+        # 回调函数签名: callback(change_type: Change, changed_path: str)
+        self._callbacks: Dict[RegisteredPath, List[Callable[[Change, str], None]]] = defaultdict(list)
+        self._callback_lock = threading.Lock() # 保护 _callbacks 的访问
+
+        self._stop_event = threading.Event() # 用于通知监控循环停止
+        self._monitor_thread: Optional[threading.Thread] = None
+        self._watch_stop_event = threading.Event() # watchfiles 停止事件
+
+        self._initialized = True
+        logger.info(f"FileMonitor singleton initialized for root directory: {self.root_dir}")
+
+    @classmethod
+    def get_instance(cls) -> Optional['FileMonitor']:
+        """
+        获取 FileMonitor 的单例实例。
+        
+        :return: FileMonitor 实例，如果尚未初始化则返回 None
+        """
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls):
+        """
+        重置单例实例。
+        如果当前实例正在运行，则先停止它。
+        """
+        with cls._instance_lock:
+            if cls._instance is not None:
+                if cls._instance.is_running():
+                    cls._instance.stop()
+                cls._instance = None
+                logger.info("FileMonitor singleton has been reset.")
+
+    def _is_pattern(self, path: str) -> bool:
+        """
+        判断一个路径是否为模式（包含通配符）。
+        
+        :param path: 要检查的路径
+        :return: 如果路径包含通配符，则返回True
+        """
+        # 检查是否包含通配符字符
+        return any(c in path for c in ['*', '?', '[', ']'])
+
+    def _create_pathspec(self, pattern: str) -> Any:
+        """
+        创建一个pathspec匹配器。
+        
+        :param pattern: 匹配模式
+        :return: pathspec匹配器对象
+        """
+        # 将单个模式转换为pathspec格式
+        # 使用GitWildMatchPattern，它支持.gitignore样式的通配符，功能最全面
+        return pathspec.PathSpec.from_patterns([pattern], pathspec.patterns.GitWildMatchPattern)
+
+    def register(self, path: Union[str, Path], callback: Callable[[Change, str], None]):
+        """
+        注册一个文件或目录路径以及对应的回调函数。
+        
+        支持多种模式路径，如 "**/*.py" 匹配任何Python文件。
+        如果注册的是目录，则该目录本身或其内部任何文件的变化都会触发回调。
+        路径必须位于初始化时指定的 root_dir 内部。
+
+        :param path: 要监控的文件或目录的路径（绝对或相对于当前工作目录）。
+                     支持多种模式，如 "src/**/*.py"。
+        :param callback: 当路径发生变化时调用的回调函数。
+                         接收两个参数：变化类型 (watchfiles.Change) 和变化的文件/目录路径 (str)。
+        """
+        path_str = str(path)
+        
+        # 检查是否是模式路径
+        is_pattern = self._is_pattern(path_str)
+        
+        # 对于非模式路径，路径必须是绝对路径或相对于当前工作目录的路径
+        if not is_pattern:
+            abs_path = os.path.abspath(path_str)
+            
+            # 检查路径是否在 root_dir 内部
+            if not abs_path.startswith(self.root_dir):
+                logger.warning(f"Path '{abs_path}' is outside the monitored root directory '{self.root_dir}' and cannot be registered.")
+                return
+                
+            reg_path = RegisteredPath(abs_path, PathType.LITERAL)
+            
+            with self._callback_lock:
+                self._callbacks[reg_path].append(callback)
+                logger.info(f"Registered callback for literal path: {abs_path}")
+        else:
+            # 对于模式路径，先处理路径格式
+            if os.path.isabs(path_str):
+                # 如果是绝对路径，检查是否在监控根目录下
+                if not path_str.startswith(self.root_dir):
+                    logger.warning(f"Pattern '{path_str}' is outside the monitored root directory '{self.root_dir}' and cannot be registered.")
+                    return
+                # 转换为相对于root_dir的路径用于pathspec匹配
+                pattern = os.path.relpath(path_str, self.root_dir)
+            else:
+                # 对于相对路径，直接使用
+                pattern = path_str
+                
+            # 创建pathspec匹配器
+            path_spec = self._create_pathspec(pattern)
+            
+            # 注册带有pathspec的模式
+            reg_path = RegisteredPath(pattern, PathType.PATTERN, spec=path_spec)
+            
+            with self._callback_lock:
+                self._callbacks[reg_path].append(callback)
+                logger.info(f"Registered callback for pattern: {pattern}")
+
+    def unregister(self, path: Union[str, Path], callback: Optional[Callable[[Change, str], None]] = None):
+        """
+        取消注册一个文件或目录路径的回调函数。
+
+        :param path: 要取消注册的文件或目录路径，包括模式路径。
+        :param callback: 要取消注册的特定回调函数。如果为 None，则移除该路径的所有回调。
+        """
+        path_str = str(path)
+        is_pattern = self._is_pattern(path_str)
+        
+        # 查找匹配的注册路径
+        target_reg_path = None
+        with self._callback_lock:
+            if not is_pattern:
+                abs_path = os.path.abspath(path_str)
+                for reg_path in self._callbacks.keys():
+                    if reg_path.path_type == PathType.LITERAL and reg_path.path == abs_path:
+                        target_reg_path = reg_path
+                        break
+            else:
+                # 对于模式路径，尝试找到完全匹配的模式
+                if os.path.isabs(path_str):
+                    pattern = os.path.relpath(path_str, self.root_dir)
+                else:
+                    pattern = path_str
+                
+                for reg_path in self._callbacks.keys():
+                    if reg_path.path_type == PathType.PATTERN and reg_path.path == pattern:
+                        target_reg_path = reg_path
+                        break
+            
+            # 如果找到匹配的路径，执行取消注册
+            if target_reg_path:
+                if callback:
+                    try:
+                        self._callbacks[target_reg_path].remove(callback)
+                        logger.info(f"Unregistered specific callback for path: {path_str}")
+                        if not self._callbacks[target_reg_path]: # 如果列表为空，则删除键
+                            del self._callbacks[target_reg_path]
+                    except ValueError:
+                        logger.warning(f"Callback not found for path: {path_str}")
+                else:
+                    del self._callbacks[target_reg_path]
+                    logger.info(f"Unregistered all callbacks for path: {path_str}")
+            else:
+                logger.warning(f"No callbacks registered for path: {path_str}")
+
+    def _path_matches(self, file_path: str, reg_path: RegisteredPath) -> bool:
+        """
+        检查文件路径是否匹配注册的路径。
+        
+        :param file_path: 要检查的文件路径
+        :param reg_path: 注册的路径对象
+        :return: 如果路径匹配，则返回True
+        """
+        if reg_path.path_type == PathType.LITERAL:
+            # 对于精确路径，检查完全匹配或者是否在目录内
+            if file_path == reg_path.path:
+                return True
+            if os.path.isdir(reg_path.path) and file_path.startswith(reg_path.path + os.sep):
+                return True
+            return False
+        
+        elif reg_path.path_type == PathType.PATTERN:
+            # 对于模式路径，使用pathspec进行匹配
+            if reg_path.spec:
+                # 获取相对于根目录的路径进行匹配
+                rel_path = os.path.relpath(file_path, self.root_dir)
+                return reg_path.spec.match_file(rel_path)
+            return False
+        
+        return False
+
+    def _monitor_loop(self):
+        """
+        监控线程的主循环，使用 watchfiles.watch。
+        """
+        logger.info(f"File monitor loop started for {self.root_dir}...")
+        try:
+            # watchfiles.watch 会阻塞直到 stop_event 被设置或发生错误
+            for changes in watch(self.root_dir, stop_event=self._watch_stop_event, yield_on_timeout=True):
+                if self._stop_event.is_set(): # 检查外部停止信号
+                    logger.info("External stop signal received.")
+                    break
+
+                if not changes: # 超时时 changes 可能为空
+                    continue
+
+                # changes 是一个集合: {(Change.added, '/path/to/file'), (Change.modified, '/path/to/another')}
+                triggered_callbacks: List[Tuple[Callable, Change, str]] = []
+
+                with self._callback_lock:
+                    # 检查每个变化是否与注册的路径匹配
+                    for change_type, changed_path in changes:
+                        abs_changed_path = os.path.abspath(changed_path)
+
+                        # 遍历所有注册的路径和回调
+                        for reg_path, callbacks in self._callbacks.items():
+                            # 使用优化后的路径匹配方法
+                            if self._path_matches(abs_changed_path, reg_path):
+                                for cb in callbacks:
+                                    # 避免重复添加同一回调对于同一事件
+                                    if (cb, change_type, abs_changed_path) not in triggered_callbacks:
+                                        triggered_callbacks.append((cb, change_type, abs_changed_path))
+
+                # 在锁外部执行回调，避免阻塞监控循环
+                if triggered_callbacks:
+                    for cb, ct, cp in triggered_callbacks:
+                        try:
+                            cb(ct, cp)
+                        except Exception as e:
+                            logger.error(f"Error executing callback {getattr(cb, '__name__', str(cb))} for change {ct} on {cp}: {e}")
+
+        except Exception as e:
+            logger.error(f"Error in file monitor loop: {e}")
+        finally:
+            logger.info("File monitor loop stopped.")
+
+    def start(self):
+        """
+        启动文件监控后台线程。
+        如果监控已在运行，则不执行任何操作。
+        """
+        if self._monitor_thread is not None and self._monitor_thread.is_alive():
+            logger.info("Monitor is already running.")
+            return
+
+        logger.info("Starting file monitor...")
+        self._stop_event.clear() # 重置外部停止事件
+        self._watch_stop_event.clear() # 重置 watchfiles 停止事件
+        self._monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self._monitor_thread.start()
+        logger.info("File monitor started in background thread.")
+
+    def stop(self):
+        """
+        停止文件监控线程。
+        """
+        if self._monitor_thread is None or not self._monitor_thread.is_alive():
+            logger.info("Monitor is not running.")
+            return
+
+        logger.info("Stopping file monitor...")
+        self._stop_event.set() # 设置外部停止标志
+        self._watch_stop_event.set() # 触发 watchfiles 内部停止
+
+        if self._monitor_thread:
+             # 等待一小段时间让 watch() 循环检测到事件并退出
+             # join() 超时是为了防止 watch() 因某些原因卡住导致主线程无限等待
+             self._monitor_thread.join(timeout=5.0)
+             if self._monitor_thread.is_alive():
+                 logger.warning("Monitor thread did not stop gracefully after 5 seconds.")
+             else:
+                 logger.info("Monitor thread joined.")
+
+        self._monitor_thread = None
+        logger.info("File monitor stopped.")
+
+    def is_running(self) -> bool:
+        """
+        检查监控线程是否正在运行。
+        """
+        return self._monitor_thread is not None and self._monitor_thread.is_alive()
+
+
+def get_file_monitor(root_dir: str) -> FileMonitor:
+    """
+    获取 FileMonitor 的单例实例。
+    """
+    return FileMonitor(root_dir)
+

autocoder/common/global_cancel.py

@@ -14,32 +14,41 @@ class GlobalCancel:
         self._token_flags: Dict[str, bool] = {}
         self._lock = threading.Lock()
         self._context: Dict[str, Any] = {}  # 存储与取消相关的上下文信息
+        self._active_tokens: set[str] = set() # 存储当前正在运行的token
     
-    @property
-    def requested(self) -> bool:
-        """检查是否请求了全局取消（向后兼容）"""
+    def register_token(self, token: str) -> None:
+        """注册一个 token，表示一个操作开始，但尚未请求取消"""
+        with self._lock:            
+            self._token_flags[token] = False            
+            self._active_tokens.add(token)
+
+    def get_active_tokens(self) -> set[str]:
+        """获取当前正在运行的token"""
         with self._lock:
-            return self._global_flag
+            return self._active_tokens.copy()
     
     def is_requested(self, token: Optional[str] = None) -> bool:
-        """检查是否请求了特定token或全局的取消"""
-        with self._lock:
-            # 全局标志总是优先
-            if self._global_flag:
-                return True
-            # 如果提供了token，检查该token的标志
-            if token is not None and token in self._token_flags:
-                return self._token_flags[token]
-            return False
-    
+        """检查是否请求了特定token或全局的取消"""                  
+        if token is not None and token in self._token_flags:
+            return self._token_flags[token]
+        
+        if self._global_flag:
+            return True
+        return False 
+
+    def set_active_tokens(self) -> None:
+        """启用所有活跃的token"""        
+        for token in self._active_tokens:
+            self.set(token)            
+
     def set(self, token: Optional[str] = None, context: Optional[Dict[str, Any]] = None) -> None:
         """设置特定token或全局的取消标志"""
         with self._lock:
             if token is None:
                 self._global_flag = True
             else:
-                self._token_flags[token] = True
-            
+                self._token_flags[token] = True                
+
             # 存储上下文
             if context:
                 if token is None:
@@ -49,6 +58,21 @@ class GlobalCancel:
                         self._context["tokens"] = {}
                     self._context["tokens"][token] = context
     
+    def reset_global(self) -> None:
+        """重置全局取消标志"""
+        with self._lock:
+            self._global_flag = False 
+
+    def reset_token(self, token: str) -> None:
+        """重置特定token的取消标志"""
+        with self._lock:
+            if token in self._token_flags:
+                del self._token_flags[token]
+            if "tokens" in self._context and token in self._context["tokens"]:
+                del self._context["tokens"][token]
+            if token:    
+                self._active_tokens.discard(token) # 从活跃集合中移除
+
     def reset(self, token: Optional[str] = None) -> None:
         """重置特定token或全局的取消标志"""
         with self._lock:
@@ -57,12 +81,21 @@ class GlobalCancel:
                 self._global_flag = False
                 self._token_flags.clear()
                 self._context.clear()
+                self._active_tokens.clear() # 清空活跃集合
             else:
                 # 特定token重置
                 if token in self._token_flags:
                     del self._token_flags[token]
                 if "tokens" in self._context and token in self._context["tokens"]:
                     del self._context["tokens"][token]
+                if token:
+                    self._active_tokens.discard(token) # 从活跃集合中移除
+    
+    def reset_active_tokens(self) -> None:
+        """重置所有活跃的token"""
+        with self._lock:
+            for token in self._active_tokens.copy():
+                self.reset_token(token)            
     
     def get_context(self, token: Optional[str] = None) -> Dict[str, Any]:
         """获取与取消相关的上下文信息"""
@@ -77,6 +110,10 @@ class GlobalCancel:
         """检查是否请求了取消，如果是则抛出异常"""
         if self.is_requested(token):
             context = self.get_context(token)
+            if token:
+                self.reset_token(token)
+            else:
+                self.reset_global()
             raise CancelRequestedException(token, context.get("message", "Operation was cancelled"))
 
 global_cancel = GlobalCancel()

autocoder/common/ignorefiles/__init__.py

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

autocoder/common/ignorefiles/ignore_file_utils.py

@@ -0,0 +1,103 @@
+
+import os
+from pathlib import Path
+from threading import Lock
+import pathspec
+import threading
+
+# 尝试导入 FileMonitor
+try:
+    from autocoder.common.file_monitor.monitor import FileMonitor, Change
+except ImportError:
+    # 如果导入失败，提供一个空的实现
+    print("警告: 无法导入 FileMonitor，忽略文件变更监控将不可用")
+    FileMonitor = None
+    Change = None
+
+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._ignore_file_path = None
+        self._file_monitor = None
+        self._load_ignore_spec()
+        self._setup_file_monitor()
+
+    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()
+                self._ignore_file_path = str(ignore_file)
+                break
+
+        # 添加默认排除目录
+        ignore_patterns.extend(DEFAULT_EXCLUDES)
+
+        self._spec = pathspec.PathSpec.from_lines('gitwildmatch', ignore_patterns)
+
+    def _setup_file_monitor(self):
+        """设置文件监控，当忽略文件变化时重新加载规则"""
+        if FileMonitor is None or not self._ignore_file_path:
+            return
+        
+        try:
+            # 获取或创建 FileMonitor 实例
+            root_dir = os.path.dirname(self._ignore_file_path)
+            self._file_monitor = FileMonitor(root_dir=root_dir)
+            
+            # 注册忽略文件的回调
+            self._file_monitor.register(self._ignore_file_path, self._on_ignore_file_changed)
+                        
+        except Exception as e:
+            print(f"设置忽略文件监控时出错: {e}")
+
+    def _on_ignore_file_changed(self, change_type: Change, changed_path: str):
+        """当忽略文件发生变化时的回调函数"""
+        if os.path.abspath(changed_path) == os.path.abspath(self._ignore_file_path):
+            print(f"检测到忽略文件变化 ({change_type.name}): {changed_path}")
+            self._load_ignore_spec()
+            print("已重新加载忽略规则")
+
+    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)