super-code-assistant 3.3.6__py3-none-any.whl

tui/query.py

@@ -0,0 +1,200 @@
+"""Run a single query turn with TUI feedback (spinner, markdown streaming)."""
+from __future__ import annotations
+
+import sys
+
+from rich.console import Console
+from rich.markup import escape as _escape
+
+from core.engine import AbortedError, Engine, _REJECT_MESSAGE, _SIBLING_REJECT_MESSAGE
+from tui.keylistener import EscListener
+from tui.rendering import (StreamingMarkdown, SpinnerManager, tool_preview, collapsed_tool_summary,
+                           SPINNER_THINKING, SPINNER_COMPACT, SPINNER_PREPARING, SPINNER_WORKING)
+
+console = Console()
+
+
+def run_query(engine: Engine, user_input: str, print_mode: bool,
+              permissions=None, quiet: bool = False) -> None:
+
+    listener = EscListener(on_cancel=engine.abort)  # 创建一个 Esc 键监听器，当用户按下 Esc 键时自动调用 engine.abort() 方法来中断引擎正在执行的任务
+    spinner = SpinnerManager(console)
+    md_stream = StreamingMarkdown(console)
+    first_text = True       # 标记是否是第一次接收到文本内容，以便在首次收到文本时停止加载动画并切换到流式渲染模式
+    streaming = False       # 追踪当前是否处于流式文本输出状态，配合 Esc 键监听实现中途取消功能。
+    # 键(key)是 tool_use_id（API 分配的唯一 id），值(value)是 (工具名, 用于终端显示的带箭头格式化字符串)。
+    # 使用 id 而非 "tool_name(preview)" 字符串作 key，避免同名工具（如两个 Grep 用相同 pattern）
+    # 因 key 碰撞导致第二条记录覆盖第一条，进而使 pending_tools 永远无法清空，spinner 卡死。
+    pending_tools: dict[str, tuple[str, str]] = {}
+
+    try:
+        with listener:
+            if not quiet:
+                spinner.start("Thinking…", SPINNER_THINKING)
+
+            for event in engine.submit(user_input):
+                if not quiet and streaming and listener.pressed:
+                    md_stream.flush()
+                    spinner.stop()
+                    engine.cancel_turn()
+                    console.print("\n[dim yellow]⏹ Turn cancelled (Esc)[/dim yellow]")
+                    return
+
+                if event[0] == "thinking":
+                    if not quiet and first_text:
+                        spinner.start("Thinking…", SPINNER_THINKING)
+
+                elif event[0] == "compact":
+                    # 轮内紧急压缩：在工具链中途触发，显示专用提示
+                    if not quiet:
+                        md_stream.flush()
+                        spinner.start("Compacting context…", SPINNER_COMPACT)
+
+                elif event[0] == "stale_reclaim":
+                    # 过期 Read 结果回收：发送前替换掉已被后续编辑的旧版本内容
+                    if not quiet:
+                        md_stream.flush()
+                        stats = event[1]
+                        n = stats.get("reclaimed", 0)
+                        chars = stats.get("chars_removed", 0)
+                        console.print(
+                            f"[dim]Reclaimed {n} stale read result(s) "
+                            f"(−{chars:,} chars)[/dim]"
+                        )
+                        spinner.start("Thinking…", SPINNER_THINKING)
+
+                elif event[0] == "notification":
+                    # worker 完成通知：engine 在 mid-turn 注入了通知到对话中
+                    if not quiet:
+                        md_stream.flush()
+                        count = event[1].count("<task-notification>")
+                        console.print(
+                            f"[dim]Worker completed ({count}).[/dim]" if count > 1
+                            else "[dim]Worker completed.[/dim]"
+                        )
+                        spinner.start("Thinking…", SPINNER_THINKING)
+
+                elif event[0] == "text":
+                    if quiet:
+                        continue
+                    if first_text:
+                        spinner.stop()
+                        streaming = True
+                        first_text = False
+                    if print_mode:
+                        print(event[1], end="", flush=True)
+                    else:
+                        md_stream.feed(event[1])
+
+                elif event[0] == "waiting":
+                    if not quiet:
+                        md_stream.flush()
+                    streaming = False
+                    if not quiet:
+                        spinner.start("Preparing tool call…", SPINNER_PREPARING)
+
+                elif event[0] == "tool_call":
+                    if not quiet:
+                        spinner.stop()
+                        streaming = False
+                        # event 格式: ("tool_call", tool_name, tool_input, activity, tool_use_id)
+                        # 用 tool_use_id 作 key，保证同名工具（如两个 Grep）各自独立追踪，不会 key 碰撞
+                        _, tool_name, tool_input, activity, tool_id = event
+                        preview = tool_preview(tool_name, tool_input)
+                        line = f"↳ {tool_name}({preview})"
+                        pending_tools[tool_id] = (tool_name, line)
+
+                elif event[0] == "tool_executing":
+                    if not quiet:
+                        # event 格式: ("tool_executing", tool_name, tool_input, activity, tool_use_id)
+                        _, tool_name, tool_input, activity, tool_id = event
+                        # 交互式工具（AskUserQuestion）执行期间需要独占 terminal 等用户输入，
+                        # Rich Live spinner 的后台重绘会与 input() 的行编辑抢光标控制，导致
+                        # 用户按键被吞、卡住直到按 Enter 才返回。这里显式不启 spinner，让
+                        # 工具自己拥有 terminal；工具返回后 tool_result 路径正常 stop()。
+                        if tool_name == "AskUserQuestion":
+                            spinner.stop()
+                        else:
+                            n = len(pending_tools)
+                            if n > 1:
+                                names = [tn for tn, _ in pending_tools.values()]
+                                spinner.start(collapsed_tool_summary(names), SPINNER_WORKING)
+                            else:
+                                _, line = pending_tools.get(tool_id, ("", f"↳ {tool_name}"))
+                                activity_text = activity or f"Running {tool_name}…"
+                                spinner.start(f"{line} … {activity_text}", SPINNER_WORKING)
+
+                elif event[0] == "tool_result":
+                    if not quiet:
+                        spinner.stop()
+                        # event 格式: ("tool_result", tool_name, tool_input, result, tool_use_id)
+                        # 用 tool_use_id pop，精确匹配对应的 tool_call，不受工具名或参数重复影响
+                        _, tool_name, tool_input, result, tool_id = event
+                        tname, line = pending_tools.pop(tool_id, (tool_name, f"↳ {tool_name}"))
+                        if result.is_error:
+                            console.print(f"  [dim]{_escape(line)}[/dim] [red]✗[/red]", highlight=False)
+                            # REJECT_MESSAGE / SIBLING_REJECT_MESSAGE 是给 LLM 看的硬
+                            # 指令体（"STOP what you are doing..."），不是用户视角的错误
+                            # 信息——用户主动拒的工具再把这串硬指令红字读一遍很多余。
+                            # 真实工具失败（Bash 报错、Read 文件不存在等）仍然正常显示。
+                            if result.content not in (_REJECT_MESSAGE, _SIBLING_REJECT_MESSAGE):
+                                console.print(f"    [red]{_escape(result.content[:200])}[/red]")
+                        else:
+                            console.print(f"  [dim]{_escape(line)}[/dim] [green]✓[/green]", highlight=False)
+                        if pending_tools:
+                            names = [tn for tn, _ in pending_tools.values()]
+                            spinner.start(collapsed_tool_summary(names), SPINNER_WORKING)
+                        else:
+                            streaming = False
+                            spinner.start("Thinking…", SPINNER_THINKING)
+                            first_text = True
+
+                elif event[0] == "error":
+                    if not quiet:
+                        md_stream.flush()
+                        spinner.stop()
+                        console.print(f"\n[bold red]{_escape(event[1])}[/bold red]")
+
+                elif event[0] == "turn_aborted_by_deny":
+                    # engine 检测到本轮发生过 deny → 硬结束 turn，给一行收尾提示，
+                    # 避免用户看到一堆 ✗ 后突然回输入框疑惑。
+                    if not quiet:
+                        md_stream.flush()
+                        spinner.stop()
+                        console.print("[dim yellow]⏹ Stopped after tool use rejected. Type your next message.[/dim yellow]")
+
+            md_stream.flush()
+            spinner.stop()
+    except (AbortedError, KeyboardInterrupt):
+        md_stream.flush()
+        spinner.stop()
+        if not isinstance(sys.exc_info()[1], AbortedError):
+            engine.cancel_turn()
+        if not quiet:
+            console.print("\n[dim yellow]⏹ Turn cancelled[/dim yellow]")
+        return
+    finally:
+        md_stream.flush()
+        spinner.stop()
+
+    if not print_mode:
+        console.print()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tui/rendering.py

