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

autocoder/sdk/core/bridge.py

@@ -9,63 +9,78 @@ import sys
 from typing import Any, Dict, Optional, Iterator, Union
 from pathlib import Path
 import subprocess
+from contextlib import contextmanager
 
 from ..exceptions import BridgeError
 from ..models.responses import StreamEvent
-from autocoder.auto_coder_runner import run_auto_command,configure
+from autocoder.auto_coder_runner import run_auto_command, configure
 from ..models.options import AutoCodeOptions
 
 # 不导入事件类型，使用动态检查避免类型冲突
 
 
+@contextmanager
+def temporary_chdir(path: Union[str, Path]):
+    """临时切换工作目录的上下文管理器"""
+    original_cwd = os.getcwd()
+    try:
+        os.chdir(path)
+        yield
+    finally:
+        os.chdir(original_cwd)
+
+
 class AutoCoderBridge:
     """桥接层，连接现有功能"""
 
-    def __init__(self, project_root: str,options:AutoCodeOptions):
+    def __init__(self, project_root: str, options: AutoCodeOptions):
         """
         初始化桥接层
 
         Args:
             project_root: 项目根目录
+            options: 配置选项
         """
         self.project_root = project_root or os.getcwd()
-        self.options = options  
+        self.options = options
+        self.allow_chdir = True  # 默认允许切换目录，可以通过配置关闭
         self._setup_environment()
 
     def _setup_environment(self):
         """设置环境和内存"""
         try:
-            # 切换到项目根目录
-            original_cwd = os.getcwd()
-            os.chdir(self.project_root)
-
-            # 尝试初始化 auto_coder_runner 环境
-            try:
-                self.init_project_if_required()
-                from autocoder.auto_coder_runner import start                
-                start()
-            except ImportError:
-                # 如果无法导入，跳过初始化
-                pass
-
-            # 恢复原始工作目录
-            os.chdir(original_cwd)
+            # 使用上下文管理器临时切换到项目根目录
+            if self.allow_chdir:
+                with temporary_chdir(self.project_root):
+                    self._init_project_environment()
+            else:
+                # 不切换目录的情况下初始化
+                self._init_project_environment()
 
         except Exception as e:
             # 设置环境失败不应该阻止程序运行
             pass
 
+    def _init_project_environment(self):
+        """初始化项目环境"""
+        try:
+            self.init_project_if_required()
+            from autocoder.auto_coder_runner import start
+            start()
+        except ImportError:
+            # 如果无法导入，跳过初始化
+            pass
+
     def init_project_if_required(self):
-        if not os.path.exists(".auto-coder") or not os.path.exists("actions"):
-            subprocess.run(
-                ["auto-coder", "init", "--source_dir", "."], check=True
-            )        
+        from autocoder.auto_coder_runner import init_project_if_required as init_project_if_required_buildin
+        init_project_if_required_buildin(self.project_root, "*")
 
     def call_run_auto_command(
         self,
         query: str,
         pre_commit: bool = False,
         pr: bool = False,
+        cancel_token: Optional[str] = None,
         extra_args: Optional[Dict[str, Any]] = None,
         stream: bool = True
     ) -> Iterator[StreamEvent]:
@@ -76,6 +91,7 @@ class AutoCoderBridge:
             query: 查询内容
             pre_commit: 是否预提交
             pr: 是否预提交
+            cancel_token: 取消令牌，用于中断执行
             extra_args: 额外参数
             stream: 是否流式返回
 
