auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/priority_directory_finder/__init__.py

@@ -0,0 +1,142 @@
+"""
+优先级目录查找器模块
+
+一个灵活的目录查找工具，支持多种查找策略和验证规则，
+用于在多个优先级目录中查找有效的目录。
+
+主要功能：
+- 多种查找策略：顺序查找、合并查找、全部查找
+- 可配置的验证规则：文件类型、数量等
+- 灵活的路径配置：支持环境变量和用户主目录展开
+- 标准路径模式：项目级、项目.auto-coder、全局目录
+"""
+
+from .models import (
+    SearchStrategy,
+    ValidationMode,
+    FileTypeFilter,
+    DirectoryConfig,
+    SearchResult,
+    FinderConfig
+)
+
+from .finder import (
+    PriorityDirectoryFinder,
+    QuickFinder
+)
+
+# 版本信息
+__version__ = "1.0.0"
+
+# 导出的主要类和函数
+__all__ = [
+    # 枚举类型
+    "SearchStrategy",
+    "ValidationMode",
+    
+    # 数据模型
+    "FileTypeFilter",
+    "DirectoryConfig", 
+    "SearchResult",
+    "FinderConfig",
+    
+    # 核心类
+    "PriorityDirectoryFinder",
+    "QuickFinder",
+    
+    # 便捷函数
+    "find_command_directories",
+    "find_config_directories",
+    "find_standard_directories",
+    "create_file_filter",
+    "create_directory_config",
+]
+
+
+def find_command_directories(current_dir=None):
+    """
+    查找命令目录的便捷函数
+    
+    Args:
+        current_dir: 当前目录，如果为None则使用os.getcwd()
+        
+    Returns:
+        SearchResult: 查找结果
+    """
+    return QuickFinder.find_command_directories(current_dir)
+
+
+def find_config_directories(current_dir=None):
+    """
+    查找配置目录的便捷函数
+    
+    Args:
+        current_dir: 当前目录
+        
+    Returns:
+        SearchResult: 查找结果
+    """
+    return QuickFinder.find_config_directories(current_dir)
+
+
+def find_standard_directories(base_name, current_dir=None, file_extensions=None, strategy=SearchStrategy.FIRST_MATCH):
+    """
+    查找标准目录结构的便捷函数
+    
+    Args:
+        base_name: 基础目录名
+        current_dir: 当前目录
+        file_extensions: 要查找的文件扩展名列表
+        strategy: 查找策略
+        
+    Returns:
+        SearchResult: 查找结果
+    """
+    return QuickFinder.find_standard_directories(base_name, current_dir, file_extensions, strategy)
+
+
+def create_file_filter(extensions=None, patterns=None, min_count=1, recursive=True, include_hidden=False):
+    """
+    创建文件类型过滤器的便捷函数
+    
+    Args:
+        extensions: 文件扩展名列表
+        patterns: 文件名模式列表
+        min_count: 最小文件数量
+        recursive: 是否递归搜索
+        include_hidden: 是否包含隐藏文件
+        
+    Returns:
+        FileTypeFilter: 文件过滤器
+    """
+    return FileTypeFilter(
+        extensions=set(extensions or []),
+        patterns=set(patterns or []),
+        min_count=min_count,
+        recursive=recursive,
+        include_hidden=include_hidden
+    )
+
+
+def create_directory_config(path, priority=0, validation_mode=ValidationMode.HAS_FILES, 
+                          file_filter=None, description=""):
+    """
+    创建目录配置的便捷函数
+    
+    Args:
+        path: 目录路径
+        priority: 优先级
+        validation_mode: 验证模式
+        file_filter: 文件过滤器
+        description: 描述
+        
+    Returns:
+        DirectoryConfig: 目录配置
+    """
+    return DirectoryConfig(
+        path=path,
+        priority=priority,
+        validation_mode=validation_mode,
+        file_filter=file_filter,
+        description=description
+    ) 

autocoder/common/priority_directory_finder/examples.py

