auto-coder 0.1.259__py3-none-any.whl → 0.1.261__py3-none-any.whl

autocoder/common/conf_validator.py

@@ -0,0 +1,245 @@
+from typing import Any
+from autocoder.utils import llms as llms_utils
+from autocoder.common.auto_coder_lang import get_message_with_format
+
+class ConfigValidationError(Exception):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)
+
+class ConfigValidator:
+    CONFIG_SPEC = {
+        # 核心配置项
+        "auto_merge": {
+            "type": str,
+            "allowed": ["editblock", "diff", "wholefile"],
+            "default": "editblock",
+            "description": "代码合并方式(editblock/diff/wholefile)"
+        },
+        "editblock_similarity": {
+            "type": float,
+            "min": 0.0,
+            "max": 1.0,
+            "default": 0.9,
+            "description": "代码块相似度阈值(0-1)"
+        },
+        "generate_times_same_model": {
+            "type": int,
+            "min": 1,
+            "max": 5,
+            "default": 1,
+            "description": "同模型生成次数(1-5)"
+        },
+        "skip_filter_index": {
+            "type": bool,
+            "default": False,
+            "description": "是否跳过根据用户的query自动查找上下文"
+        },
+        "skip_build_index": {
+            "type": bool,
+            "default": True,
+            "description": "是否自动构建索引"
+        },
+        "enable_global_memory": {
+            "type": bool,
+            "default": True,
+            "description": "是否开启全局记忆"
+        },
+        "rank_times_same_model": {
+            "type": int,
+            "min": 1,
+            "max": 3,
+            "default": 1,
+            "description": "相同模型重排序次数"
+        },
+        "human_as_model": {
+            "type": bool,
+            "default": False,
+            "description": "是否以人类作为模型"
+        },
+        "skip_confirm": {
+            "type": bool,
+            "default": True,
+            "description": "是否跳过确认步骤"
+        },
+        "silence": {
+            "type": bool,
+            "default": True,
+            "description": "是否静默模式"
+        },
+        "include_project_structure": {
+            "type": bool,
+            "default": True,
+            "description": "是否包含项目结构"
+        },
+        "product_mode": {
+            "type": str,
+            "allowed": ["lite", "pro"],
+            "default": "lite",
+            "description": "产品模式(lite/pro)"
+        },
+        "model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "默认模型名称"
+        },
+        "chat_model": {
+            "type": str,
+            "default": "r1_chat",
+            "description": "聊天模型名称"
+        },
+        "code_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "代码生成模型名称"
+        },
+        "index_filter_model": {
+            "type": str,
+            "default": "r1_chat",
+            "description": "索引过滤模型名称"
+        },
+        "generate_rerank_model": {
+            "type": str,
+            "default": "r1_chat",
+            "description": "生成重排序模型名称"
+        },
+        "emb_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "嵌入模型名称"
+        },
+        "vl_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "视觉语言模型名称"
+        },
+        "designer_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "设计模型名称"
+        },
+        "sd_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "稳定扩散模型名称"
+        },
+        "voice2text_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "语音转文本模型名称"
+        },
+        "commit_model": {
+            "type": str,
+            "default": "v3_chat",
+            "description": "提交信息生成模型名称"
+        }
+    }
+
+    @classmethod
+    def validate(cls, key: str, value: Any, product_mode: str) -> Any:
+        # 获取配置规范
+        spec = cls.CONFIG_SPEC.get(key)
+        if not spec:
+            # raise ConfigValidationError(
+            #     get_message_with_format("unknown_config_key", key=key)
+            # )
+            return
+
+        # 类型转换和验证
+        try:
+            # 布尔类型特殊处理
+            if isinstance(spec['type'], (list, tuple)):
+                # 多个类型支持
+                for type_ in spec['type']:
+                    try:
+                        if type_ == bool:
+                            return cls.validate_boolean(value)
+                        converted_value = type_(value)
+                        break
+                    except ValueError:
+                        continue
+                else:
+                    types_str = ', '.join([t.__name__ for t in spec['type']])
+                    raise ConfigValidationError(
+                        get_message_with_format(f"invalid_type_value", 
+                                  value=value,
+                                  types=types_str)
+                    )
+            else:
+                # 单个类型处理
+                if spec['type'] == bool:
+                    return cls.validate_boolean(value)
+                converted_value = spec['type'](value)
+        except ValueError:
+            type_name = spec['type'].__name__ if not isinstance(spec['type'], (list, tuple)) else ', '.join([t.__name__ for t in spec['type']])
+            raise ConfigValidationError(
+                get_message_with_format(f"invalid_type_value", 
+                          value=value,
+                          types=type_name)
+            )
+
+        # 范围检查
+        if 'min' in spec and converted_value < spec['min']:
+            raise ConfigValidationError(
+                get_message_with_format("value_out_of_range", 
+                          value=converted_value,
+                          min=spec['min'],
+                          max=spec['max'])
+            )
+        
+        if 'max' in spec and converted_value > spec['max']:
+            raise ConfigValidationError(
+                get_message_with_format("value_out_of_range", 
+                          value=converted_value,
+                          min=spec['min'],
+                          max=spec['max'])
+            )
+
+        # 枚举值检查
+        if 'allowed' in spec and converted_value not in spec['allowed']:
+            raise ConfigValidationError(
+                get_message_with_format("invalid_enum_value", 
+                          value=converted_value,
+                          allowed=', '.join(map(str, spec['allowed'])))
+            )
+        
+        # 模型存在性检查        
+        if product_mode == "lite" and key in ["chat_model","code_model", 
+                                     "index_filter_model", "generate_rerank_model", 
+                                     "rank_times_same_model", 
+                                     "emb_model", "vl_model", "designer_model", "sd_model", 
+                                     "voice2text_model", 
+                                     "commit_model","model"]:
+            if not llms_utils.get_model_info(converted_value,product_mode):
+                raise ConfigValidationError(
+                    get_message_with_format("model_not_found", model=converted_value)
+                )
+
+        return converted_value
+
+    @staticmethod
+    def validate_boolean(value: str) -> bool:
+        if value.lower() in ("true", "1", "yes"):
+            return True
+        if value.lower() in ("false", "0", "no"):
+            return False
+        raise ConfigValidationError(
+            get_message_with_format("invalid_boolean_value", value=value)
+        )
+
+    @classmethod
+    def get_config_docs(cls) -> str:
+        """生成配置项文档"""
+        docs = ["可用配置项："]
+        for key, spec in cls.CONFIG_SPEC.items():
+            desc = [
+                f"- {key}: {spec['description']}",
+                f"  类型: {spec['type'].__name__}",
+                f"  默认值: {spec['default']}"
+            ]
+            if "allowed" in spec:
+                desc.append(f"  允许值: {', '.join(spec['allowed'])}")
+            if "min" in spec and "max" in spec:
+                desc.append(f"  取值范围: {spec['min']}~{spec['max']}")
+            docs.append("\n".join(desc))
+        return "\n\n".join(docs)