@@ -86,50 +102,105 @@ class AutoCoderBridge:
             BridgeError: 桥接层错误
         """
         try:
-            # 切换到项目根目录
-            original_cwd = os.getcwd()
-            os.chdir(self.project_root)
-
             # 准备参数
             extra_args = extra_args or {}
 
+            # 根据会话配置确定 conversation_action 和 conversation_id
+            from autocoder.common.v2.agent.agentic_edit_types import ConversationAction
+            
+            conversation_action = ConversationAction.NEW  # 默认为新对话
+            conversation_id = None
+            
+            if self.options.session_id:
+                # 如果有 session_id，就是恢复特定会话
+                conversation_action = ConversationAction.RESUME
+                conversation_id = self.options.session_id
+            elif self.options.continue_session:
+                # 如果是 continue_session，就是继续最近的对话
+                conversation_action = ConversationAction.CONTINUE
+                conversation_id = None
+
             # 发送开始事件
             yield StreamEvent(
                 event_type="start",
-                data={"query": query, "pre_commit": pre_commit}
+                data={"query": query, "pre_commit": pre_commit,
+                      "cancel_token": cancel_token, "conversation_action": conversation_action.value,
+                      "conversation_id": conversation_id}
             )
-            
-            try:
-               
-                configure(f"model:{self.options.model}")
-                events = run_auto_command(
-                    query=query,
-                    pre_commit=pre_commit,
-                    pr=pr,
-                    extra_args=extra_args
-                )
 
-                # 如果返回的是生成器，逐个处理事件
-                if hasattr(events, '__iter__') and not isinstance(events, (str, bytes)):
-                    for event in events:
-                        # 转换事件格式
-                        stream_event = self._convert_event_to_stream_event(
-                            event)
-                        if stream_event:  # 只yield非None的事件
-                            yield stream_event
-                else:
-                    # 如果不是生成器，包装成单个事件
-                    yield StreamEvent(
-                        event_type="content",
-                        data={"content": str(events)}
-                    )
-
-            except (ImportError, FileNotFoundError, Exception) as e:
-                # import traceback
-                # traceback.print_exc()
-                # 如果无法导入或出现其他错误
-                raise BridgeError(
-                    f"run_auto_command failed: {str(e)}", original_error=e)
+            # 使用上下文管理器切换目录（如果允许）
+            context = temporary_chdir(
+                self.project_root) if self.allow_chdir else _nullcontext()
+
+            with context:
+                try:
+                    # 实现循环逻辑
+                    loop_count = self.options.loop
+                    
+                    for loop_index in range(loop_count):
+                        # 第一次使用原始查询，后续循环使用改进的查询
+                        current_query = query
+                        if loop_index > 0:
+                            # 使用自定义的额外提示或默认提示
+                            if self.options.loop_additional_prompt:
+                                additional_prompt = self.options.loop_additional_prompt
+                            else:
+                                additional_prompt = "use git log to get the code changes generated by previous tasks and try to focus on iterative improvements and refinements. Ensure the implementation is complete, functional, and fully usable without any missing features or incomplete functionality. Make sure to use git commit command to make a commit after every single file edit."
+                            current_query = f"{query}\n\nAdditional instruction: {additional_prompt}"
+                        
+                        # 发送循环开始事件
+                        if loop_count > 1:
+                            yield StreamEvent(
+                                event_type="loop_start",
+                                data={"content": f"{loop_index + 1}/{loop_count}"}
+                            )
+                        
+                        # 对于循环执行，根据loop_keep_conversation参数决定是否使用CONTINUE模式
+                        current_conversation_action = conversation_action
+                        current_conversation_id = conversation_id
+                        if loop_index > 0 and self.options.loop_keep_conversation:
+                            from autocoder.common.v2.agent.agentic_edit_types import ConversationAction
+                            current_conversation_action = ConversationAction.CONTINUE
+                            current_conversation_id = None
+                        
+                        events = run_auto_command(
+                            query=current_query,
+                            pre_commit=pre_commit,
+                            pr=pr and (loop_index == loop_count - 1),  # 只在最后一次循环时创建PR
+                            cancel_token=cancel_token,
+                            extra_args={
+                                **extra_args, "max_turns": self.options.max_turns, "model": self.options.model, "include_rules": self.options.include_rules},
+                            system_prompt=self.options.system_prompt,
+                            conversation_action=current_conversation_action,
+                            conversation_id=current_conversation_id,
+                            is_sub_agent=self.options.is_sub_agent
+                        )
+
+                        # 如果返回的是生成器，逐个处理事件
+                        if hasattr(events, '__iter__') and not isinstance(events, (str, bytes)):
+                            for event in events:
+                                # 转换事件格式
+                                stream_event = self._convert_event_to_stream_event(
+                                    event)
+                                if stream_event:  # 只yield非None的事件
+                                    yield stream_event
+                        else:
+                            # 如果不是生成器，包装成单个事件
+                            yield StreamEvent(
+                                event_type="content",
+                                data={"content": str(events)}
+                            )
+                        
+                        # 发送循环完成事件
+                        if loop_count > 1:
+                            yield StreamEvent(
+                                event_type="loop_end",
+                                data={"content": f"{loop_index + 1}/{loop_count}"}
+                            )
+
+                except (ImportError, FileNotFoundError, Exception) as e:
+                    raise BridgeError(
+                        f"run_auto_command failed: {str(e)}", original_error=e)
 
             # 发送完成事件
             yield StreamEvent(
@@ -145,9 +216,6 @@ class AutoCoderBridge:
             )
             raise BridgeError(
                 f"run_auto_command failed: {str(e)}", original_error=e)
-        finally:
-            # 恢复原始工作目录
-            os.chdir(original_cwd)
 
     def _simulate_auto_command_response(self, query: str) -> Iterator[StreamEvent]:
         """
