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

autocoder/common/v2/agent/runner/file_based_event_runner.py

@@ -0,0 +1,217 @@
+
+"""
+FileBasedEventRunner 提供将代理事件转换为标准事件系统格式的功能。
+
+这个模块负责将内部代理事件转换为标准事件系统格式，并通过事件管理器写入。
+它支持流式处理事件和结果事件的写入。
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from autocoder.common.v2.agent.agentic_edit_types import (
+    AgenticEditRequest, AgentEvent, CompletionEvent,
+    LLMOutputEvent, LLMThinkingEvent, ToolCallEvent,
+    ToolResultEvent, TokenUsageEvent, ErrorEvent,PlanModeRespondEvent,
+    WindowLengthChangeEvent,ConversationIdEvent
+)
+from autocoder.events.event_manager_singleton import get_event_manager
+from autocoder.events.event_types import EventMetadata
+from autocoder.events import event_content as EventContentCreator
+from byzerllm.utils.types import SingleOutputMeta
+from .base_runner import BaseRunner
+
+logger = logging.getLogger(__name__)
+
+class FileBasedEventRunner(BaseRunner):
+    """
+    将代理事件转换为标准事件系统格式并写入事件管理器。
+    
+    这个运行器负责将内部代理事件转换为标准事件系统格式，
+    并通过事件管理器写入，支持流式处理和结果事件。
+    """
+    
+    def run(self, request: AgenticEditRequest) -> None:
+        """
+        Runs the agentic edit process, converting internal events to the
+        standard event system format and writing them using the event manager.
+        """
+        event_manager = get_event_manager(self.args.event_file)
+        self.apply_pre_changes()              
+
+        try:
+            event_stream = self.analyze(request)
+            for agent_event in event_stream:
+                content = None
+                metadata = EventMetadata(
+                    action_file=self.args.file,
+                    is_streaming=False,
+                    stream_out_type="/agent/edit")
+                
+                if isinstance(agent_event, LLMThinkingEvent):
+                    content = EventContentCreator.create_stream_thinking(
+                        content=agent_event.text)
+                    metadata.is_streaming = True
+                    metadata.path = "/agent/edit/thinking"
+                    event_manager.write_stream(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, LLMOutputEvent):
+                    content = EventContentCreator.create_stream_content(
+                        content=agent_event.text)
+                    metadata.is_streaming = True
+                    metadata.path = "/agent/edit/output"
+                    event_manager.write_stream(content=content.to_dict(),
+                                            metadata=metadata.to_dict())
+                
+                elif isinstance(agent_event, ToolCallEvent):
+                    tool_name = type(agent_event.tool).__name__
+                    metadata.path = "/agent/edit/tool/call"
+                    content = EventContentCreator.create_result(
+                        content={
+                            "tool_name": tool_name,
+                            **agent_event.tool.model_dump()
+                        },
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, ToolResultEvent):
+                    metadata.path = "/agent/edit/tool/result"
+                    content = EventContentCreator.create_result(
+                        content={
+                            "tool_name": agent_event.tool_name,
+                            **agent_event.result.model_dump()
+                        },
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                
+                elif isinstance(agent_event, PlanModeRespondEvent):
+                    metadata.path = "/agent/edit/plan_mode_respond"
+                    content = EventContentCreator.create_markdown_result(
+                        content=agent_event.completion.response,
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+
+                elif isinstance(agent_event, TokenUsageEvent):
+                    last_meta: SingleOutputMeta = agent_event.usage
+                    # Get model info for pricing
+                    from autocoder.utils import llms as llm_utils
+                    model_name = ",".join(llm_utils.get_llm_names(self.llm))
+                    model_info = llm_utils.get_model_info(
+                        model_name, self.args.product_mode) or {}
+                    input_price = model_info.get(
+                        "input_price", 0.0) if model_info else 0.0
+                    output_price = model_info.get(
+                        "output_price", 0.0) if model_info else 0.0
+
+                    # Calculate costs
+                    input_cost = (last_meta.input_tokens_count *
+                                input_price) / 1000000  # Convert to millions
+                    # Convert to millions
+                    output_cost = (
+                        last_meta.generated_tokens_count * output_price) / 1000000
+
+                    # 添加日志记录
+                    logger.info(f"Token Usage Details: Model={model_name}, Input Tokens={last_meta.input_tokens_count}, Output Tokens={last_meta.generated_tokens_count}, Input Cost=${input_cost:.6f}, Output Cost=${output_cost:.6f}")
+                    
+                    # 直接将每次的 TokenUsageEvent 写入到事件中
+                    metadata.path = "/agent/edit/token_usage"
+                    content = EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
+                        model_name=model_name,
+                        elapsed_time=0.0,
+                        first_token_time=last_meta.first_token_time,
+                        input_tokens=last_meta.input_tokens_count,
+                        output_tokens=last_meta.generated_tokens_count,
+                        input_cost=input_cost,
+                        output_cost=output_cost
+                    ).to_dict())
+                    event_manager.write_result(content=content.to_dict(), metadata=metadata.to_dict())
+                
+                elif isinstance(agent_event, CompletionEvent):
+                    # 在这里完成实际合并
+                    try:
+                        self.apply_changes()
+                    except Exception as e:
+                        logger.exception(
+                            f"Error merging shadow changes to project: {e}")                                        
+
+                    metadata.path = "/agent/edit/completion"
+                    content = EventContentCreator.create_completion(
+                        success_code="AGENT_COMPLETE",
+                        success_message="Agent attempted task completion.",
+                        result={
+                            "response": agent_event.completion.result
+                        }
+                    )
+                    event_manager.write_completion(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, WindowLengthChangeEvent):
+                    # 处理窗口长度变化事件
+                    metadata.path = "/agent/edit/window_length_change"
+                    content = EventContentCreator.create_result(
+                        content={
+                            "tokens_used": agent_event.tokens_used
+                        },
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                    
+                    # 记录日志
+                    logger.info(f"当前会话总 tokens: {agent_event.tokens_used}")
+
+                elif isinstance(agent_event, ConversationIdEvent):
+                    metadata.path = "/agent/edit/conversation_id"
+                    content = EventContentCreator.create_result(
+                        content={
+                            "conversation_id": agent_event.conversation_id
+                        },
+                        metadata={}
+                    )
+                    event_manager.write_result(content=content.to_dict(), metadata=metadata.to_dict())    
+                    
+                elif isinstance(agent_event, ErrorEvent):                                        
+                    metadata.path = "/agent/edit/error"
+                    content = EventContentCreator.create_error(
+                        error_code="AGENT_ERROR",
+                        error_message=agent_event.message,
+                        details={"agent_event_type": "ErrorEvent"}
+                    )
+                    event_manager.write_error(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                else:
+                    metadata.path = "/agent/edit/error"
+                    logger.warning(
+                        f"Unhandled agent event type: {type(agent_event)}")
+                    content = EventContentCreator.create_error(
+                        error_code="AGENT_ERROR",
+                        error_message=f"Unhandled agent event type: {type(agent_event)}",
+                        details={"agent_event_type": type(
+                            agent_event).__name__}
+                    )
+                    event_manager.write_error(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+
+        except Exception as e:
+            logger.exception(
+                "An unexpected error occurred during agent execution:")
+            metadata = EventMetadata(
+                action_file=self.args.file,
+                is_streaming=False,
+                stream_out_type="/agent/edit/error")
+                
+            # 发送累计的TokenUsageEvent数据（在错误情况下也需要发送）            
+                
+            error_content = EventContentCreator.create_error(
+                error_code="AGENT_FATAL_ERROR",
+                error_message=f"An unexpected error occurred: {str(e)}",
+                details={"exception_type": type(e).__name__}
+            )
+            event_manager.write_error(
+                content=error_content.to_dict(), metadata=metadata.to_dict())
+            # Re-raise the exception if needed, or handle appropriately
+            raise e

autocoder/common/v2/agent/runner/sdk_runner.py

@@ -0,0 +1,182 @@
+"""
+SdkRunner 提供生成器接口，适用于SDK环境下的代理运行。
+
+这个模块提供了一个简单的生成器接口，允许外部代码迭代处理代理事件。
+它是三种运行模式中最轻量级的一种，适合集成到其他应用程序中。
+"""
+
+from loguru import logger
+from typing import Generator, Any, Optional
+import os
+import time
+
+from autocoder.common.v2.agent.agentic_edit_types import (
+    AgenticEditRequest, AgentEvent, CompletionEvent, PullRequestEvent, 
+    PullRequestResult, CommitEvent,PreCommitEvent
+)
+from autocoder.common import  git_utils
+from autocoder.common.git_utils import CommitResult
+from autocoder.common.pull_requests import create_pull_request
+
+from .base_runner import BaseRunner
+
+class SdkRunner(BaseRunner):
+    """
+    提供生成器接口的代理运行器，适用于SDK环境。
+    
+    这个运行器返回一个事件生成器，允许外部代码迭代处理代理事件。
+    它是三种运行模式中最轻量级的一种，适合集成到其他应用程序中。
+    """
+
+    def apply_pre_changes(self)->Optional[CommitResult]:
+        # get the file name
+        file_name = os.path.basename(self.args.file)
+        if not self.args.skip_commit:
+            try:
+                commit_result = git_utils.commit_changes(
+                    self.args.source_dir, f"auto_coder_pre_{file_name}")                
+                return commit_result
+
+            except Exception as e:
+                self.printer.print_in_terminal("git_init_required",
+                                               source_dir=self.args.source_dir, error=str(e))
+        return None
+
+    def apply_changes(self) -> tuple[Optional[CommitResult], Optional[PullRequestResult]]:
+        """
+        应用变更并可选地创建 Pull Request
+        
+        Returns:
+            tuple: (commit_result, pull_request_result)
+        """
+        if not self.args.skip_commit:
+            try:
+                file_name = os.path.basename(self.args.file)
+                commit_result = git_utils.commit_changes(
+                    self.args.source_dir,
+                    f"{self.args.query}\nauto_coder_{file_name}",
+                )
+                
+                pull_request_result = None
+                # 检查是否需要创建 Pull Request
+                if self.conversation_config and self.conversation_config.pull_request:
+                    pr_result = self._create_pull_request(commit_result)
+                    if pr_result:
+                        # 将 PRResult 转换为 PullRequestResult
+                        pull_request_result = PullRequestResult.from_pr_result(pr_result)
+
+                return commit_result, pull_request_result    
+
+            except Exception as e:
+                self.printer.print_str_in_terminal(
+                    str(e),
+                    style="red"
+                )  
+        
+        return None, None
+    
+    def _create_pull_request(self, commit_result):
+        """
+        创建 Pull Request 的内部方法
+        
+        Args:
+            commit_result: Git commit 结果对象
+            
+        Returns:
+            PRResult: Pull Request 创建结果
+        """
+        try:            
+            
+            # 获取当前分支名
+            current_branch = git_utils.get_current_branch(self.args.source_dir)
+            if not current_branch:
+                logger.warning("无法获取当前分支名")
+                return None
+
+            # 准备 PR 标题和描述
+            query = self.args.query or "Auto-coder generated changes"
+            pr_title = f"Auto-coder: {query[:40]}..."
+
+            # 构建 PR 描述
+            file_list = ""
+            if commit_result.changed_files:
+                for file_path in commit_result.changed_files:
+                    file_list += f"- `{file_path}`\n"
+
+            pr_description = f"""## 自动生成的代码变更
+
+**查询内容**: {query}
+
+**变更文件数量**: {len(commit_result.changed_files or [])}
+
+**Commit Hash**: {commit_result.commit_hash}
+
+### 变更文件列表:
+{file_list.strip()}
+
+**源分支**: {current_branch}  
+**目标分支**: main  
+**生成时间**: {time.strftime('%Y-%m-%d %H:%M:%S')}
+---
+此 Pull Request 由 Auto-coder 自动生成
+"""
+
+            # 创建 Pull Request
+            logger.info(f"正在创建 Pull Request: {pr_title}")
+
+            result = create_pull_request(
+                repo_path=self.args.source_dir,
+                title=pr_title,
+                description=pr_description,
+            )
+
+            if result.success:
+                logger.info("Pull Request 创建成功")
+                logger.info(f"PR URL: {result.pr_url}")
+                logger.info(f"PR 编号: {result.pr_number}")
+
+            return result
+
+        except Exception as e:
+            logger.exception(f"创建 Pull Request 时发生异常: {str(e)}")
+            # 返回一个失败的 PRResult
+            try:
+                from autocoder.common.pull_requests.models import PRResult
+                return PRResult(
+                    success=False,
+                    error_message=f"创建 Pull Request 失败: {str(e)}"
+                )
+            except ImportError:
+                return None
+    
+    def run(self, request: AgenticEditRequest) -> Generator[AgentEvent, None, None]:
+        """
+        Runs the agentic edit process and yields events for external processing.
+        """
+        try:
+            if self.conversation_config and self.conversation_config.pre_commit:
+                pre_commit_result = self.apply_pre_changes()
+                yield PreCommitEvent(commit_result=pre_commit_result)
+
+            event_stream = self.analyze(request)                                    
+            for agent_event in event_stream:
+                if isinstance(agent_event, CompletionEvent):
+                    if self.conversation_config and self.conversation_config.post_commit:
+                        commit_result, pull_request_result = self.apply_changes()                    
+                        # 发射 commit 事件
+                        if commit_result:
+                            yield CommitEvent(commit_result=commit_result)
+                        
+                        # 发射 pull request 事件（如果有）                        
+                        if pull_request_result:
+                            yield PullRequestEvent(pull_request_result=pull_request_result)
+                    
+                    # 总是发射 completion 事件
+                    yield agent_event
+                else:
+                    yield agent_event
+                
+        except Exception as e:
+            logger.exception(
+                "An unexpected error occurred during agent execution: {e}")           
+            raise e