@@ -0,0 +1,230 @@
+"""
+优先级目录查找器使用示例
+
+展示不同的使用场景和配置方式。
+"""
+
+import os
+import tempfile
+from typing import List
+
+from . import (
+    PriorityDirectoryFinder, QuickFinder, FinderConfig, DirectoryConfig,
+    SearchStrategy, ValidationMode, FileTypeFilter,
+    find_command_directories, create_file_filter
+)
+
+
+def example_basic_usage():
+    """基础使用示例"""
+    print("=== 基础使用示例 ===")
+    
+    # 简单查找命令目录
+    result = find_command_directories()
+    print(f"查找命令目录: 成功={result.success}")
+    if result.success:
+        print(f"选择的目录: {result.primary_directory}")
+    
+    # 手动配置查找器
+    config = FinderConfig()
+    config.add_directory(".autocodercommands", priority=1)
+    config.add_directory("~/commands", priority=2)
+    
+    finder = PriorityDirectoryFinder(config)
+    result = finder.find_directories()
+    print(f"手动配置查找: 成功={result.success}")
+    
+
+def example_different_strategies():
+    """不同查找策略示例"""
+    print("\n=== 不同查找策略示例 ===")
+    
+    # 创建测试目录
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_dirs = []
+        for i in range(3):
+            dir_path = os.path.join(temp_dir, f"test_{i}")
+            os.makedirs(dir_path)
+            # 创建测试文件
+            with open(os.path.join(dir_path, f"file_{i}.md"), 'w') as f:
+                f.write(f"Test file {i}")
+            test_dirs.append(dir_path)
+        
+        config = FinderConfig()
+        for i, dir_path in enumerate(test_dirs):
+            config.add_directory(dir_path, priority=i)
+        
+        # 测试不同策略
+        strategies = [
+            (SearchStrategy.FIRST_MATCH, "顺序查找"),
+            (SearchStrategy.LIST_ALL, "全部查找"),
+            (SearchStrategy.MERGE_ALL, "合并查找")
+        ]
+        
+        for strategy, name in strategies:
+            config.strategy = strategy
+            finder = PriorityDirectoryFinder(config)
+            result = finder.find_directories()
+            print(f"{name}: 找到 {len(result.selected_directories)} 个目录")
+
+
+def example_file_type_filtering():
+    """文件类型过滤示例"""
+    print("\n=== 文件类型过滤示例 ===")
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # 创建不同类型的文件
+        md_dir = os.path.join(temp_dir, "md_files")
+        py_dir = os.path.join(temp_dir, "py_files")
+        empty_dir = os.path.join(temp_dir, "empty")
+        
+        os.makedirs(md_dir)
+        os.makedirs(py_dir)
+        os.makedirs(empty_dir)
+        
+        # 创建测试文件
+        with open(os.path.join(md_dir, "test.md"), 'w') as f:
+            f.write("# Test")
+        with open(os.path.join(py_dir, "test.py"), 'w') as f:
+            f.write("print('test')")
+        
+        # 配置不同的文件过滤器
+        filters = [
+            (create_file_filter(extensions=[".md"]), "Markdown文件"),
+            (create_file_filter(extensions=[".py"]), "Python文件"),
+            (create_file_filter(extensions=[".txt"]), "文本文件"),
+        ]
+        
+        for file_filter, description in filters:
+            config = FinderConfig()
+            config.add_directory(md_dir, priority=1, 
+                               validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+                               file_filter=file_filter)
+            config.add_directory(py_dir, priority=2,
+                               validation_mode=ValidationMode.HAS_SPECIFIC_FILES, 
+                               file_filter=file_filter)
+            config.add_directory(empty_dir, priority=3,
+                               validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+                               file_filter=file_filter)
+            
+            finder = PriorityDirectoryFinder(config)
+            result = finder.find_directories()
+            print(f"{description}: 找到目录 = {result.primary_directory or 'None'}")
+
+
+def example_custom_validation():
+    """自定义验证示例"""
+    print("\n=== 自定义验证示例 ===")
+    
+    def has_large_files(directory: str) -> bool:
+        """检查目录是否包含大文件（>1KB）"""
+        try:
+            for item in os.listdir(directory):
+                item_path = os.path.join(directory, item)
+                if os.path.isfile(item_path) and os.path.getsize(item_path) > 1024:
+                    return True
+            return False
+        except:
+            return False
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # 创建小文件目录
+        small_dir = os.path.join(temp_dir, "small_files")
+        os.makedirs(small_dir)
+        with open(os.path.join(small_dir, "small.txt"), 'w') as f:
+            f.write("small")
+        
+        # 创建大文件目录
+        large_dir = os.path.join(temp_dir, "large_files") 
+        os.makedirs(large_dir)
+        with open(os.path.join(large_dir, "large.txt"), 'w') as f:
+            f.write("x" * 2048)  # 2KB文件
+        
+        config = FinderConfig()
+        config.add_directory(small_dir, priority=1,
+                           validation_mode=ValidationMode.CUSTOM,
+                           custom_validator=has_large_files)
+        config.add_directory(large_dir, priority=2,
+                           validation_mode=ValidationMode.CUSTOM,
+                           custom_validator=has_large_files)
+        
+        finder = PriorityDirectoryFinder(config)
+        result = finder.find_directories()
+        print(f"包含大文件的目录: {result.primary_directory or 'None'}")
+
+
+def example_standard_paths():
+    """标准路径模式示例"""
+    print("\n=== 标准路径模式示例 ===")
+    
+    # 使用QuickFinder查找标准结构
+    result = QuickFinder.find_standard_directories(
+        base_name=".autocodercommands",
+        file_extensions=["md"],
+        strategy=SearchStrategy.LIST_ALL
+    )
+    
+    print(f"标准命令目录查找: 成功={result.success}")
+    print(f"所有有效目录: {result.all_valid_directories}")
+    
+    if result.metadata:
+        print("目录配置详情:")
+        for config in result.metadata.get("directory_configs", []):
+            print(f"  {config['path']} -> {config['expanded_path']} (有效: {config['is_valid']})")
+
+
+def example_file_collection():
+    """文件收集示例"""
+    print("\n=== 文件收集示例 ===")
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # 创建测试目录和文件
+        for i in range(2):
+            sub_dir = os.path.join(temp_dir, f"dir_{i}")
+            os.makedirs(sub_dir)
+            for j in range(3):
+                with open(os.path.join(sub_dir, f"file_{i}_{j}.md"), 'w') as f:
+                    f.write(f"Content {i}-{j}")
+        
+        # 查找目录
+        config = FinderConfig(strategy=SearchStrategy.LIST_ALL)
+        for i in range(2):
+            config.add_directory(os.path.join(temp_dir, f"dir_{i}"))
+        
+        finder = PriorityDirectoryFinder(config)
+        result = finder.find_directories()
+        
+        # 收集文件
+        md_filter = create_file_filter(extensions=[".md"])
+        files = finder.collect_files_from_directories(
+            result.selected_directories, 
+            md_filter
+        )
+        
+        print(f"收集到的Markdown文件: {len(files)}")
+        for file_path in files:
+            print(f"  {os.path.basename(file_path)}")
+
+
+def main():
+    """运行所有示例"""
+    examples = [
+        example_basic_usage,
+        example_different_strategies,
+        example_file_type_filtering,
+        example_custom_validation,
+        example_standard_paths,
+        example_file_collection,
+    ]
+    
+    for example in examples:
+        try:
+            example()
+        except Exception as e:
+            print(f"运行示例 {example.__name__} 时发生错误: {e}")
+    
+    print("\n=== 所有示例运行完成 ===")
+
+
+if __name__ == "__main__":
+    main() 