autocoder/common/conversation_pruner.py

@@ -0,0 +1,131 @@
+from typing import List, Dict, Any, Union
+import json
+from pydantic import BaseModel
+import byzerllm
+from autocoder.common.printer import Printer
+from autocoder.utils.llms import count_tokens
+from loguru import logger
+
+class PruneStrategy(BaseModel):
+    name: str
+    description: str
+    config: Dict[str, Any] = {"safe_zone_tokens": 0, "group_size": 4}
+
+class ConversationPruner:
+    def __init__(self, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM], 
+                 safe_zone_tokens: int = 500, group_size: int = 4):
+        self.llm = llm
+        self.printer = Printer()
+        self.strategies = {
+            "summarize": PruneStrategy(
+                name="summarize",
+                description="对早期对话进行分组摘要，保留关键信息",
+                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+            ),
+            "truncate": PruneStrategy(
+                name="truncate",
+                description="分组截断最早的部分对话",
+                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+            ),
+            "hybrid": PruneStrategy(
+                name="hybrid",
+                description="先尝试分组摘要，如果仍超限则分组截断",
+                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+            )
+        }
+
+    def get_available_strategies(self) -> List[Dict[str, Any]]:
+        """获取所有可用策略"""
+        return [strategy.dict() for strategy in self.strategies.values()]
+
+    def prune_conversations(self, conversations: List[Dict[str, Any]], 
+                            strategy_name: str = "summarize") -> List[Dict[str, Any]]:
+        """
+        根据策略修剪对话
+        Args:
+            conversations: 原始对话列表            
+            strategy_name: 策略名称
+        Returns:
+            修剪后的对话列表
+        """        
+        current_tokens = count_tokens(json.dumps(conversations, ensure_ascii=False))
+        if current_tokens <= self.args.conversation_prune_safe_zone_tokens:
+            return conversations
+
+        strategy = self.strategies.get(strategy_name, self.strategies["summarize"])
+        
+        if strategy.name == "summarize":
+            return self._summarize_prune(conversations, strategy.config)
+        elif strategy.name == "truncate":
+            return self._truncate_prune.with_llm(self.llm).run(conversations)
+        elif strategy.name == "hybrid":
+            pruned = self._summarize_prune(conversations, strategy.config)
+            if count_tokens(json.dumps(pruned, ensure_ascii=False)) > self.args.conversation_prune_safe_zone_tokens:
+                return self._truncate_prune(pruned)
+            return pruned
+        else:
+            logger.warning(f"Unknown strategy: {strategy_name}, using summarize instead")
+            return self._summarize_prune(conversations, strategy.config)
+
+    def _summarize_prune(self, conversations: List[Dict[str, Any]], 
+                         config: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """摘要式剪枝"""
+        safe_zone_tokens = config.get("safe_zone_tokens", 50*1024)
+        group_size = config.get("group_size", 4)
+        processed_conversations = conversations.copy()
+        
+        while True:
+            current_tokens = count_tokens(json.dumps(processed_conversations, ensure_ascii=False))
+            if current_tokens <= safe_zone_tokens:
+                break
+                
+            # 找到要处理的对话组
+            early_conversations = processed_conversations[:-group_size]
+            recent_conversations = processed_conversations[-group_size:]
+            
+            if not early_conversations:
+                break
+                
+            # 生成当前组的摘要
+            group_summary = self._generate_summary.with_llm(self.llm).run(early_conversations[-group_size:])
+            
+            # 更新对话历史
+            processed_conversations = early_conversations[:-group_size] + [
+                {"role": "user", "content": f"历史对话摘要：\n{group_summary}"},
+                {"role": "assistant", "content": f"收到"}
+            ] + recent_conversations
+            
+        return processed_conversations
+
+    @byzerllm.prompt()
+    def _generate_summary(self, conversations: List[Dict[str, Any]]) -> str:
+        '''
+        请用中文将以下对话浓缩为要点，保留关键决策和技术细节：
+        
+        <history_conversations>
+        {{conversations}}
+        </history_conversations>
+        '''    
+        return {
+            "conversations": json.dumps(conversations, ensure_ascii=False)
+        }    
+
+    def _truncate_prune(self, conversations: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """截断式剪枝"""
+        safe_zone_tokens = self.strategies["truncate"].config.get("safe_zone_tokens", 0)
+        group_size = self.strategies["truncate"].config.get("group_size", 4)
+        processed_conversations = conversations.copy()
+        
+        while True:
+            current_tokens = count_tokens(json.dumps(processed_conversations, ensure_ascii=False))
+            if current_tokens <= safe_zone_tokens:
+                break
+                
+            # 如果剩余对话不足一组，直接返回
+            if len(processed_conversations) <= group_size:
+                return []
+                
+            # 移除最早的一组对话
+            processed_conversations = processed_conversations[group_size:]
+            
+        return processed_conversations

autocoder/common/git_utils.py

@@ -1,7 +1,7 @@
 import os
 from git import Repo, GitCommandError
 from loguru import logger
-from typing import List, Optional
+from typing import List, Optional, Dict
 from pydantic import BaseModel
 import byzerllm
 from rich.console import Console
@@ -11,6 +11,16 @@ from rich.table import Table
 from rich.text import Text
 
 
+class FileChange(BaseModel):
+    file_path: str
+    before: Optional[str] = None
+    after: Optional[str] = None
+
+class CommitChangesResult(BaseModel):
+    success: bool
+    changes: Dict[str, FileChange] = {}
+    error_message: Optional[str] = None
+
 class CommitResult(BaseModel):
     success: bool
     commit_message: Optional[str] = None
@@ -605,6 +615,77 @@ def generate_commit_message(changes_report: str) -> str:
     请输出commit message, 不要输出任何其他内容.
     '''
 
+def get_commit_by_message(repo_path: str, message: str):
+    repo = get_repo(repo_path)
+    try:
+        commit_hash = repo.git.log("--all", f"--grep={message}", "--format=%H", "-n", "1")
+        if not commit_hash:
+            return None
+        return repo.commit(commit_hash.strip())
+    except GitCommandError as e:
+        logger.error(f"Error finding commit: {e}")
+        return None
+
+def get_changes_by_commit_message(repo_path: str, message: str) -> CommitChangesResult:
+    """
+    根据提交信息查找对应的变更内容
+    
+    Args:
+        repo_path: Git仓库路径
+        message: 提交信息
+        
+    Returns:
+        CommitChangesResult: 包含变更前后内容的字典，键为文件路径
+    """
+    try:
+        if repo_path:
+            repo = get_repo(repo_path)
+        else:
+            repo = get_repo(os.getcwd())
+        commit = get_commit_by_message(repo_path, message)
+        
+        if not commit:
+            return CommitChangesResult(success=False, error_message="Commit not found")
+
+        changes = {}
+        
+        # 比较当前commit与其父commit的差异
+        for diff_item in commit.parents[0].diff(commit):
+            file_path = diff_item.a_path if diff_item.a_path else diff_item.b_path
+            
+            # 获取变更前内容
+            before_content = None
+            try:
+                if diff_item.a_blob:
+                    before_content = repo.git.show(f"{commit.parents[0].hexsha}:{file_path}")
+            except GitCommandError:
+                pass  # 文件可能是新增的
+
+            # 获取变更后内容
+            after_content = None
+            try:
+                if diff_item.b_blob:
+                    after_content = repo.git.show(f"{commit.hexsha}:{file_path}")
+            except GitCommandError:
+                pass  # 文件可能被删除
+
+            changes[file_path] = FileChange(
+                file_path=file_path,
+                before=before_content,
+                after=after_content
+            )
+
+        return CommitChangesResult(success=True, changes=changes)
+
+    except GitCommandError as e:
+        logger.error(f"Error retrieving changes: {e}")
+        return CommitChangesResult(success=False, error_message=str(e))
+    except IndexError:
+        return CommitChangesResult(success=False, error_message="Initial commit has no parent")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        return CommitChangesResult(success=False, error_message=str(e))
+
 def print_commit_info(commit_result: CommitResult):
     console = Console()
     table = Table(

autocoder/common/index_import_export.py

@@ -0,0 +1,101 @@
+import os
+import json
+import shutil
+from loguru import logger
+from autocoder.common.printer import Printer
+
+
+def export_index(project_root: str, export_path: str) -> bool:
+    printer = Printer()
+    """
+    Export index.json with absolute paths converted to relative paths
+    
+    Args:
+        project_root: Project root directory
+        export_path: Path to export the index file
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        index_path = os.path.join(project_root, ".auto-coder", "index.json")
+        if not os.path.exists(index_path):
+            printer.print_in_terminal("index_not_found", path=index_path)
+            return False
+            
+        # Read and convert paths
+        with open(index_path, "r") as f:
+            index_data = json.load(f)
+            
+        # Convert absolute paths to relative
+        converted_data = {}
+        for abs_path, data in index_data.items():
+            try:
+                rel_path = os.path.relpath(abs_path, project_root)
+                data["module_name"] = rel_path
+                converted_data[rel_path] = data
+            except ValueError:
+                printer.print_in_terminal("index_convert_path_fail", path=abs_path)
+                converted_data[abs_path] = data
+        
+        # Write to export location
+        export_file = os.path.join(export_path, "index.json")
+        os.makedirs(export_path, exist_ok=True)
+        with open(export_file, "w") as f:
+            json.dump(converted_data, f, indent=2)
+            
+        return True
+        
+    except Exception as e:
+        printer.print_in_terminal("index_error", error=str(e))
+        return False
+
+def import_index(project_root: str, import_path: str) -> bool:
+    printer = Printer()
+    """
+    Import index.json with relative paths converted to absolute paths
+    
+    Args:
+        project_root: Project root directory
+        import_path: Path containing the index file to import
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        import_file = os.path.join(import_path, "index.json")
+        if not os.path.exists(import_file):
+            printer.print_in_terminal("index_not_found", path=import_file)
+            return False
+            
+        # Read and convert paths
+        with open(import_file, "r") as f:
+            index_data = json.load(f)
+            
+        # Convert relative paths to absolute
+        converted_data = {}
+        for rel_path, data in index_data.items():
+            try:
+                abs_path = os.path.join(project_root, rel_path)
+                data["module_name"] = abs_path
+                converted_data[abs_path] = data
+            except Exception:
+                printer.print_in_terminal("index_convert_path_fail", path=rel_path)
+                converted_data[rel_path] = data
+        
+        # Backup existing index
+        index_path = os.path.join(project_root, ".auto-coder", "index.json")
+        if os.path.exists(index_path):
+            backup_path = index_path + ".bak"
+            shutil.copy2(index_path, backup_path)
+            printer.print_in_terminal("index_backup_success", path=backup_path)
+            
+        # Write new index
+        with open(index_path, "w") as f:
+            json.dump(converted_data, f, indent=2)
+            
+        return True
+        
+    except Exception as e:
+        printer.print_in_terminal("index_error", error=str(e))
+        return False

autocoder/common/result_manager.py

@@ -0,0 +1,115 @@
+import os
+import json
+import time
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+class ResultItem(BaseModel):
+    """单条结果记录的数据模型"""
+    content: str = Field(..., description="结果内容")
+    meta: Dict[str, Any] = Field(default_factory=dict, description="元数据信息")
+    time: int = Field(default_factory=lambda: int(time.time()), description="记录时间戳")
+
+    class Config:
+        arbitrary_types_allowed = True
+
+class ResultManager:
+    """结果管理器，用于维护一个追加写入的jsonl文件"""
+    
+    def __init__(self, source_dir: Optional[str] = None):
+        """
+        初始化结果管理器
+        
+        Args:
+            source_dir: 可选的源目录，如果不提供则使用当前目录
+        """
+        self.source_dir = source_dir or os.getcwd()
+        self.result_dir = os.path.join(self.source_dir, ".auto-coder", "results")
+        self.result_file = os.path.join(self.result_dir, "results.jsonl")
+        os.makedirs(self.result_dir, exist_ok=True)
+
+    def append(self, content: str, meta: Optional[Dict[str, Any]] = None) -> ResultItem:
+        """
+        追加一条新的结果记录
+        
+        Args:
+            content: 结果内容
+            meta: 可选的元数据信息
+            
+        Returns:
+            ResultItem: 新创建的结果记录
+        """
+        result_item = ResultItem(
+            content=content,
+            meta=meta or {},
+        )
+        
+        with open(self.result_file, "a", encoding="utf-8") as f:
+            f.write(result_item.model_dump_json() + "\n")
+            
+        return result_item
+    
+    def add_result(self, content: str, meta: Optional[Dict[str, Any]] = None) -> ResultItem:
+        return self.append(content, meta)
+        
+    def get_last(self) -> Optional[ResultItem]:
+        """
+        获取最后一条记录
+        
+        Returns:
+            Optional[ResultItem]: 最后一条记录，如果文件为空则返回None
+        """
+        if not os.path.exists(self.result_file):
+            return None
+            
+        with open(self.result_file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            if not lines:
+                return None
+            last_line = lines[-1].strip()
+            return ResultItem.model_validate_json(last_line)
+
+    def get_all(self) -> List[ResultItem]:
+        """
+        获取所有记录
+        
+        Returns:
+            List[ResultItem]: 所有记录的列表
+        """
+        if not os.path.exists(self.result_file):
+            return []
+            
+        results = []
+        with open(self.result_file, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:  # 跳过空行
+                    results.append(ResultItem.model_validate_json(line))
+        return results
+
+    def get_by_time_range(self, 
+                         start_time: Optional[int] = None, 
+                         end_time: Optional[int] = None) -> List[ResultItem]:
+        """
+        获取指定时间范围内的记录
+        
+        Args:
+            start_time: 开始时间戳
+            end_time: 结束时间戳
+            
+        Returns:
+            List[ResultItem]: 符合时间范围的记录列表
+        """
+        results = []
+        for item in self.get_all():
+            if start_time and item.time < start_time:
+                continue
+            if end_time and item.time > end_time:
+                continue
+            results.append(item)
+        return results
+
+    def clear(self) -> None:
+        """清空所有记录"""
+        if os.path.exists(self.result_file):
+            os.remove(self.result_file)