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

autocoder/terminal/utils/shell.py

@@ -0,0 +1,43 @@
+"""Shell 相关工具函数"""
+
+import platform
+import subprocess
+import asyncio
+
+
+def get_shell() -> str:
+    """获取当前系统的默认 shell"""
+    return "/bin/bash" if platform.system() != "Windows" else "cmd.exe"
+
+
+async def run_shell_command_async(command: str, session=None) -> bool:
+    """异步运行 shell 命令
+
+    Args:
+        command: 要执行的命令
+        session: PromptSession 对象，如果提供则使用其 app.run_system_command
+
+    Returns:
+        bool: 是否成功执行
+    """
+    shell = get_shell()
+
+    if session and hasattr(session, "app"):
+        try:
+            await session.app.run_system_command(command, wait_for_enter=False)
+            return True
+        except Exception:
+            # 如果异步调用失败，回退到同步方式
+            pass
+
+    # 回退到同步方式
+    try:
+        if command == shell:
+            # 直接启动 shell
+            subprocess.call([shell])
+        else:
+            # 执行命令
+            subprocess.call([shell, "-c", command])
+        return True
+    except Exception:
+        return False

autocoder/terminal_v3/__init__.py

@@ -0,0 +1,10 @@
+"""
+Terminal V3 - 重构的终端交互模块
+
+这个模块提供了类似 Claude Code 的 TUI 界面，
+同时支持所有 auto-coder 的功能命令。
+"""
+
+from .app import AutoCoderChatApp
+
+__all__ = ["AutoCoderChatApp"]

autocoder/terminal_v3/app.py

