comate-cli 0.1.0__py3-none-any.whl

comate_cli/terminal_agent/tui_parts/history_sync.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+from prompt_toolkit.application import run_in_terminal
+from rich.console import Console
+
+from comate_agent_sdk.context.items import ItemType
+from comate_agent_sdk.llm.messages import AssistantMessage, UserMessage
+
+from comate_cli.terminal_agent.history_printer import (
+    print_history_group_sync,
+    render_history_group,
+)
+from comate_cli.terminal_agent.logo import print_logo
+from comate_cli.terminal_agent.markdown_render import render_markdown_to_plain
+from comate_cli.terminal_agent.models import HistoryEntry
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+
+class HistorySyncMixin:
+    async def _replay_scrollback_after_rewind(self) -> None:
+        """清屏并重建 scrollback：Logo + 当前会话历史。"""
+        self._renderer.reset_history_view()
+        self._printed_history_index = 0
+
+        def _clear_and_print_logo() -> None:
+            out = sys.__stdout__ or sys.stdout
+            out.write("\x1b[3J\x1b[2J\x1b[H")
+            out.flush()
+            scrollback_console = Console(
+                file=out,
+                force_terminal=True,
+                width=self._terminal_width(),
+            )
+            print_logo(scrollback_console)
+
+        try:
+            await run_in_terminal(_clear_and_print_logo, in_executor=False)
+        except Exception as exc:
+            logger.warning(
+                f"failed to clear terminal and replay logo: {exc}",
+                exc_info=True,
+            )
+
+        self.add_resume_history("resume")
+
+    def add_resume_history(self, mode: str) -> None:
+        if mode != "resume":
+            return
+
+        items = self._session._agent._context.get_conversation_items_snapshot()
+        history: list[Any] = []
+        for item in items:
+            if item.item_type not in (
+                ItemType.USER_MESSAGE,
+                ItemType.ASSISTANT_MESSAGE,
+                ItemType.TOOL_RESULT,
+            ):
+                continue
+            if item.item_type == ItemType.USER_MESSAGE:
+                message = getattr(item, "message", None)
+                if isinstance(message, UserMessage) and bool(getattr(message, "is_meta", False)):
+                    continue
+            history.append(item)
+        if not history:
+            return
+
+        self._renderer.append_system_message(f"history loaded: {len(history)} messages")
+
+        # 维护 tool_call_id 映射，用于匹配工具调用和结果
+        tool_call_info: dict[str, tuple[str, str]] = {}  # tool_call_id → (tool_name, signature)
+
+        for item in history:
+            if item.item_type == ItemType.USER_MESSAGE:
+                message = getattr(item, "message", None)
+                content = str(item.content_text or "").strip()
+                if not content and isinstance(message, UserMessage):
+                    content = str(message.text or "").strip()
+                if content:
+                    self._renderer.seed_user_message(content)
+                continue
+
+            # 处理 AssistantMessage - 提取 tool_calls 信息但不渲染为动态组件
+            if item.item_type == ItemType.ASSISTANT_MESSAGE:
+                message = getattr(item, "message", None)
+                if isinstance(message, AssistantMessage) and message.tool_calls:
+                    for tc in message.tool_calls:
+                        tool_name = tc.function.name
+                        args_str = tc.function.arguments
+                        try:
+                            import json
+
+                            args_dict = json.loads(args_str) if args_str else {}
+                        except json.JSONDecodeError:
+                            args_dict = {"_raw": args_str}
+                        signature = self._build_resume_tool_signature(tool_name, args_dict)
+                        # 存储映射，不调用 restore_tool_call（避免加入 _running_tools）
+                        tool_call_info[tc.id] = (tool_name, signature)
+
+                # 显示 assistant text
+                assistant_text = self._extract_assistant_text(item).strip()
+                if assistant_text:
+                    self._renderer.append_assistant_message(assistant_text)
+                continue
+
+            # 处理 TOOL_RESULT - 直接输出静态文本（无计时器）
+            if item.item_type == ItemType.TOOL_RESULT:
+                message = getattr(item, "message", None)
+                if message is None:
+                    continue
+
+                tool_call_id = getattr(message, "tool_call_id", None)
+                is_error = getattr(message, "is_error", False)
+
+                # 从映射中获取工具信息
+                if tool_call_id and tool_call_id in tool_call_info:
+                    tool_name, signature = tool_call_info[tool_call_id]
+                else:
+                    # 回退：直接使用 tool_name
+                    tool_name = getattr(message, "tool_name", item.tool_name or "UnknownTool")
+                    signature = f"{tool_name}()"
+
+                # Extract diff from raw_envelope for Edit/MultiEdit
+                diff_lines: list[str] | None = None
+                if tool_name in ("Edit", "MultiEdit") and not is_error:
+                    raw_envelope = getattr(item, "metadata", {}) or {}
+                    envelope = raw_envelope.get("tool_raw_envelope")
+                    if isinstance(envelope, dict):
+                        data = envelope.get("data", {})
+                        if isinstance(data, dict):
+                            diff = data.get("diff")
+                            if isinstance(diff, list) and len(diff) > 0:
+                                diff_lines = diff
+
+                # 直接追加静态 HistoryEntry（无计时器）
+                self._renderer.append_static_tool_result(
+                    signature,
+                    is_error,
+                    diff_lines=diff_lines,
+                )
+                continue
+
+        self._drain_history_sync()
+
+    def _summarize_tool_args(self, tool_name: str, args: dict[str, Any]) -> str:
+        """Summarize tool arguments for display in history."""
+        from comate_cli.terminal_agent.tool_view import summarize_tool_args
+
+        summary = summarize_tool_args(tool_name, args, self._renderer._project_root).strip()
+        return summary
+
+    @staticmethod
+    def _lookup_arg(args: dict[str, Any], *keys: str) -> Any:
+        for key in keys:
+            if key in args:
+                return args.get(key)
+        params = args.get("params")
+        if isinstance(params, dict):
+            for key in keys:
+                if key in params:
+                    return params.get(key)
+        return None
+
+    def _build_resume_tool_signature(self, tool_name: str, args: dict[str, Any]) -> str:
+        lowered = tool_name.lower()
+        if lowered != "task":
+            summary = self._summarize_tool_args(tool_name, args)
+            if summary:
+                return f"{tool_name}({summary})"
+            return f"{tool_name}()"
+
+        raw_subagent = self._lookup_arg(args, "subagent_type")
+        subagent_name = raw_subagent.strip() if isinstance(raw_subagent, str) else ""
+        if not subagent_name:
+            subagent_name = "Task"
+
+        raw_description = self._lookup_arg(args, "description")
+        description = raw_description.strip() if isinstance(raw_description, str) else ""
+        if description and description != subagent_name:
+            return f"{subagent_name}({description})"
+        return subagent_name
+
+    @staticmethod
+    def _extract_assistant_text(item: Any) -> str:
+        """从 ContextItem 提取用于显示的文本（不含 tool_calls JSON）"""
+        message = getattr(item, "message", None)
+        if message is None:
+            return ""
+
+        # 优先使用 message.text（纯文本，不含 tool_calls）
+        if hasattr(message, "text"):
+            text = message.text
+            if isinstance(text, str):
+                return text
+
+        # 回退：处理非标准 content
+        msg_content = getattr(message, "content", "")
+        if isinstance(msg_content, str):
+            return msg_content
+        if isinstance(msg_content, list):
+            text_parts: list[str] = []
+            for part in msg_content:
+                if isinstance(part, dict) and part.get("type") == "text":
+                    text_parts.append(str(part.get("text", "")))
+            return "".join(text_parts)
+
+        return ""
+
+    async def _drain_history_async(self) -> None:
+        pending = self._pending_history_entries()
+        if not pending:
+            return
+        group = render_history_group(
+            console,
+            pending,
+            terminal_width=self._terminal_width(),
+            render_markdown_to_plain=render_markdown_to_plain,
+        )
+        if group is None:
+            return
+
+        def _print() -> None:
+            width = self._terminal_width()
+            out = sys.__stdout__ or sys.stdout
+            scrollback_console = Console(
+                file=out,
+                force_terminal=True,
+                width=width,
+            )
+            print_history_group_sync(scrollback_console, group)
+
+        await run_in_terminal(_print, in_executor=False)
+
+    def _drain_history_sync(self) -> None:
+        pending = self._pending_history_entries()
+        if not pending:
+            return
+        group = render_history_group(
+            console,
+            pending,
+            terminal_width=self._terminal_width(),
+            render_markdown_to_plain=render_markdown_to_plain,
+        )
+        if group is None:
+            return
+        print_history_group_sync(console, group)
+
+    def _pending_history_entries(self) -> list[HistoryEntry]:
+        entries = self._renderer.history_entries()
+        if self._printed_history_index >= len(entries):
+            return []
+        pending = entries[self._printed_history_index :]
+        self._printed_history_index = len(entries)
+        # 根据 _show_thinking 开关过滤 thinking 条目
+        if not getattr(self, "_show_thinking", False):
+            pending = [e for e in pending if e.entry_type != "thinking"]
+        return pending