@@ -0,0 +1,135 @@
+"""Streaming markdown renderer and spinner manager for the TUI."""
+from __future__ import annotations
+
+import re
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown as RichMarkdown
+from rich.spinner import Spinner
+from rich.text import Text
+
+_BLOCK_BOUNDARY_RE = re.compile(r"\n(?=\n|\#{1,6} |```|---|\* |- |\d+\. )")
+
+# 各 UI 场景专属 spinner 风格（Rich 内置）与配色，让不同状态一眼可辨、告别全场景单一灰白 dots。
+# 元组格式: (动画风格名, Rich 颜色名)，start() 里解包。
+SPINNER_THINKING = ("dots8", "cyan")           # 思考中：点阵旋转（青，冷静）
+SPINNER_COMPACT = ("arc", "yellow")            # 上下文压缩：圆弧转动（黄，整理收拢）
+SPINNER_PREPARING = ("line", "bright_blue")    # 准备工具调用：短线脉冲（蓝，待命）
+SPINNER_WORKING = ("bouncingBar", "green")     # 工具执行中：弹跳条（绿，干活推进）
+SPINNER_MEMORY = ("star", "magenta")           # 记忆检索：星光闪烁（品红，联想检索）
+
+
+class StreamingMarkdown:
+    def __init__(self, console: Console):
+        self._console = console
+        self._buf = ""
+        self._stable_len = 0
+        self._live: Live | None = None
+
+    def feed(self, chunk: str) -> None:
+        self._buf += chunk
+        self._render()
+
+    def _render(self) -> None:  # 智能区分并分别渲染稳定文本和不完整文本：将已完成的 Markdown 块直接打印到终端，而将正在接收中的不完整部分用 Live 组件动态刷新以实现打字机效果。
+        text = self._buf
+        boundary = self._stable_len
+        for m in _BLOCK_BOUNDARY_RE.finditer(text, self._stable_len):
+            boundary = m.start()
+        if boundary > self._stable_len:
+            if self._live is not None:
+                self._live.stop()
+                self._live = None
+            stable_text = text[self._stable_len:boundary]
+            self._console.print(RichMarkdown(stable_text), end="")
+            self._stable_len = boundary
+        unstable = text[self._stable_len:]
+        if unstable:
+            if self._live is None:
+                self._live = Live(RichMarkdown(unstable), console=self._console,
+                                  refresh_per_second=8, transient=True)
+                self._live.start()
+            else:
+                self._live.update(RichMarkdown(unstable))
+
+    def flush(self) -> None:    # 强制完成所有剩余文本的渲染并清空缓冲区，确保流式传输结束时没有内容遗漏。
+        if self._live is not None:
+            self._live.stop()
+            self._live = None
+        remaining = self._buf[self._stable_len:]
+        if remaining:
+            self._console.print(RichMarkdown(remaining), end="")
+        self._buf = ""
+        self._stable_len = 0
+
+
+class SpinnerManager:
+    def __init__(self, console: Console):
+        self._console = console
+        self._live: Live | None = None
+        self._spinner: Spinner | None = None
+        self._spinner_name: str | tuple | None = None   # 当前 (风格名, 颜色) 配置（Rich Spinner 不保存 name，需自己记录）
+
+    def start(self, text: str = "Thinking…", spinner: str | tuple[str, str] = "dots"):
+        # 启动带提示文本的加载动画，每秒刷新12次且结束后自动消失。
+        # spinner 参数：Rich 动画风格名，或 (风格名, 颜色) 元组（见上方 SPINNER_* 常量）；
+        # 只传风格名时默认青色。帧与文字同色，去掉 dim 避免灰白。
+        name, color = spinner if isinstance(spinner, tuple) else (spinner, "cyan")
+        # 幂等：Live 已在运行时只原地换文本，不销毁重建。思考模型按 token 高频
+        # 产生 thinking 事件，若每次都 stop+重建（清屏+重启刷新线程），spinner 会
+        # 忽隐忽现、出现"没反应"的空窗。复用同一个 Spinner 实例避免动画相位重置。
+        # 但请求的风格/颜色与当前不同（场景切换）时必须重建，否则换不了动画。
+        if self._live is not None and self._spinner is not None:
+            if self._spinner_name != spinner:
+                self._live.stop()
+                self._live = None
+                self._spinner = None
+            else:
+                self._spinner.text = Text(text, style=color)
+                self._live.update(self._spinner)
+                return
+        self._spinner = Spinner(name, text=Text(text, style=color), style=color)
+        self._spinner_name = spinner
+        self._live = Live(
+            self._spinner,
+            console=self._console, refresh_per_second=12, transient=True,
+        )
+        self._live.start()
+
+    def stop(self):                     # 停止并清除当前正在显示的加载动画。
+        if self._live is not None:
+            self._live.stop()
+            self._live = None
+
+
+def tool_preview(tool_name: str, tool_input: dict) -> str:    # 根据工具类型生成简洁的工具调用预览文本，用于在界面上显示即将执行的操作摘要。
+    if tool_name == "Bash":
+        cmd = tool_input.get("command", "")
+        return cmd[:80] + ("…" if len(cmd) > 80 else "")
+    if tool_name in ("Read", "Edit", "Write"):
+        fp = tool_input.get("file_path", "")
+        from pathlib import Path
+        return Path(fp).name if fp else ""
+    if tool_name in ("Glob", "Grep"):
+        pat = tool_input.get("pattern", "")
+        p = tool_input.get("path", "")
+        return f"{pat} in {p}" if p else pat
+    return ""
+
+
+def collapsed_tool_summary(tool_names: list[str]) -> str:  # 是将多个工具调用按类型统计并生成简洁的汇总描述文本，用" · "连接显示。
+    from collections import Counter
+    counts = Counter(tool_names)
+    _LABELS = {
+        "Read": ("Reading {n} files", "Reading file"),
+        "Glob": ("Searching {n} patterns", "Searching"),
+        "Grep": ("Searching {n} patterns", "Searching"),
+        "Bash": ("Running {n} commands", "Running command"),
+        "Edit": ("Editing {n} files", "Editing file"),
+        "Write": ("Writing {n} files", "Writing file"),
+    }
+    parts = []
+    for name, n in counts.items():
+        plural, singular = _LABELS.get(name, (f"{name} ×{{n}}", name))
+        parts.append(plural.format(n=n) if n > 1 else singular)
+    return " · ".join(parts) + "…"