@@ -0,0 +1,201 @@
+"""主应用类"""
+
+import asyncio
+from prompt_toolkit import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+
+from .models import ConversationBuffer
+from .handlers import CommandHandler
+from .ui import get_styles, create_layout, create_key_bindings
+from autocoder.plugins import PluginManager
+
+
+class AutoCoderChatApp:
+    """Auto-Coder 聊天式 TUI 应用程序"""
+
+    def __init__(self,plugin_manager: PluginManager):
+        # 初始化状态
+        self.conversation_buffer = ConversationBuffer()
+        self.is_processing = False
+        self.current_task = ""
+        self.show_shortcuts = False
+        self.animation_counter = 0
+        self.plugin_manager = plugin_manager
+
+        # 创建命令处理器
+        self.command_handler = CommandHandler(self.conversation_buffer, self)
+
+        # 创建输入缓冲区
+        self.input_buffer = Buffer(
+            history=InMemoryHistory(),
+            auto_suggest=AutoSuggestFromHistory(),
+            enable_history_search=True,
+            multiline=False,
+            accept_handler=self._handle_input_sync,
+        )
+
+        # 创建布局
+        self.layout = create_layout(
+            conversation_buffer=self.conversation_buffer,
+            input_buffer=self.input_buffer,
+            get_prompt_text=self._get_prompt_text,
+            get_right_hint=self._get_right_hint,
+            get_tips_text=self._get_tips_text,
+            get_shortcuts_help_text=self._get_shortcuts_help_text,
+            show_shortcuts_condition=lambda: self.show_shortcuts,
+            input_has_text_condition=lambda: bool(self.input_buffer.text.strip()),
+        )
+
+        # 创建键绑定
+        self.key_bindings = create_key_bindings(self, self.input_buffer, self.plugin_manager)
+
+        # 创建样式
+        self.style = get_styles()
+
+        # 创建应用程序
+        self.app = Application(
+            layout=self.layout,
+            key_bindings=self.key_bindings,
+            style=self.style,
+            full_screen=True,
+            mouse_support=False,
+            color_depth=None,
+            refresh_interval=0.5,
+        )
+
+    def _get_tips_text(self):
+        """获取提示文本"""
+        return [
+            ("class:tips", "Tips for getting started:\n\n"),
+            (
+                "class:tips",
+                "1. Type your questions or tasks directly - Auto-Coder will help!\n",
+            ),
+            ("class:tips", "2. Use /auto <query> for explicit auto command\n"),
+            ("class:tips", "3. Use /exit or Ctrl+D to exit the application\n"),
+            ("class:tips", "4. Be as specific as possible for the best results\n"),
+        ]
+
+    def _get_prompt_text(self):
+        """获取提示符文本"""
+        if self.is_processing:
+            # 转圈圈动画字符
+            spinner_chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+            spinner_index = (self.animation_counter // 3) % len(spinner_chars)
+            return f"{spinner_chars[spinner_index]} "
+        else:
+            return "> "
+
+    def _get_right_hint(self):
+        """获取右侧提示信息"""
+        if self.show_shortcuts:
+            return "Press ? again to hide shortcuts"
+        else:
+            return "? for shortcuts"
+
+    def _get_shortcuts_help_text(self):
+        """底部快捷键帮助文本"""
+        return [
+            (
+                "class:shortcuts-help",
+                "┌─────────────────────── Keyboard Shortcuts ───────────────────────┐\n",
+            ),
+            (
+                "class:shortcuts-help",
+                "│  ?       Toggle this help           Enter    Submit command      │\n",
+            ),
+            (
+                "class:shortcuts-help",
+                "│  Ctrl+C  Cancel current task        ↑/↓      Navigate history   │\n",
+            ),
+            (
+                "class:shortcuts-help",
+                "│  Ctrl+D  Exit application           Ctrl+L   Clear conversation │\n",
+            ),
+            (
+                "class:shortcuts-help",
+                "└──────────────────────────────────────────────────────────────────┘",
+            ),
+        ]
+
+    def invalidate(self):
+        """刷新界面 - 转发到内部的 prompt_toolkit Application"""
+        self.app.invalidate()
+
+    def exit(self):
+        """退出应用 - 转发到内部的 prompt_toolkit Application"""
+        self.app.exit()
+
+    def _handle_input_sync(self, buffer: Buffer) -> bool:
+        """处理用户输入（同步版本）"""
+        command = buffer.text.strip()
+        buffer.reset()
+
+        if not command:
+            return True
+
+        # 一旦用户输入了内容，隐藏底部帮助
+        if self.show_shortcuts:
+            self.show_shortcuts = False
+
+        # 添加用户消息到对话
+        self.conversation_buffer.add_user_message(command)
+        self.app.invalidate()
+
+        # 创建后台任务
+        self.app.create_background_task(self._execute_command(command))
+
+        return True
+
+    async def _execute_command(self, command: str):
+        """执行用户命令"""
+        self.is_processing = True
+        self.current_task = command[:30] + "..." if len(command) > 30 else command
+
+        # 开始处理时刷新界面显示转圈圈动画
+        self.app.invalidate()
+        await asyncio.sleep(0.05)
+
+        try:
+            await self.command_handler.handle_command(command)
+        except Exception as e:
+            self.conversation_buffer.add_system_message(f"Error: {str(e)}")
+        finally:
+            self.is_processing = False
+            self.current_task = ""
+            self.animation_counter = 0
+            self.app.invalidate()
+
+    async def _animation_loop(self):
+        """动画循环，定期更新界面以显示转圈圈效果"""
+        while True:
+            try:
+                if self.is_processing:
+                    self.animation_counter += 1
+                    self.app.invalidate()
+                    await asyncio.sleep(0.2)
+                else:
+                    await asyncio.sleep(1.0)
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                await asyncio.sleep(1.0)
+
+    async def run(self):
+        """运行 TUI 应用"""
+        try:
+            # 创建动画更新任务
+            animation_task = asyncio.create_task(self._animation_loop())
+
+            # 运行应用
+            await self.app.run_async()
+        finally:
+            # 确保清理资源
+            if "animation_task" in locals():
+                animation_task.cancel()
+                try:
+                    await animation_task
+                except asyncio.CancelledError:
+                    pass

autocoder/terminal_v3/handlers/__init__.py

@@ -0,0 +1,5 @@
+"""命令处理器"""
+
+from .command_handler import CommandHandler
+
+__all__ = ["CommandHandler"]

autocoder/terminal_v3/handlers/command_handler.py

@@ -0,0 +1,131 @@
+"""统一的命令处理器"""
+
+import asyncio
+from typing import TYPE_CHECKING
+from concurrent.futures import ThreadPoolExecutor
+from autocoder.common.global_cancel import global_cancel, CancelRequestedException
+from autocoder.events.event_manager_singleton import gengerate_event_file_path
+from autocoder.auto_coder_runner import configure
+from autocoder.inner.agentic import RunAgentic
+from autocoder.common.v2.agent.agentic_edit_types import ConversationAction
+from ..models import ConversationBuffer
+
+if TYPE_CHECKING:
+    from ..app import AutoCoderChatApp
+
+
+class CommandHandler:
+    """处理所有命令的统一处理器"""
+
+    def __init__(
+        self, conversation_buffer: ConversationBuffer, app_instance: "AutoCoderChatApp"
+    ):
+        self.conversation_buffer = conversation_buffer
+        self.app = app_instance
+        # 创建线程池用于执行同步生成器
+        self.executor = ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="agentic-worker"
+        )
+
+    async def handle_command(self, command: str):
+        """处理命令"""
+        try:
+            # 退出命令
+            if command in ["exit", "/exit"]:
+                self.app.exit()
+
+            # /auto 命令或直接输入查询
+            elif command.startswith("/auto") or not command.startswith("/"):
+                # 处理 /auto 命令或直接的查询
+                if not command:
+                    self.conversation_buffer.add_system_message(
+                        "Please provide a query"
+                    )
+                else:
+                    await self._execute_auto_command(command)
+
+            # 未知命令
+            else:
+                self.conversation_buffer.add_system_message(
+                    f"Unknown command: {command}. Use /auto <query> or /exit"
+                )
+
+        except Exception as e:
+            self.conversation_buffer.add_system_message(f"Error: {str(e)}")
+
+    async def _execute_auto_command(self, query: str):
+        """执行 /auto 命令（使用线程池避免阻塞事件循环）"""
+        event_file, _ = gengerate_event_file_path()
+        global_cancel.register_token(event_file)
+        configure(f"event_file:{event_file}")
+
+        self.app.invalidate()
+
+        # 创建事件队列用于线程和协程之间通信
+        event_queue = asyncio.Queue()
+        loop = asyncio.get_event_loop()
+
+        def run_agentic_in_thread():
+            """在线程中运行同步生成器"""
+            try:
+                agentic = RunAgentic()
+                for event in agentic.run_with_events(
+                    query=query,
+                    pre_commit=False,
+                    post_commit=False,
+                    pr=False,
+                    cancel_token=event_file,
+                    conversation_action=ConversationAction.RESUME,
+                ):
+                    # 将事件放入队列（线程安全）
+                    asyncio.run_coroutine_threadsafe(
+                        event_queue.put(("event", event)), loop
+                    )
+            except CancelRequestedException:
+                # 取消请求异常
+                asyncio.run_coroutine_threadsafe(
+                    event_queue.put(("cancelled", None)), loop
+                )
+            except Exception as e:
+                # 其他异常
+                asyncio.run_coroutine_threadsafe(event_queue.put(("error", e)), loop)
+            finally:
+                # 发送结束信号
+                asyncio.run_coroutine_threadsafe(event_queue.put(("done", None)), loop)
+
+        try:
+            # 在线程池中启动生成器
+            loop.run_in_executor(self.executor, run_agentic_in_thread)
+
+            # 异步消费事件队列
+            while True:
+                msg_type, data = await event_queue.get()
+
+                if msg_type == "event":
+                    # 处理事件
+                    self.conversation_buffer.add_event(data)
+                    self.app.invalidate()
+                    # 让出控制权，确保 Ctrl+C 能被及时处理
+                    await asyncio.sleep(0)
+
+                elif msg_type == "cancelled":
+                    # 任务被取消
+                    self.conversation_buffer.add_system_message("Task cancelled")
+                    self.app.invalidate()
+                    break
+
+                elif msg_type == "error":
+                    # 发生错误
+                    self.conversation_buffer.add_system_message(f"Error: {str(data)}")
+                    self.app.invalidate()
+                    break
+
+                elif msg_type == "done":
+                    # 正常结束
+                    break
+
+        except Exception as e:
+            self.conversation_buffer.add_system_message(f"Error: {str(e)}")
+        finally:
+            global_cancel.reset_token(event_file)
+            self.app.invalidate()