autocoder/common/priority_directory_finder/finder.py

@@ -0,0 +1,283 @@
+"""
+优先级目录查找器核心实现
+
+提供灵活的目录查找功能，支持多种查找策略和验证规则。
+"""
+
+import os
+from typing import List, Optional, Dict, Any
+from loguru import logger
+
+from .models import (
+    SearchStrategy, ValidationMode, FileTypeFilter, DirectoryConfig,
+    SearchResult, FinderConfig
+)
+
+
+class PriorityDirectoryFinder:
+    """优先级目录查找器"""
+    
+    def __init__(self, config: Optional[FinderConfig] = None):
+        """
+        初始化查找器
+        
+        Args:
+            config: 查找器配置，如果为None则使用默认配置
+        """
+        self.config = config or FinderConfig()
+    
+    def find_directories(self, config: Optional[FinderConfig] = None) -> SearchResult:
+        """
+        查找目录
+        
+        Args:
+            config: 查找配置，如果为None则使用初始化时的配置
+            
+        Returns:
+            SearchResult: 查找结果
+        """
+        use_config = config or self.config
+        
+        result = SearchResult(
+            strategy=use_config.strategy,
+            success=False
+        )
+        
+        # 获取排序后的目录列表
+        directories = use_config.get_sorted_directories()
+        
+        if not directories:
+            logger.warning("没有配置任何目录")
+            if use_config.fail_on_no_match:
+                result.add_error("config", "没有配置任何目录")
+            return result
+        
+        # 验证所有目录并收集有效目录
+        valid_directories = []
+        for dir_config in directories:
+            try:
+                if dir_config.validate_directory():
+                    expanded_path = dir_config.get_expanded_path()
+                    valid_directories.append(expanded_path)
+                    logger.debug(f"目录有效: {expanded_path} (优先级: {dir_config.priority})")
+                else:
+                    logger.debug(f"目录无效: {dir_config.path}")
+            except Exception as e:
+                error_msg = f"验证目录时发生错误: {str(e)}"
+                result.add_error(dir_config.path, error_msg)
+                logger.warning(f"验证目录 {dir_config.path} 时发生错误: {e}")
+        
+        result.all_valid_directories = valid_directories
+        
+        # 根据策略选择目录
+        if use_config.strategy == SearchStrategy.FIRST_MATCH:
+            result.selected_directories = valid_directories[:1] if valid_directories else []
+        
+        elif use_config.strategy == SearchStrategy.MERGE_ALL:
+            result.selected_directories = valid_directories
+        
+        elif use_config.strategy == SearchStrategy.LIST_ALL:
+            result.selected_directories = valid_directories
+        
+        # 如果没有找到有效目录，尝试使用回退目录
+        if not result.selected_directories and use_config.default_fallback:
+            fallback_path = os.path.expanduser(use_config.default_fallback)
+            fallback_path = os.path.expandvars(fallback_path)
+            fallback_path = os.path.abspath(fallback_path)
+            
+            result.selected_directories = [fallback_path]
+            logger.info(f"使用回退目录: {fallback_path}")
+        
+        # 设置成功状态
+        result.success = len(result.selected_directories) > 0
+        
+        if not result.success and use_config.fail_on_no_match:
+            result.add_error("search", "没有找到任何有效目录")
+        
+        # 添加元数据
+        if use_config.include_metadata:
+            result.metadata.update({
+                "total_configured": len(directories),
+                "total_valid": len(valid_directories),
+                "strategy_used": use_config.strategy.value,
+                "directory_configs": [
+                    {
+                        "path": d.path,
+                        "expanded_path": d.get_expanded_path(),
+                        "priority": d.priority,
+                        "description": d.description,
+                        "is_valid": d.validate_directory()
+                    }
+                    for d in directories
+                ]
+            })
+        
+        logger.info(f"目录查找完成: 策略={use_config.strategy.value}, "
+                   f"配置={len(directories)}, 有效={len(valid_directories)}, "
+                   f"选择={len(result.selected_directories)}")
+        
+        return result
+    
+    def find_first_directory(self, config: Optional[FinderConfig] = None) -> Optional[str]:
+        """
+        查找第一个有效目录
+        
+        Args:
+            config: 查找配置
+            
+        Returns:
+            str: 第一个有效目录路径，如果没有找到则返回None
+        """
+        use_config = config or self.config
+        original_strategy = use_config.strategy
+        use_config.strategy = SearchStrategy.FIRST_MATCH
+        
+        try:
+            result = self.find_directories(use_config)
+            return result.primary_directory
+        finally:
+            use_config.strategy = original_strategy
+    
+    def find_all_directories(self, config: Optional[FinderConfig] = None) -> List[str]:
+        """
+        查找所有有效目录
+        
+        Args:
+            config: 查找配置
+            
+        Returns:
+            List[str]: 所有有效目录路径列表
+        """
+        use_config = config or self.config
+        original_strategy = use_config.strategy
+        use_config.strategy = SearchStrategy.LIST_ALL
+        
+        try:
+            result = self.find_directories(use_config)
+            return result.selected_directories
+        finally:
+            use_config.strategy = original_strategy
+    
+    def collect_files_from_directories(self, 
+                                     directories: List[str], 
+                                     file_filter: Optional[FileTypeFilter] = None) -> List[str]:
+        """
+        从目录列表中收集文件
+        
+        Args:
+            directories: 目录路径列表
+            file_filter: 文件过滤器
+            
+        Returns:
+            List[str]: 收集到的文件路径列表
+        """
+        all_files = []
+        
+        for directory in directories:
+            if not os.path.exists(directory) or not os.path.isdir(directory):
+                continue
+            
+            try:
+                self._collect_files_recursive(directory, all_files, file_filter)
+            except (OSError, PermissionError) as e:
+                logger.warning(f"无法访问目录 {directory}: {e}")
+        
+        return all_files
+    
+    def _collect_files_recursive(self, 
+                               directory: str, 
+                               file_list: List[str], 
+                               file_filter: Optional[FileTypeFilter] = None) -> None:
+        """
+        递归收集文件
+        
+        Args:
+            directory: 目录路径
+            file_list: 文件列表（会被修改）
+            file_filter: 文件过滤器
+        """
+        for item in os.listdir(directory):
+            item_path = os.path.join(directory, item)
+            
+            if os.path.isfile(item_path):
+                if file_filter is None or file_filter.matches_file(item_path):
+                    file_list.append(item_path)
+            
+            elif (os.path.isdir(item_path) and 
+                  (file_filter is None or file_filter.recursive) and
+                  not os.path.basename(item).startswith('.')):
+                self._collect_files_recursive(item_path, file_list, file_filter)
+
+
+class QuickFinder:
+    """快速查找器 - 提供简化的API"""
+    
+    @staticmethod
+    def find_standard_directories(base_name: str, 
+                                current_dir: Optional[str] = None,
+                                file_extensions: Optional[List[str]] = None,
+                                strategy: SearchStrategy = SearchStrategy.FIRST_MATCH) -> SearchResult:
+        """
+        查找标准目录结构
+        
+        Args:
+            base_name: 基础目录名（如 ".autocodercommands"）
+            current_dir: 当前目录，如果为None则使用os.getcwd()
+            file_extensions: 要查找的文件扩展名列表
+            strategy: 查找策略
+            
+        Returns:
+            SearchResult: 查找结果
+        """
+        config = FinderConfig(strategy=strategy)
+        config.add_standard_paths(base_name, current_dir)
+        
+        # 设置文件过滤器
+        if file_extensions:
+            file_filter = FileTypeFilter(
+                extensions=set(f".{ext.lstrip('.')}" for ext in file_extensions),
+                recursive=True
+            )
+            
+            for dir_config in config.directories:
+                dir_config.validation_mode = ValidationMode.HAS_SPECIFIC_FILES
+                dir_config.file_filter = file_filter
+        
+        finder = PriorityDirectoryFinder(config)
+        return finder.find_directories()
+    
+    @staticmethod
+    def find_command_directories(current_dir: Optional[str] = None) -> SearchResult:
+        """
+        查找命令目录（.autocodercommands）
+        
+        Args:
+            current_dir: 当前目录
+            
+        Returns:
+            SearchResult: 查找结果
+        """
+        return QuickFinder.find_standard_directories(
+            base_name=".autocodercommands",
+            current_dir=current_dir,
+            file_extensions=["md"],
+            strategy=SearchStrategy.FIRST_MATCH
+        )
+    
+    @staticmethod
+    def find_config_directories(current_dir: Optional[str] = None) -> SearchResult:
+        """
+        查找配置目录
+        
+        Args:
+            current_dir: 当前目录
+            
+        Returns:
+            SearchResult: 查找结果
+        """
+        return QuickFinder.find_standard_directories(
+            base_name=".auto-coder",
+            current_dir=current_dir,
+            file_extensions=["yml", "yaml", "json"],
+            strategy=SearchStrategy.FIRST_MATCH
+        )