@@ -324,9 +392,22 @@ class AutoCoderBridge:
                 )
 
             elif event_class_name == "TokenUsageEvent":
+                usage = getattr(event, 'usage', None)
+                if usage:
+                    # 序列化 SingleOutputMeta 对象
+                    usage_data = {
+                        "input_tokens_count": getattr(usage, 'input_tokens_count', 0),
+                        "generated_tokens_count": getattr(usage, 'generated_tokens_count', 0),
+                        "reasoning_content": getattr(usage, 'reasoning_content', ''),
+                        "finish_reason": getattr(usage, 'finish_reason', 'stop'),
+                        "first_token_time": getattr(usage, 'first_token_time', 0)
+                    }
+                else:
+                    usage_data = {}
+
                 return StreamEvent(
                     event_type="token_usage",
-                    data={"usage": getattr(event, 'usage', {})}
+                    data={"usage": usage_data}
                 )
 
             elif event_class_name == "WindowLengthChangeEvent":
@@ -342,6 +423,64 @@ class AutoCoderBridge:
                         event, 'conversation_id', '')}
                 )
 
+            elif event_class_name == "PreCommitEvent":
+                # event.commit_result 和 event.tpe 一定存在
+                commit_result = event.commit_result
+                commit_data = {
+                    "success": commit_result.success if hasattr(commit_result, 'success') else False,
+                    "message": commit_result.message if hasattr(commit_result, 'message') else '',
+                    "commit_hash": commit_result.commit_hash if hasattr(commit_result, 'commit_hash') else '',
+                    "files_changed": commit_result.files_changed if hasattr(commit_result, 'files_changed') else [],
+                    "error": commit_result.error if hasattr(commit_result, 'error') else None
+                }
+
+                return StreamEvent(
+                    event_type="pre_commit",
+                    data={
+                        "commit_result": commit_data,
+                        "tpe": event.tpe
+                    }
+                )
+
+            elif event_class_name == "CommitEvent":
+                # event.commit_result 和 event.tpe 一定存在
+                commit_result = event.commit_result
+                commit_data = {
+                    "success": commit_result.success if hasattr(commit_result, 'success') else False,
+                    "message": commit_result.message if hasattr(commit_result, 'message') else '',
+                    "commit_hash": commit_result.commit_hash if hasattr(commit_result, 'commit_hash') else '',
+                    "files_changed": commit_result.files_changed if hasattr(commit_result, 'files_changed') else [],
+                    "error": commit_result.error if hasattr(commit_result, 'error') else None
+                }
+
+                return StreamEvent(
+                    event_type="commit",
+                    data={
+                        "commit_result": commit_data,
+                        "tpe": event.tpe
+                    }
+                )
+
+            elif event_class_name == "PullRequestEvent":
+                # event.pull_request_result 一定存在
+                pr_result = event.pull_request_result
+                pr_data = {
+                    "success": pr_result.success if hasattr(pr_result, 'success') else False,
+                    "pr_number": pr_result.pr_number if hasattr(pr_result, 'pr_number') else None,
+                    "pr_url": pr_result.pr_url if hasattr(pr_result, 'pr_url') else '',
+                    "pr_id": pr_result.pr_id if hasattr(pr_result, 'pr_id') else None,
+                    "error_message": pr_result.error_message if hasattr(pr_result, 'error_message') else None,
+                    "error_code": pr_result.error_code if hasattr(pr_result, 'error_code') else None,
+                    "platform": pr_result.platform if hasattr(pr_result, 'platform') else None,
+                    "raw_response": pr_result.raw_response if hasattr(pr_result, 'raw_response') else None,
+                    "retry_after": pr_result.retry_after if hasattr(pr_result, 'retry_after') else None
+                }
+
+                return StreamEvent(
+                    event_type="pull_request",
+                    data={"pull_request_result": pr_data}
+                )
+
             elif event_class_name == "PlanModeRespondEvent":
                 result = ""
                 if hasattr(event, 'completion'):