autocoder/terminal_v3/models/__init__.py

@@ -0,0 +1,6 @@
+"""消息和数据模型"""
+
+from .message import ChatMessage
+from .conversation_buffer import ConversationBuffer
+
+__all__ = ["ChatMessage", "ConversationBuffer"]

autocoder/terminal_v3/models/conversation_buffer.py

@@ -0,0 +1,214 @@
+"""对话缓冲区管理"""
+
+import os
+from typing import List, Optional
+from .message import ChatMessage
+from autocoder.common.v2.agent.agentic_edit_types import (
+    ConversationIdEvent,
+    TokenUsageEvent,
+    WindowLengthChangeEvent,
+    LLMThinkingEvent,
+    LLMOutputEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+    PlanModeRespondEvent,
+    PreCommitEvent,
+    CommitEvent,
+    PullRequestEvent,
+    CompletionEvent,
+    ErrorEvent,
+)
+
+
+class ConversationBuffer:
+    """对话缓冲区，类似聊天应用的消息列表"""
+
+    def __init__(self, max_messages: int = 200):
+        self.max_messages = max_messages
+        self.messages: List[ChatMessage] = []
+        self.welcome_messages: List[ChatMessage] = []
+        self.token_stats = {"input_tokens": 0, "output_tokens": 0, "model": ""}
+
+        # 强类型属性定义
+        self._thinking_buffer: Optional[str] = None
+        self._current_response: Optional[str] = None
+
+        self._init_welcome_messages()
+
+    def _init_welcome_messages(self):
+        """初始化欢迎消息"""
+        self.welcome_messages.append(
+            ChatMessage("✦ Welcome to Auto-Coder.Chat!", "welcome")
+        )
+        self.welcome_messages.append(ChatMessage("", "welcome"))
+        self.welcome_messages.append(
+            ChatMessage("/help for help, /status to view current setup", "welcome")
+        )
+        self.welcome_messages.append(ChatMessage("", "welcome"))
+        cwd = os.getcwd()
+        self.welcome_messages.append(ChatMessage(f"cwd: {cwd}", "welcome"))
+        self.welcome_messages.append(ChatMessage("", "welcome"))
+
+    def get_welcome_text(self):
+        """获取欢迎消息的格式化文本"""
+        result = []
+        for msg in self.welcome_messages:
+            result.extend(msg.to_formatted_text())
+        return result
+
+    def add_user_message(self, content: str):
+        """添加用户消息"""
+        self.messages.append(ChatMessage(content, "user"))
+        self._trim_messages()
+
+    def add_assistant_message(self, content: str):
+        """添加助手消息"""
+        self.messages.append(ChatMessage(content, "assistant"))
+        self._trim_messages()
+
+    def add_system_message(self, content: str, ansi: bool = False):
+        """添加系统消息"""
+        self.messages.append(ChatMessage(content, "system", ansi=ansi))
+        self._trim_messages()
+
+    def add_event(self, event):
+        """处理 SdkRunner 事件 - 参考 terminal_runner.py 的格式化方式"""
+        if isinstance(event, ConversationIdEvent):
+            # 对话ID事件静默处理，不显示
+            pass
+
+        elif isinstance(event, TokenUsageEvent):
+            meta = event.usage
+            self.token_stats["input_tokens"] += meta.input_tokens_count
+            self.token_stats["output_tokens"] += meta.generated_tokens_count
+            # SingleOutputMeta 没有 model_name 属性，保持原有逻辑
+            # 模型名称通过其他方式获取
+
+        elif isinstance(event, WindowLengthChangeEvent):
+            # 显示 token 使用情况
+            if event.tokens_used > event.pruned_tokens_used:
+                self.add_system_message(
+                    f"Conversation tokens: {event.tokens_used} -> {event.pruned_tokens_used} "
+                    f"(round: {event.conversation_round})"
+                )
+
+        elif isinstance(event, LLMThinkingEvent):
+            # 实时显示思考过程（灰色显示）
+            if self._thinking_buffer is not None:
+                self._thinking_buffer += event.text
+                # 更新最后一条思考消息
+                if self.messages and self.messages[-1]._is_thinking:
+                    self.messages[-1].content = self._thinking_buffer
+                else:
+                    msg = ChatMessage(self._thinking_buffer, "system")
+                    msg._is_thinking = True
+                    self.messages.append(msg)
+            else:
+                self._thinking_buffer = event.text
+                msg = ChatMessage(self._thinking_buffer, "system")
+                msg._is_thinking = True
+                self.messages.append(msg)
+
+        elif isinstance(event, LLMOutputEvent):
+            # 清除思考缓冲区（如果有）
+            if self._thinking_buffer is not None:
+                self._thinking_buffer = None
+
+            # LLM 输出直接添加为助手消息（流式更新）
+            if self._current_response is not None:
+                self._current_response += event.text
+                if self.messages and self.messages[-1].role == "assistant":
+                    self.messages[-1].content = self._current_response
+                else:
+                    self.messages.append(
+                        ChatMessage(self._current_response, "assistant")
+                    )
+            else:
+                self._current_response = event.text
+                self.messages.append(ChatMessage(self._current_response, "assistant"))
+
+        elif isinstance(event, ToolCallEvent):
+            # 使用简洁的工具调用显示
+            from .tool_display import get_tool_simple_display
+
+            tool_display = get_tool_simple_display(event.tool)
+            self.add_system_message(f"🔧 {tool_display}")
+
+        elif isinstance(event, ToolResultEvent):
+            # 显示工具结果（简洁版本）
+            from .tool_display import get_tool_result_display
+
+            result = event.result
+            result_display = get_tool_result_display(
+                event.tool_name,
+                result.success,
+                result.message if not result.success else None,
+            )
+            self.add_system_message(result_display)
+
+        elif isinstance(event, PlanModeRespondEvent):
+            try:
+                response_text = event.completion.response
+                if response_text:
+                    self.add_assistant_message(response_text)
+            except Exception:
+                pass
+
+        elif isinstance(event, PreCommitEvent):
+            if event.commit_result:
+                self.add_system_message("📦 Changes staged")
+
+        elif isinstance(event, CommitEvent):
+            if event.commit_result and event.commit_result.success:
+                self.add_system_message(
+                    f"✅ Committed: {event.commit_result.commit_hash[:8]}"
+                )
+
+        elif isinstance(event, PullRequestEvent):
+            if event.pull_request_result and event.pull_request_result.success:
+                self.add_system_message(
+                    f"🎉 PR #{event.pull_request_result.pr_number} created"
+                )
+
+        elif isinstance(event, CompletionEvent):
+            # 清除思考和响应缓冲区
+            if self._thinking_buffer is not None:
+                self._thinking_buffer = None
+
+            if self._current_response is not None:
+                if self.messages and self.messages[-1].role == "assistant":
+                    self.messages[-1].content = self._current_response
+                else:
+                    self.add_assistant_message(self._current_response)
+                self._current_response = None
+            else:
+                try:
+                    result_text = event.completion.result
+                    if result_text:
+                        self.add_assistant_message(result_text)
+                except Exception:
+                    pass
+
+        elif isinstance(event, ErrorEvent):
+            self.add_system_message(f"❌ Error: {event.message}")
+
+    def _trim_messages(self):
+        """保持消息数量在限制内"""
+        if len(self.messages) > self.max_messages:
+            self.messages = self.messages[-self.max_messages :]
+
+    def get_formatted_text(self):
+        """获取格式化的文本用于显示"""
+        if not self.messages:
+            return [("", "")]
+
+        result = []
+        for message in self.messages:
+            result.extend(message.to_formatted_text())
+        return result
+
+    def clear_conversation(self):
+        """清空对话历史"""
+        self.messages = []
+        self._current_response = None
+        self._thinking_buffer = None

