auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/rulefiles/api.py

@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+"""
+RuleFiles API 接口
+
+提供所有公共 API 函数和便利函数。
+"""
+
+import os
+from typing import Dict, List, Optional, Union, Any
+from loguru import logger
+
+# 导入第三方依赖
+import byzerllm
+from autocoder.common import AutoCoderArgs
+
+# 导入数据模型
+from .models.rule_file import RuleFile
+from .models.summary import AlwaysApplyRuleSummary
+from .models.index import ConditionalRulesIndex
+from .models.init_rule import InitRule
+
+# 导入核心组件
+from .core.manager import AutocoderRulesManager
+from .core.selector import RuleSelector
+
+
+# 对外提供单例
+_rules_manager = None
+
+
+def get_rules(project_root: Optional[str] = None) -> Dict[str, str]:
+    """获取所有规则文件内容，可指定项目根目录"""
+    global _rules_manager
+    if _rules_manager is None:
+        _rules_manager = AutocoderRulesManager(project_root=project_root)
+    return _rules_manager.get_rules()
+
+
+def get_parsed_rules(project_root: Optional[str] = None) -> List[RuleFile]:
+    """获取所有解析后的规则文件，可指定项目根目录"""
+    global _rules_manager
+    if _rules_manager is None:
+        _rules_manager = AutocoderRulesManager(project_root=project_root)
+    return _rules_manager.get_parsed_rules()
+
+
+def parse_rule_file(file_path: str, project_root: Optional[str] = None) -> RuleFile:
+    """解析指定的规则文件，可指定项目根目录"""
+    global _rules_manager
+    if _rules_manager is None:
+        _rules_manager = AutocoderRulesManager(project_root=project_root)
+    return _rules_manager.parse_rule_file(file_path)
+
+
+def reset_rules_manager():
+    """重置AutocoderRulesManager单例实例"""
+    AutocoderRulesManager.reset_instance()
+    global _rules_manager
+    _rules_manager = None
+
+
+def auto_select_rules(context: str, llm: Optional[byzerllm.ByzerLLM] = None, args: Optional[AutoCoderArgs] = None) -> Dict[str, str]:
+    """
+    根据LLM的判断和规则元数据选择适用的规则。
+    
+    Args:
+        context: 上下文信息
+        llm: ByzerLLM 实例
+        args: 可选的 AutoCoderArgs 参数
+        
+    Returns:
+        Dict[str, str]: 选定规则的 {file_path: content} 字典
+    """
+    selector = RuleSelector(llm=llm, args=args)    
+    return selector.get_selected_rules_content(context=context)
+
+
+def get_required_and_index_rules() -> Dict[str, str]:
+    """
+    获取所有必须应用的规则文件(always_apply=True)和Index.md文件。
+    
+    Returns:
+        Dict[str, str]: 包含必须应用的规则和Index.md文件的{file_path: content}字典。
+    """
+    # 获取所有解析后的规则文件
+    parsed_rules = get_parsed_rules()
+    result: Dict[str, str] = {}
+    logger.info(f"获取所有解析后的规则文件完成，总数: {len(parsed_rules)}")
+    
+    for rule in parsed_rules:
+        # 检查是否是always_apply=True的规则
+        if rule.always_apply:
+            result[rule.file_path] = rule.content
+            logger.info(f"添加必须应用的规则: {os.path.basename(rule.file_path)}")
+        
+        # 检查是否是Index.md文件
+        if os.path.basename(rule.file_path).lower() == "index.md":
+            result[rule.file_path] = rule.content
+            logger.info(f"添加Index.md文件: {rule.file_path}")
+    
+    logger.info(f"获取必须应用的规则和Index.md文件完成，总数: {len(result)}")
+    return result
+
+
+def generate_always_apply_summary(llm: Optional[Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]], args: Optional[AutoCoderArgs] = None) -> Optional[AlwaysApplyRuleSummary]:
+    """
+    便利函数：生成所有必须应用规则的合并摘要。
+
+    Args:
+        llm: ByzerLLM 实例
+        args: 可选的 AutoCoderArgs 参数
+
+    Returns:
+        AlwaysApplyRuleSummary: 合并后的规则摘要，如果没有 LLM 则返回 None
+    """
+    selector = RuleSelector(llm=llm, args=args)
+    return selector.generate_always_apply_summary()
+
+
+def generate_conditional_rules_index(llm: Optional[Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]], args: Optional[AutoCoderArgs] = None) -> Optional[ConditionalRulesIndex]:
+    """
+    便利函数：生成所有条件规则的索引目录。
+
+    Args:
+        llm: ByzerLLM 实例
+        args: 可选的 AutoCoderArgs 参数
+
+    Returns:
+        ConditionalRulesIndex: 条件规则索引，如果没有 LLM 则返回 None
+    """
+    selector = RuleSelector(llm=llm, args=args)
+    return selector.generate_conditional_rules_index()
+
+
+def init_rule(llm: Optional[Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]] = None, 
+              args: Optional[AutoCoderArgs] = None, 
+              project_root: Optional[str] = None) -> Optional[InitRule]:
+    """
+    使用 subagent 机制探索项目结构并生成初始化规则，自动保存到 .autocoderrules/init.md 文件。
+
+    Args:
+        llm: ByzerLLM 实例（可选，因为使用 subagent 机制）
+        args: 可选的 AutoCoderArgs 参数
+        project_root: 项目根目录，如果为 None 则使用当前目录
+
+    Returns:
+        InitRule: 生成的初始化规则对象，如果失败则返回 None
+    """
+    try:
+        # 确定项目根目录
+        if project_root is None:
+            project_root = os.getcwd()
+
+        logger.info(f"使用 subagent 机制开始为项目生成初始化规则: {project_root}")
+
+        # 使用 RuleSelector 生成初始化规则，subagent 机制会自动处理文件写入
+        selector = RuleSelector(llm=llm, args=args)
+        init_rule_result = selector.generate_init_rule(project_root=project_root)
+
+        if init_rule_result is None:
+            logger.error("使用 subagent 机制生成初始化规则失败")
+            return None
+
+        logger.info(f"成功使用 subagent 机制生成初始化规则")
+        logger.info(f"初始化规则文件: {init_rule_result.file_path}")
+        logger.info(f"项目类型: {init_rule_result.project_type}")
+        logger.info(f"检测到的技术栈: {', '.join(init_rule_result.technologies)}")
+        logger.info(f"检测到的命令: {', '.join(init_rule_result.commands)}")
+        
+        return init_rule_result
+
+    except Exception as e:
+        logger.error(f"使用 subagent 机制生成初始化规则时出错: {e}", exc_info=True)
+        return None
+
+
+def get_rules_for_conversation(project_root: Optional[str] = None) -> Optional[str]:
+    """
+    获取格式化的规则文本，用于添加到对话中。
+    
+    将必须规则（alwaysApply=true）的完整内容和条件规则（alwaysApply=false）的描述信息
+    格式化为适合对话的文本格式。
+    
+    Args:
+        project_root: 项目根目录，如果为 None 则使用当前目录
+        
+    Returns:
+        str: 格式化的规则文本，如果没有规则则返回 None
+    """
+    try:
+        # 获取所有解析后的规则
+        all_rules = get_parsed_rules(project_root)
+        
+        if not all_rules:
+            logger.info("未找到任何规则文件")
+            return None
+        
+        # 分离必须规则和条件规则
+        required_rules = [rule for rule in all_rules if rule.always_apply]
+        conditional_rules = [rule for rule in all_rules if not rule.always_apply]
+        
+        # 构建消息内容
+        message_parts = []
+        
+        # 添加必须规则的完整内容
+        if required_rules:
+            message_parts.append("## Required Rules (Always Applied)")
+            message_parts.append("The following rules must always be followed:")
+            message_parts.append("")
+            
+            for rule in required_rules:
+                rule_name = os.path.basename(rule.file_path)
+                message_parts.append(f"### {rule_name}")
+                if rule.description:
+                    message_parts.append(f"**Description**: {rule.description}")
+                if rule.globs:
+                    message_parts.append(f"**Applicable Files**: {', '.join(rule.globs)}")
+                message_parts.append("")
+                message_parts.append(rule.content)
+                message_parts.append("")
+        
+        # 添加条件规则的描述和路径
+        if conditional_rules:
+            message_parts.append("## Conditional Rules (Apply as Needed)")
+            message_parts.append("The following rules are available for specific contexts. Use the read_file tool to read their full content when needed:")
+            message_parts.append("")
+            
+            for rule in conditional_rules:
+                rule_name = os.path.basename(rule.file_path)
+                message_parts.append(f"### {rule_name}")
+                message_parts.append(f"**Path**: `{rule.file_path}`")
+                if rule.description:
+                    message_parts.append(f"**Description**: {rule.description}")
+                if rule.globs:
+                    message_parts.append(f"**Applicable Files**: {', '.join(rule.globs)}")
+                message_parts.append("")
+        
+        # 如果没有任何规则，返回 None
+        if not message_parts:
+            return None
+            
+        combined_rules = "\n".join(message_parts)
+        logger.info(f"成功格式化规则文本，必须规则: {len(required_rules)}, 条件规则: {len(conditional_rules)}")
+        return combined_rules
+        
+    except Exception as e:
+        logger.error(f"获取对话规则时出错: {e}", exc_info=True)
+        return None
+
+ 

