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

autocoder/sdk/formatters/input.py

@@ -0,0 +1,64 @@
+"""
+输入格式化器模块
+
+提供输入内容的格式化功能。
+"""
+
+import json
+from typing import Dict, Any, AsyncIterator
+
+
+class InputFormatter:
+    """输入格式化器，处理不同格式的输入。"""
+    
+    def format_text(self, content: str) -> str:
+        """
+        格式化文本输入。
+        
+        Args:
+            content: 输入文本
+            
+        Returns:
+            格式化后的文本
+        """
+        return content.strip()
+    
+    def format_json(self, content: str) -> Dict[str, Any]:
+        """
+        格式化JSON输入。
+        
+        Args:
+            content: JSON格式的输入字符串
+            
+        Returns:
+            解析后的字典
+            
+        Raises:
+            ValueError: 如果输入不是有效的JSON
+        """
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"无效的JSON输入: {str(e)}")
+    
+    async def format_stream_json(self, content: str) -> AsyncIterator[Dict[str, Any]]:
+        """
+        格式化流式JSON输入。
+        
+        Args:
+            content: 包含多行JSON对象的字符串
+            
+        Yields:
+            解析后的字典
+            
+        Raises:
+            ValueError: 如果某行不是有效的JSON
+        """
+        for line in content.strip().split("\n"):
+            if not line.strip():
+                continue
+                
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"无效的JSON行: {line}, 错误: {str(e)}") 

autocoder/sdk/formatters/output.py