@@ -390,27 +529,29 @@ class AutoCoderBridge:
             Dict[str, Any]: 内存数据
         """
         try:
-            original_cwd = os.getcwd()
-            os.chdir(self.project_root)
-
-            try:
-                from autocoder.auto_coder_runner import get_memory
-                memory_data = get_memory()
-                return memory_data
-            except ImportError:
-                # 模拟内存数据
-                return {
-                    "current_files": {"files": [], "groups": {}},
-                    "conf": {},
-                    "exclude_dirs": [],
-                    "mode": "auto_detect"
-                }
-
+            if self.allow_chdir:
+                with temporary_chdir(self.project_root):
+                    return self._get_memory_internal()
+            else:
+                return self._get_memory_internal()
         except Exception as e:
             raise BridgeError(
                 f"Failed to get memory: {str(e)}", original_error=e)
-        finally:
-            os.chdir(original_cwd)
+
+    def _get_memory_internal(self) -> Dict[str, Any]:
+        """内部获取内存实现"""
+        try:
+            from autocoder.auto_coder_runner import get_memory
+            memory_data = get_memory()
+            return memory_data
+        except ImportError:
+            # 模拟内存数据
+            return {
+                "current_files": {"files": [], "groups": {}},
+                "conf": {},
+                "exclude_dirs": [],
+                "mode": "auto_detect"
+            }
 
     def save_memory(self, memory_data: Dict[str, Any]) -> None:
         """
@@ -420,23 +561,25 @@ class AutoCoderBridge:
             memory_data: 要保存的内存数据
         """
         try:
-            original_cwd = os.getcwd()
-            os.chdir(self.project_root)
-
-            try:
-                from autocoder.auto_coder_runner import save_memory, memory
-                # 更新全局 memory 变量
-                memory.update(memory_data)
-                save_memory()
-            except ImportError:
-                # 模拟保存
-                pass
-
+            if self.allow_chdir:
+                with temporary_chdir(self.project_root):
+                    self._save_memory_internal(memory_data)
+            else:
+                self._save_memory_internal(memory_data)
         except Exception as e:
             raise BridgeError(
                 f"Failed to save memory: {str(e)}", original_error=e)
-        finally:
-            os.chdir(original_cwd)
+
+    def _save_memory_internal(self, memory_data: Dict[str, Any]) -> None:
+        """内部保存内存实现"""
+        try:
+            from autocoder.auto_coder_runner import save_memory, memory
+            # 更新全局 memory 变量
+            memory.update(memory_data)
+            save_memory()
+        except ImportError:
+            # 模拟保存
+            pass
 
     def get_project_config(self) -> Dict[str, Any]:
         """
@@ -446,22 +589,24 @@ class AutoCoderBridge:
             Dict[str, Any]: 项目配置
         """
         try:
-            original_cwd = os.getcwd()
-            os.chdir(self.project_root)
-
-            try:
-                from autocoder.auto_coder_runner import get_final_config
-                config = get_final_config()
-                return config.__dict__ if hasattr(config, '__dict__') else {}
-            except ImportError:
-                # 模拟配置
-                return {"mock_config": True}
-
+            if self.allow_chdir:
+                with temporary_chdir(self.project_root):
+                    return self._get_project_config_internal()
+            else:
+                return self._get_project_config_internal()
         except Exception as e:
             raise BridgeError(
                 f"Failed to get project config: {str(e)}", original_error=e)
-        finally:
-            os.chdir(original_cwd)
+
+    def _get_project_config_internal(self) -> Dict[str, Any]:
+        """内部获取配置实现"""
+        try:
+            from autocoder.auto_coder_runner import get_final_config
+            config = get_final_config()
+            return config.__dict__ if hasattr(config, '__dict__') else {}
+        except ImportError:
+            # 模拟配置
+            return {"mock_config": True}
 
     def setup_project_context(self) -> None:
         """设置项目上下文"""
@@ -475,20 +620,45 @@ class AutoCoderBridge:
     def cleanup(self) -> None:
         """清理资源"""
         try:
-            original_cwd = os.getcwd()
-            os.chdir(self.project_root)
-
-            try:
-                from autocoder.auto_coder_runner import stop
-                stop()
-            except ImportError:
-                pass
-
+            if self.allow_chdir:
+                with temporary_chdir(self.project_root):
+                    self._cleanup_internal()
+            else:
+                self._cleanup_internal()
         except Exception as e:
             # 清理失败不应该阻止程序继续运行，只记录错误
             print(f"Warning: Failed to cleanup resources: {str(e)}")
-        finally:
-            os.chdir(original_cwd)
+
+    def _cleanup_internal(self) -> None:
+        """内部清理实现"""
+        try:
+            from autocoder.auto_coder_runner import stop
+            stop()
+        except ImportError:
+            pass
+
+    def configure_agentic_max_rounds(self, max_rounds: int = 10000) -> None:
+        """
+        配置代理最大轮数
+
+        Args:
+            max_rounds: 最大轮数，默认为10000
+        """
+        try:
+            configure(f"agentic_max_rounds:{max_rounds}", skip_print=True)
+        except Exception as e:
+            raise BridgeError(
+                f"Failed to configure agentic max rounds: {str(e)}", original_error=e)
+
+    def configure_model(self, model_name: str) -> None:
+        """
+        配置模型
+        """
+        try:
+            configure(f"model:{model_name}", skip_print=True)
+        except Exception as e:
+            raise BridgeError(
+                f"Failed to configure model '{model_name}': {str(e)}", original_error=e)
 
     def __enter__(self):
         """上下文管理器入口"""
@@ -498,3 +668,13 @@ class AutoCoderBridge:
     def __exit__(self, exc_type, exc_val, exc_tb):
         """上下文管理器出口"""
         self.cleanup()
+
+
+class _nullcontext:
+    """Python 3.7 兼容的 nullcontext"""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        return False

autocoder/sdk/exceptions.py

@@ -5,16 +5,18 @@ Auto-Coder SDK 异常定义
 定义所有自定义异常类，提供错误码和异常的映射关系，统一异常处理策略。
 """
 