comate_cli/terminal_agent/tui_parts/input_behavior.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+from bisect import bisect_right
+from typing import Any
+
+from prompt_toolkit.document import Document
+
+from comate_cli.terminal_agent.input_geometry import (
+    compute_visual_line_ranges,
+    index_for_visual_col,
+    visual_col_for_index,
+)
+from comate_cli.terminal_agent.question_view import QuestionAction
+from comate_cli.terminal_agent.tui_parts.ui_mode import UIMode
+
+
+class InputBehaviorMixin:
+    def _should_handle_history(self) -> bool:
+        """检查是否应该处理历史浏览(而不是补全导航)
+
+        Returns:
+            True 表示可以浏览历史,False 表示应该优先处理补全
+        """
+        buffer = self._input_area.buffer
+
+        # 如果有活动的补全菜单,不应该浏览历史
+        if buffer.complete_state is not None and buffer.complete_state.completions:
+            return False
+
+        # 如果在补全上下文中(输入了 / 或 @),不应该浏览历史
+        document = buffer.document
+        if self._completion_context_active(
+            document.text_before_cursor,
+            document.text_after_cursor,
+        ):
+            return False
+
+        return True
+
+    def _completion_context_active(
+        self,
+        text_before_cursor: str,
+        text_after_cursor: str,
+    ) -> bool:
+        if text_after_cursor.strip():
+            return False
+        if text_before_cursor.startswith("/") and " " not in text_before_cursor:
+            return True
+        return self._mention_completer.extract_context(text_before_cursor) is not None
+
+    def _move_completion_selection(self, buffer: Any, *, backward: bool) -> bool:
+        """尝试在补全菜单中移动选择项
+
+        行为:
+        - 如果补全菜单已显示,在菜单中导航
+        - 如果在补全上下文中(输入 / 或 @)但菜单未显示,触发补全并选中第一项
+        - 否则返回 False,允许调用者处理其他行为(如历史浏览)
+
+        Args:
+            buffer: 当前的 Buffer 对象
+            backward: True 表示向上导航,False 表示向下导航
+
+        Returns:
+            True 表示已处理补全导航,False 表示未处理
+        """
+        complete_state = buffer.complete_state
+
+        # 情况1: 已有补全菜单且有补全项
+        if complete_state is not None and complete_state.completions:
+            if backward:
+                buffer.complete_previous()
+            else:
+                buffer.complete_next()
+            return True
+
+        # 情况2: 在补全上下文中但菜单未显示
+        document = buffer.document
+        if self._completion_context_active(
+            document.text_before_cursor,
+            document.text_after_cursor,
+        ):
+            # 启动补全并选择第一项(关键改动:select_first=True)
+            buffer.start_completion(select_first=True)
+            return True
+
+        return False
+
+    def _enter_question_mode(self, questions: list[dict[str, Any]]) -> None:
+        if not self._question_ui.set_questions(questions):
+            return
+        self._ui_mode = UIMode.QUESTION
+        self._sync_focus_for_mode()
+        self._refresh_layers()
+
+    def _exit_question_mode(self) -> None:
+        self._ui_mode = UIMode.NORMAL
+        self._question_ui.clear()
+        self._sync_focus_for_mode()
+
+    def _sync_focus_for_mode(self) -> None:
+        if self._app is None:
+            return
+        if self._ui_mode == UIMode.QUESTION:
+            self._app.layout.focus(self._question_ui.focus_target())
+            return
+        if self._ui_mode == UIMode.SELECTION:
+            self._app.layout.focus(self._selection_ui.focus_target())
+            return
+        self._app.layout.focus(self._input_area.window)
+
+    def _handle_question_action(self, action: QuestionAction | None) -> None:
+        if action is None:
+            return
+        if action.kind == "cancel":
+            self._submit_question_reply(action.message, cancelled=True)
+            return
+        if action.kind == "submit":
+            self._submit_question_reply(action.message, cancelled=False)
+
+    def _submit_question_reply(self, message: str, *, cancelled: bool) -> None:
+        normalized = message.strip()
+        if not normalized:
+            return
+        self._exit_question_mode()
+        self._waiting_for_input = False
+        self._pending_questions = None
+        if cancelled:
+            self._renderer.append_system_message("用户取消问答，已发送拒绝回答消息。")
+        self._refresh_layers()
+        self._schedule_background(self._submit_user_message(normalized))
+
+    def _clear_input_area(self) -> None:
+        self._clear_paste_state()
+        self._last_input_len = 0
+        self._last_input_text = ""
+
+        buffer = self._input_area.buffer
+        buffer.cancel_completion()
+        self._suppress_input_change_hook = True
+        try:
+            buffer.set_document(Document("", cursor_position=0), bypass_readonly=True)
+        finally:
+            self._suppress_input_change_hook = False
+
+    def _next_paste_token(self) -> str:
+        self._paste_token_seq += 1
+        return f"paste_{self._paste_token_seq}"
+
+    def _clear_paste_state(self) -> None:
+        self._active_paste_token = None
+        self._paste_placeholder_text = None
+        self._paste_payload_by_token.clear()
+
+    @staticmethod
+    def _find_inserted_segment(
+        previous_text: str,
+        current_text: str,
+    ) -> tuple[int, int, str] | None:
+        if len(current_text) <= len(previous_text):
+            return None
+
+        prefix = 0
+        max_prefix = min(len(previous_text), len(current_text))
+        while prefix < max_prefix and previous_text[prefix] == current_text[prefix]:
+            prefix += 1
+
+        previous_remaining = len(previous_text) - prefix
+        current_remaining = len(current_text) - prefix
+        suffix = 0
+        max_suffix = min(previous_remaining, current_remaining)
+        while (
+            suffix < max_suffix
+            and previous_text[len(previous_text) - 1 - suffix]
+            == current_text[len(current_text) - 1 - suffix]
+        ):
+            suffix += 1
+
+        start = prefix
+        end = len(current_text) - suffix
+        if end <= start:
+            return None
+        return start, end, current_text[start:end]
+
+    def _resolve_submit_texts(self, raw_text: str) -> tuple[str, str]:
+        stripped = raw_text.strip()
+        token = self._active_paste_token
+        placeholder = self._paste_placeholder_text
+        if token is not None and placeholder is not None and placeholder in raw_text:
+            payload = self._paste_payload_by_token.get(token)
+            if payload is not None:
+                submit_text = raw_text.replace(placeholder, payload, 1).strip()
+                # 在 history 中展示真实发送内容，避免显示占位符文本。
+                return submit_text, submit_text
+        return stripped, stripped
+
+    def _handle_large_paste(self, buffer: Any) -> bool:
+        if self._suppress_input_change_hook:
+            return False
+        if self._busy:
+            return False
+
+        text = str(buffer.text)
+        previous_text = self._last_input_text
+        self._last_input_len = len(text)
+        self._last_input_text = text
+
+        placeholder = self._paste_placeholder_text
+        if self._active_paste_token is not None and placeholder and placeholder in text:
+            return False
+
+        if (
+            self._active_paste_token is not None
+            and self._paste_placeholder_text is not None
+        ):
+            self._clear_paste_state()
+
+        threshold = max(1, int(self._paste_threshold_chars))
+        segment = self._find_inserted_segment(previous_text, text)
+        if segment is None:
+            return False
+        start, end, inserted_text = segment
+        if len(inserted_text) < threshold:
+            return False
+
+        token = self._next_paste_token()
+        self._active_paste_token = token
+        self._paste_payload_by_token[token] = inserted_text
+        placeholder = f"[Pasted Content {len(inserted_text)} chars]"
+        self._paste_placeholder_text = placeholder
+        replaced_text = f"{text[:start]}{placeholder}{text[end:]}"
+
+        self._suppress_input_change_hook = True
+        try:
+            buffer.cancel_completion()
+            buffer.set_document(
+                Document(replaced_text, cursor_position=start + len(placeholder)),
+                bypass_readonly=True,
+            )
+            self._last_input_len = len(replaced_text)
+            self._last_input_text = replaced_text
+        finally:
+            self._suppress_input_change_hook = False
+
+        self._invalidate()
+        return True
+
+    def _move_cursor_visual(self, buffer: Any, *, backward: bool) -> bool:
+        text = str(buffer.text)
+        if not text:
+            return False
+
+        width = self._terminal_width()
+        max_cols = max(1, width - self._input_prompt_width)
+        ranges = compute_visual_line_ranges(text, max_cols=max_cols)
+        if len(ranges) <= 1:
+            return False
+
+        cursor_index = int(buffer.cursor_position)
+        starts = [start for start, _end in ranges]
+        row = max(0, bisect_right(starts, cursor_index) - 1)
+        row_start, row_end = ranges[row]
+
+        current_col = visual_col_for_index(
+            text,
+            row_start,
+            row_end,
+            max_cols,
+            cursor_index,
+        )
+
+        target_row = row - 1 if backward else row + 1
+        if target_row < 0 or target_row >= len(ranges):
+            return False
+
+        target_start, target_end = ranges[target_row]
+        target_index = index_for_visual_col(
+            text, target_start, target_end, max_cols, current_col
+        )
+        buffer.cursor_position = target_index
+        return True
+
+    def _submit_from_input(self) -> None:
+        if self._ui_mode != UIMode.NORMAL:
+            return
+
+        raw_text = self._input_area.text
+        display_text, submit_text = self._resolve_submit_texts(raw_text)
+        if not submit_text.strip():
+            return
+
+        if self._input_area.buffer.complete_state is not None:
+            self._input_area.buffer.cancel_completion()
+        self._clear_input_area()
+
+        # busy 或 initializing 时：非斜杠命令 → 入队，斜杠命令 → 交由命令分发决定
+        is_busy = self._busy or self._initializing
+        if is_busy:
+            if display_text.lstrip().startswith("/"):
+                self._schedule_background(self._execute_command(display_text.strip()))
+                return
+
+            if not display_text.lstrip().startswith("/"):
+                queue_size = len(self._queued_messages)
+                if queue_size >= int(self._message_queue_max_size):
+                    self._renderer.append_system_message(
+                        f"消息队列已满（{queue_size}/{self._message_queue_max_size}），请等待当前任务完成。",
+                        severity="error",
+                    )
+                    self._refresh_layers()
+                    return
+                self._queued_messages.append(submit_text)
+                self._invalidate()
+                return
+
+        if display_text.lstrip().startswith("/"):
+            self._schedule_background(self._execute_command(display_text.strip()))
+            return
+
+        self._schedule_background(
+            self._submit_user_message(
+                submit_text,
+                display_text=display_text,
+            )
+        )