@@ -0,0 +1,247 @@
+"""
+输出格式化器模块
+
+提供统一的输出格式化功能。
+"""
+
+import json
+from typing import Any, Dict, Union, List, Optional
+
+
+class OutputFormatter:
+    """输出格式化器，处理不同格式的输出。"""
+    
+    def __init__(self, verbose: bool = False):
+        """
+        初始化输出格式化器。
+        
+        Args:
+            verbose: 是否输出详细信息
+        """
+        self.verbose = verbose
+    
+    def format_text(self, content: Union[str, Dict[str, Any]]) -> str:
+        """
+        格式化为文本输出。
+        
+        Args:
+            content: 要格式化的内容，可以是字符串或字典
+            
+        Returns:
+            格式化后的文本
+        """
+        if isinstance(content, dict):
+            # 如果是字典，提取主要内容
+            if "content" in content:
+                result = content["content"]
+            else:
+                result = str(content)
+        else:
+            result = str(content)
+            
+        if self.verbose:
+            # 在详细模式下添加调试信息
+            debug_info = self._get_debug_info(content)
+            if debug_info:
+                result += f"\n\n[DEBUG]\n{debug_info}"
+                
+        return result
+    
+    def format_json(self, content: Any) -> str:
+        """
+        格式化为JSON输出。
+        
+        Args:
+            content: 要格式化的内容
+            
+        Returns:
+            JSON格式的字符串
+        """
+        # 确保内容可以被序列化为JSON
+        if isinstance(content, str):
+            try:
+                # 尝试解析为JSON
+                parsed = json.loads(content)
+                content = parsed
+            except json.JSONDecodeError:
+                # 如果不是有效的JSON，则包装为字典
+                content = {"content": content}
+        
+        # 添加调试信息（如果启用详细模式）
+        if self.verbose and isinstance(content, dict):
+            content["debug"] = self._get_debug_info_dict(content)
+            
+        return json.dumps(content, ensure_ascii=False, indent=2)
+    
+    def _get_debug_info(self, content: Any) -> str:
+        """
+        获取调试信息的文本表示。
+        
+        Args:
+            content: 内容对象
+            
+        Returns:
+            调试信息文本
+        """
+        debug_dict = self._get_debug_info_dict(content)
+        if debug_dict:
+            return json.dumps(debug_dict, ensure_ascii=False, indent=2)
+        return ""
+    
+    def _get_debug_info_dict(self, content: Any) -> Dict[str, Any]:
+        """
+        获取调试信息的字典表示。
+        
+        Args:
+            content: 内容对象
+            
+        Returns:
+            调试信息字典
+        """
+        debug_info = {}
+        
+        # 从内容中提取元数据
+        if isinstance(content, dict):
+            if "metadata" in content:
+                debug_info["metadata"] = content["metadata"]
+            
+            # 提取令牌计数信息
+            if "tokens" in content:
+                debug_info["tokens"] = content["tokens"]
+            elif "metadata" in content and "tokens" in content["metadata"]:
+                debug_info["tokens"] = content["metadata"]["tokens"]
+                
+            # 提取模型信息
+            if "model" in content:
+                debug_info["model"] = content["model"]
+            elif "metadata" in content and "model" in content["metadata"]:
+                debug_info["model"] = content["metadata"]["model"]
+                
+            # 提取时间信息
+            if "timestamp" in content:
+                debug_info["timestamp"] = content["timestamp"]
+            elif "metadata" in content and "timestamp" in content["metadata"]:
+                debug_info["timestamp"] = content["metadata"]["timestamp"]
+        
+        return debug_info
+
+
+def format_output(content: Any, output_format: str = "text") -> str:
+    """
+    格式化输出内容
+    
+    Args:
+        content: 要格式化的内容
+        output_format: 输出格式 (text, json)
+        
+    Returns:
+        str: 格式化后的内容
+    """
+    formatter = OutputFormatter()
+    
+    if output_format == "json":
+        return formatter.format_json(content)
+    else:
+        return formatter.format_text(content)
+
+
+def format_table_output(data: List[Any], headers: Optional[List[str]] = None) -> str:
+    """
+    格式化表格输出
+    
+    Args:
+        data: 表格数据
+        headers: 表头
+        
+    Returns:
+        str: 格式化的表格
+    """
+    if not data:
+        return "No data to display"
+    
+    if headers is None:
+        if isinstance(data[0], dict):
+            headers = list(data[0].keys())
+        else:
+            headers = [f"Column {i+1}" for i in range(len(data[0]) if data[0] else 0)]
+    
+    # 计算列宽
+    col_widths = []
+    for i, header in enumerate(headers):
+        max_width = len(header)
+        for row in data:
+            if isinstance(row, dict):
+                cell_value = str(row.get(header, ""))
+            elif isinstance(row, (list, tuple)) and i < len(row):
+                cell_value = str(row[i])
+            else:
+                cell_value = ""
+            max_width = max(max_width, len(cell_value))
+        col_widths.append(max_width + 2)  # 添加padding
+    
+    # 构建表格
+    lines = []
+    
+    # 表头
+    header_line = "|".join(header.center(col_widths[i]) for i, header in enumerate(headers))
+    lines.append(header_line)
+    
+    # 分隔线
+    separator = "|".join("-" * width for width in col_widths)
+    lines.append(separator)
+    
+    # 数据行
+    for row in data:
+        if isinstance(row, dict):
+            row_values = [str(row.get(header, "")) for header in headers]
+        elif isinstance(row, (list, tuple)):
+            row_values = [str(row[i]) if i < len(row) else "" for i in range(len(headers))]
+        else:
+            row_values = [str(row)]
+        
+        row_line = "|".join(value.ljust(col_widths[i]) for i, value in enumerate(row_values))
+        lines.append(row_line)
+    
+    return "\n".join(lines)
+
+
+def format_error_output(error: Exception, verbose: bool = False) -> str:
+    """
+    格式化错误输出
+    
+    Args:
+        error: 异常对象
+        verbose: 是否显示详细信息
+        
+    Returns:
+        str: 格式化的错误信息
+    """
+    if verbose:
+        import traceback
+        return f"Error: {str(error)}\n\nTraceback:\n{traceback.format_exc()}"
+    else:
+        return f"Error: {str(error)}"
+
+
+def format_progress_output(current: int, total: int, description: str = "") -> str:
+    """
+    格式化进度输出
+    
+    Args:
+        current: 当前进度
+        total: 总数
+        description: 描述
+        
+    Returns:
+        str: 格式化的进度信息
+    """
+    if total == 0:
+        percentage = 100
+    else:
+        percentage = min(100, int((current / total) * 100))
+    
+    bar_length = 30
+    filled_length = int(bar_length * percentage // 100)
+    bar = "█" * filled_length + "-" * (bar_length - filled_length)
+    
+    return f"{description} [{bar}] {percentage}% ({current}/{total})" 

autocoder/sdk/formatters/stream.py

@@ -0,0 +1,54 @@
+"""
+流式输出格式化模块
+
+提供流式输出的格式化功能。
+"""
+
+import json
+from typing import AsyncIterator, Any
+
+from ..models.responses import StreamEvent
+
+
+async def format_stream_output(stream: AsyncIterator[Any], output_format: str = "stream-json") -> AsyncIterator[str]:
+    """
+    格式化流式输出
+    
+    Args:
+        stream: 输入流
+        output_format: 输出格式
+        
+    Yields:
+        str: 格式化后的内容
+    """
+    if output_format == "stream-json":
+        # 发送开始事件
+        start_event = StreamEvent.start_event()
+        yield start_event.to_json()
+        
+        try:
+            async for item in stream:
+                if isinstance(item, StreamEvent):
+                    # 直接输出 StreamEvent
+                    yield item.to_json()
+                elif hasattr(item, 'to_dict'):
+                    # 直接输出有to_dict方法的对象
+                    yield json.dumps(item.to_dict(), ensure_ascii=False)
+                else:
+                    # 包装普通内容为content事件
+                    content_event = StreamEvent.content_event(str(item))
+                    yield content_event.to_json()
+            
+            # 发送结束事件
+            end_event = StreamEvent.end_event()
+            yield end_event.to_json()
+            
+        except Exception as e:
+            # 发送错误事件
+            error_event = StreamEvent.error_event(str(e))
+            yield error_event.to_json()
+    else:
+        # 其他格式，直接输出
+        from .output import format_output
+        async for item in stream:
+            yield format_output(item, "text") 

autocoder/sdk/models/__init__.py

@@ -3,17 +3,18 @@
 """
 Auto-Coder SDK 数据模型
 
-包含所有数据结构定义，提供类型安全的接口。
+定义SDK中使用的各种数据模型。
 """
 
 from .options import AutoCodeOptions
-from .messages import Message
-from .responses import CLIResult, SessionInfo
+from .responses import StreamEvent, CLIResult, SessionInfo, QueryResult, CodeModificationResult
 
 __all__ = [
     "AutoCodeOptions",
-    "Message", 
+    "StreamEvent",
     "CLIResult",
-    "SessionInfo"
+    "SessionInfo",
+    "QueryResult",
+    "CodeModificationResult"
 ]
 

autocoder/sdk/models/options.py

@@ -21,6 +21,7 @@ from ..constants import (
     ALLOWED_TOOLS
 )
 from ..exceptions import ValidationError
+from autocoder.common.international import get_message_with_format
 
 
 @dataclass
@@ -30,6 +31,7 @@ class AutoCodeOptions:
     # 基础配置
     max_turns: int = DEFAULT_MAX_TURNS
     system_prompt: Optional[str] = None
+    system_prompt_path: Optional[str] = None
     cwd: Optional[Union[str, Path]] = None
     
     # 工具和权限配置
@@ -52,7 +54,14 @@ class AutoCodeOptions:
     timeout: int = 30
     verbose: bool = False
     include_project_structure: bool = True
+    include_rules: bool = False  # 是否包含规则文件
     pr: bool = False  # 是否创建 PR
+    cancel_token: Optional[str] = None  # 取消令牌
+    is_sub_agent: bool = False  # 是否为子代理模式，避免conversation冲突
+    loop: int = 1  # 循环执行次数，默认为1
+    loop_keep_conversation: bool = False  # 循环时是否保持对话连续性
+    loop_additional_prompt: Optional[str] = None  # 循环时的额外提示，可自定义
+    include_libs: List[str] = field(default_factory=list)  # 要包含的LLM friendly packages列表
     
     def __post_init__(self):
         """初始化后验证"""
@@ -60,27 +69,22 @@ class AutoCodeOptions:
         self.validate()
     
     def validate(self) -> None:
-        """验证配置选项"""
-        
-        # 验证max_turns（-1表示不限制）
-        if self.max_turns <= 0 and self.max_turns != -1:
-            raise ValidationError("max_turns", "must be positive integer or -1 (unlimited)")
-        
-        if self.max_turns > 100 and self.max_turns != -1:
-            raise ValidationError("max_turns", "cannot exceed 100 (unless -1 for unlimited)")
-        
+        """验证配置选项"""               
         # 验证output_format
         if self.output_format not in OUTPUT_FORMATS:
             raise ValidationError(
                 "output_format", 
-                f"must be one of: {', '.join(OUTPUT_FORMATS.keys())}"
+                get_message_with_format("validation_output_format_invalid", valid_formats=', '.join(OUTPUT_FORMATS.keys()))
             )
         
+        # stream-json 格式建议开启verbose以获得实时输出
+        # 但不强制要求，JSON格式可以在非verbose模式下正常工作
+        
         # 验证permission_mode
         if self.permission_mode not in PERMISSION_MODES:
             raise ValidationError(
                 "permission_mode",
-                f"must be one of: {', '.join(PERMISSION_MODES.keys())}"
+                get_message_with_format("validation_permission_mode_invalid", valid_modes=', '.join(PERMISSION_MODES.keys()))
             )
         
         # 验证allowed_tools
@@ -89,25 +93,42 @@ class AutoCodeOptions:
             if invalid_tools:
                 raise ValidationError(
                     "allowed_tools",
-                    f"invalid tools: {', '.join(invalid_tools)}. "
-                    f"Valid tools: {', '.join(ALLOWED_TOOLS)}"
+                    get_message_with_format("validation_allowed_tools_invalid", 
+                                          invalid_tools=', '.join(invalid_tools),
+                                          valid_tools=', '.join(ALLOWED_TOOLS))
                 )
         
         # 验证temperature
         if not 0.0 <= self.temperature <= 2.0:
-            raise ValidationError("temperature", "must be between 0.0 and 2.0")
+            raise ValidationError("temperature", get_message_with_format("validation_temperature_range"))
         
         # 验证timeout
         if self.timeout <= 0:
-            raise ValidationError("timeout", "must be positive integer")
+            raise ValidationError("timeout", get_message_with_format("validation_timeout_positive"))
+        
+        # 验证循环次数
+        if self.loop <= 0:
+            raise ValidationError("loop", f"Loop count must be positive, got {self.loop}")
         
         # 验证cwd
         if self.cwd is not None:
             cwd_path = Path(self.cwd)
             if not cwd_path.exists():
-                raise ValidationError("cwd", f"directory does not exist: {self.cwd}")
+                raise ValidationError("cwd", get_message_with_format("validation_cwd_not_exist", path=self.cwd))
             if not cwd_path.is_dir():
-                raise ValidationError("cwd", f"path is not a directory: {self.cwd}")
+                raise ValidationError("cwd", get_message_with_format("validation_cwd_not_directory", path=self.cwd))
+        
+        # 验证 system_prompt 和 system_prompt_path 的互斥性
+        if self.system_prompt and self.system_prompt_path:
+            raise ValidationError("system_prompt", "只能配置 system_prompt 或 system_prompt_path 中的一个，不能同时配置两个")
+        
+        # 验证 system_prompt_path 文件存在性
+        if self.system_prompt_path is not None:
+            prompt_path = Path(self.system_prompt_path)
+            if not prompt_path.exists():
+                raise ValidationError("system_prompt_path", f"系统提示文件不存在: {self.system_prompt_path}")
+            if not prompt_path.is_file():
+                raise ValidationError("system_prompt_path", f"系统提示路径不是文件: {self.system_prompt_path}")
     
     def _normalize_values(self) -> None:
         """标准化配置值"""
@@ -131,6 +152,7 @@ class AutoCodeOptions:
         return {
             "max_turns": self.max_turns,
             "system_prompt": self.system_prompt,
+            "system_prompt_path": self.system_prompt_path,
             "cwd": self.cwd,
             "allowed_tools": self.allowed_tools,
             "permission_mode": self.permission_mode,
@@ -142,7 +164,14 @@ class AutoCodeOptions:
             "timeout": self.timeout,
             "verbose": self.verbose,
             "include_project_structure": self.include_project_structure,
-            "pr": self.pr
+            "include_rules": self.include_rules,
+            "pr": self.pr,
+            "cancel_token": self.cancel_token,
+            "is_sub_agent": self.is_sub_agent,
+            "loop": self.loop,
+            "loop_keep_conversation": self.loop_keep_conversation,
+            "loop_additional_prompt": self.loop_additional_prompt,
+            "include_libs": self.include_libs
         }
     
     @classmethod
@@ -170,6 +199,8 @@ class AutoCodeOptions:
             data["max_turns"] = other.max_turns
         if other.system_prompt is not None:
             data["system_prompt"] = other.system_prompt
+        if other.system_prompt_path is not None:
+            data["system_prompt_path"] = other.system_prompt_path
         if other.output_format != DEFAULT_OUTPUT_FORMAT:
             data["output_format"] = other.output_format
         if other.permission_mode != DEFAULT_PERMISSION_MODE:
@@ -186,10 +217,16 @@ class AutoCodeOptions:
             data["stream"] = other.stream
         if other.include_project_structure is not True:
             data["include_project_structure"] = other.include_project_structure
+        if other.include_rules is not False:
+            data["include_rules"] = other.include_rules
         if other.session_id is not None:
             data["session_id"] = other.session_id
         if other.allowed_tools != []:
             data["allowed_tools"] = other.allowed_tools
+        if other.cancel_token is not None:
+            data["cancel_token"] = other.cancel_token
+        if other.is_sub_agent is not False:
+            data["is_sub_agent"] = other.is_sub_agent
         
         return self.from_dict(data)