+from autocoder.common.international import get_message_with_format
+
 class AutoCoderSDKError(Exception):
     """SDK基础异常类"""
     
-    def __init__(self, message: str, error_code: str = None):
+    def __init__(self, message: str, error_code: str = "SDK_ERROR"):
         super().__init__(message)
         self.message = message
-        self.error_code = error_code or "SDK_ERROR"
+        self.error_code = error_code
     
     def __str__(self):
-        return f"[{self.error_code}] {self.message}"
+        return get_message_with_format("sdk_error_with_code", error_code=self.error_code, message=self.message)
 
 
 class SessionNotFoundError(AutoCoderSDKError):
@@ -22,7 +24,7 @@ class SessionNotFoundError(AutoCoderSDKError):
     
     def __init__(self, session_id: str):
         super().__init__(
-            f"Session '{session_id}' not found",
+            get_message_with_format("session_not_found", session_id=session_id),
             error_code="SESSION_NOT_FOUND"
         )
         self.session_id = session_id
@@ -33,7 +35,7 @@ class InvalidOptionsError(AutoCoderSDKError):
     
     def __init__(self, message: str):
         super().__init__(
-            f"Invalid options: {message}",
+            get_message_with_format("invalid_options", message=message),
             error_code="INVALID_OPTIONS"
         )
 
@@ -41,11 +43,15 @@ class InvalidOptionsError(AutoCoderSDKError):
 class BridgeError(AutoCoderSDKError):
     """桥接层异常"""
     
-    def __init__(self, message: str, original_error: Exception = None):
-        super().__init__(
-            f"Bridge error: {message}",
-            error_code="BRIDGE_ERROR"
-        )
+    def __init__(self, message: str, original_error: Exception | None = None):
+        if original_error:
+            formatted_message = get_message_with_format("bridge_error_with_original", 
+                                                       message=message, 
+                                                       original_error=str(original_error))
+        else:
+            formatted_message = get_message_with_format("bridge_error", message=message)
+        
+        super().__init__(formatted_message, error_code="BRIDGE_ERROR")
         self.original_error = original_error
 
 
@@ -54,7 +60,7 @@ class CLIError(AutoCoderSDKError):
     
     def __init__(self, message: str, exit_code: int = 1):
         super().__init__(
-            f"CLI error: {message}",
+            get_message_with_format("cli_error", message=message),
             error_code="CLI_ERROR"
         )
         self.exit_code = exit_code
@@ -65,7 +71,7 @@ class ValidationError(AutoCoderSDKError):
     
     def __init__(self, field: str, message: str):
         super().__init__(
-            f"Validation error for '{field}': {message}",
+            get_message_with_format("validation_error_field", field=field, message=message),
             error_code="VALIDATION_ERROR"
         )
         self.field = field

autocoder/sdk/formatters/__init__.py

@@ -0,0 +1,19 @@
+"""
+Auto-Coder SDK 格式化模块
+
+统一提供各种输入输出格式化功能。
+"""
+
+from .output import OutputFormatter, format_output, format_table_output, format_error_output, format_progress_output
+from .input import InputFormatter
+from .stream import format_stream_output
+
+__all__ = [
+    "OutputFormatter",
+    "InputFormatter", 
+    "format_output",
+    "format_stream_output",
+    "format_table_output",
+    "format_error_output",
+    "format_progress_output",
+]