autocoder/terminal_v3/models/message.py

@@ -0,0 +1,50 @@
+"""聊天消息模型"""
+
+from datetime import datetime
+from typing import List, Tuple
+from prompt_toolkit.formatted_text import ANSI, to_formatted_text
+
+
+class ChatMessage:
+    """聊天消息类"""
+
+    def __init__(
+        self,
+        content: str,
+        role: str = "assistant",
+        timestamp: datetime = None,
+        ansi: bool = False,
+    ):
+        self.content = content
+        self.role = role  # user, assistant, system, welcome
+        self.timestamp = timestamp or datetime.now()
+        self.is_ansi = ansi
+        self._is_thinking: bool = False
+
+    def to_formatted_text(self) -> List[Tuple[str, str]]:
+        """转换为 FormattedText 格式"""
+        if self.is_ansi:
+            # 直接使用 ANSI 渲染（不加前缀圆点，避免破坏颜色布局）
+            return list(to_formatted_text(ANSI(self.content))) + [("", "\n")]
+
+        if self.role == "welcome":
+            # 欢迎消息不显示时间戳
+            return [("class:welcome", self.content), ("", "\n")]
+        elif self.role == "system":
+            return [
+                ("class:system", "● "),
+                ("class:system-text", self.content),
+                ("", "\n"),
+            ]
+        elif self.role == "user":
+            return [
+                ("class:user-prompt", "> "),
+                ("class:user-text", self.content),
+                ("", "\n"),
+            ]
+        else:  # assistant
+            return [
+                ("class:assistant", "● "),
+                ("class:assistant-text", self.content),
+                ("", "\n"),
+            ]