autocoder/common/rulefiles/core/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+"""
+RuleFiles 核心功能
+
+包含规则管理器和规则选择器等核心组件。
+"""
+
+from .manager import AutocoderRulesManager
+from .selector import RuleSelector
+
+__all__ = [
+    'AutocoderRulesManager',
+    'RuleSelector',
+] 

autocoder/common/rulefiles/core/manager.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""
+AutocoderRulesManager 
+
+规则管理器，负责加载、监控和管理规则文件。
+实现单例模式，确保全局只有一个规则管理实例。
+"""
+
+import os
+import re
+import yaml
+from typing import Dict, List, Optional, Set, TYPE_CHECKING
+from threading import Lock
+from loguru import logger
+
+# 导入数据模型
+from ..models.rule_file import RuleFile
+
+# 导入工具函数
+from ..utils.parser import parse_rule_file as parse_rule_file_util
+
+# 条件导入以避免循环依赖
+if TYPE_CHECKING:
+    pass
+
+
+class AutocoderRulesManager:
+    """
+    管理 autocoderrules 目录中的规则文件。
+    
+    实现单例模式，确保全局只有一个规则管理实例。
+    每次访问时都会重新加载规则文件。
+    """
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, project_root: Optional[str] = None):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(AutocoderRulesManager, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, project_root: Optional[str] = None):
+        if self._initialized:
+            return
+        self._initialized = True
+        
+        self._rules: Dict[str, str] = {}  # 存储规则文件内容: {file_path: content}
+        self._rules_dir: Optional[str] = None  # 当前使用的规则目录
+        self._project_root = project_root if project_root is not None else os.getcwd()  # 项目根目录
+        
+        # 加载规则
+        self._load_rules()
+
+    def _load_rules(self):
+        """
+        重新实现的规则加载逻辑，不使用 FinderConfig。
+        加载顺序：
+        1. 项目级规则文件（按优先级）
+        2. 全局规则文件 (~/.auto-coder/autocoderrules)
+        3. 全局 repos 子目录规则（基于当前目录名）
+        
+        确保不重复加载相同的文件。
+        """
+        self._rules = {}
+        loaded_files: Set[str] = set()  # 跟踪已加载的文件，避免重复
+        
+        # 1. 加载项目级规则文件（按优先级）
+        self._load_project_rules(loaded_files)
+        
+        # 2. 加载全局规则文件
+        self._load_global_rules(loaded_files)
+        
+        # 3. 加载全局 repos 子目录规则
+        self._load_global_repos_rules(loaded_files)
+        
+        logger.info(f"总共加载了 {len(self._rules)} 个规则文件")
+    
+    def _load_project_rules(self, loaded_files: Set[str]):
+        """加载项目级规则文件，按优先级顺序"""
+        project_root = self._project_root
+        
+        # 按优先级定义项目级规则目录
+        project_dirs = [
+            os.path.join(project_root, ".autocoderrules"),
+            os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+            os.path.join(project_root, ".auto-coder", "autocoderrules")
+        ]
+        
+        # 查找第一个包含 .md 文件的目录
+        for rules_dir in project_dirs:
+            if self._has_md_files(rules_dir):
+                self._rules_dir = rules_dir
+                logger.info(f"找到项目规则目录: {rules_dir}")
+                self._load_rules_from_directory(rules_dir, loaded_files)
+                return
+        
+        logger.info("未找到项目级规则目录")
+    
+    def _load_global_rules(self, loaded_files: Set[str]):
+        """加载全局规则文件 (~/.auto-coder/autocoderrules)"""
+        home_dir = os.path.expanduser("~")
+        global_rules_dir = os.path.join(home_dir, ".auto-coder", "autocoderrules")
+        
+        if self._has_md_files(global_rules_dir):
+            logger.info(f"找到全局规则目录: {global_rules_dir}")
+            self._load_rules_from_directory(global_rules_dir, loaded_files)
+        else:
+            logger.info("未找到全局规则目录")
+    
+    def _load_global_repos_rules(self, loaded_files: Set[str]):
+        """加载全局 repos 子目录规则（基于当前目录名）"""
+        home_dir = os.path.expanduser("~")
+        global_rules_dir = os.path.join(home_dir, ".auto-coder", "autocoderrules")
+        repos_dir = os.path.join(global_rules_dir, "repos")
+        
+        if not os.path.isdir(repos_dir):
+            logger.info("未找到全局 repos 目录")
+            return
+        
+        # 获取当前目录名
+        current_dir_name = os.path.basename(self._project_root)
+        repo_specific_dir = os.path.join(repos_dir, current_dir_name)
+        
+        if self._has_md_files(repo_specific_dir):
+            logger.info(f"找到仓库特定规则目录: {repo_specific_dir}")
+            self._load_rules_from_directory(repo_specific_dir, loaded_files)
+        else:
+            logger.info(f"未找到仓库特定规则目录: {repo_specific_dir}")
+    
+    def _has_md_files(self, directory: str) -> bool:
+        """检查目录是否存在且包含 .md 文件"""
+        if not os.path.isdir(directory):
+            return False
+        
+        try:
+            for fname in os.listdir(directory):
+                if fname.endswith(".md"):
+                    return True
+            return False
+        except Exception as e:
+            logger.warning(f"检查目录 {directory} 时出错: {e}")
+            return False
+    
+    def _load_rules_from_directory(self, rules_dir: str, loaded_files: Set[str]):
+        """从指定目录加载规则文件，避免重复加载"""
+        logger.info(f"扫描规则目录: {rules_dir}")
+        try:
+            for fname in os.listdir(rules_dir):
+                if fname.endswith(".md"):
+                    fpath = os.path.join(rules_dir, fname)
+                    
+                    # 使用规范化路径避免重复加载
+                    normalized_path = os.path.normpath(os.path.abspath(fpath))
+                    if normalized_path in loaded_files:
+                        logger.info(f"跳过重复文件: {fpath}")
+                        continue
+                    
+                    try:
+                        with open(fpath, "r", encoding="utf-8") as f:
+                            content = f.read()
+                            self._rules[fpath] = content
+                            loaded_files.add(normalized_path)
+                            logger.info(f"已加载规则文件: {fpath}")
+                    except Exception as e:
+                        logger.warning(f"加载规则文件 {fpath} 时出错: {e}")
+                        continue
+        except Exception as e:
+            logger.warning(f"读取规则目录 {rules_dir} 时出错: {e}")
+
+    def parse_rule_file(self, file_path: str) -> RuleFile:
+        """
+        解析规则文件并返回结构化的Pydantic模型对象
+        
+        Args:
+            file_path: 规则文件的路径
+            
+        Returns:
+            RuleFile: 包含规则文件结构化内容的Pydantic模型
+        """
+        if not os.path.exists(file_path) or not file_path.endswith('.md'):
+            logger.warning(f"无效的规则文件路径: {file_path}")
+            return RuleFile(file_path=file_path)
+            
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            # 解析YAML头部和Markdown内容
+            yaml_pattern = re.compile(r'^---\s*\n(.*?)\n---\s*\n', re.DOTALL)
+            yaml_match = yaml_pattern.search(content)
+            
+            metadata = {}
+            markdown_content = content
+            
+            if yaml_match:
+                yaml_content = yaml_match.group(1)
+                try:
+                    metadata = yaml.safe_load(yaml_content)
+                    # 移除YAML部分，仅保留Markdown内容
+                    markdown_content = content[yaml_match.end():]
+                except Exception as e:
+                    logger.warning(f"解析规则文件YAML头部时出错: {e}")
+            
+            # 创建并返回Pydantic模型            
+            rule = RuleFile(
+                description=metadata.get('description', ''),
+                globs=metadata.get('globs', []),
+                always_apply=metadata.get('alwaysApply', False),
+                content=markdown_content.strip(),
+                file_path=file_path
+            )                                    
+            return rule
+            
+        except Exception as e:
+            logger.warning(f"解析规则文件时出错: {file_path}, 错误: {e}")
+            return RuleFile(file_path=file_path)
+
+    def get_rules(self) -> Dict[str, str]:
+        """获取所有规则文件内容，总是重新加载"""
+        self._load_rules()  # 总是重新加载
+        return self._rules.copy()
+        
+    def get_parsed_rules(self) -> List[RuleFile]:
+        """获取所有解析后的规则文件，总是重新加载"""
+        self._load_rules()  # 总是重新加载
+        parsed_rules = []
+        for file_path in self._rules:
+            parsed_rule = self.parse_rule_file(file_path)
+            parsed_rules.append(parsed_rule)
+        return parsed_rules
+
+    @classmethod
+    def reset_instance(cls):
+        """重置单例实例"""
+        with cls._lock:
+            if cls._instance is not None:
+                cls._instance = None
+                logger.info("AutocoderRulesManager单例已被重置")