zrcoder 0.3.0__tar.gz → 0.4.0__tar.gz

{zrcoder-0.3.0 → zrcoder-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zrcoder
-Version: 0.3.0
+Version: 0.4.0
 Summary: Terminal coding agent chat — OpenAI-compatible APIs, tools, and slash commands
 Keywords: cli,agent,coding,terminal,openai
 Author: Zr

{zrcoder-0.3.0 → zrcoder-0.4.0}/core/agent/core.py

@@ -8,10 +8,10 @@ from urllib.parse import urlparse, urlunparse
 
 from dotenv import load_dotenv
 from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.providers.openai import OpenAIProvider
 
 from .hooks import hooks
-from .openai_compat import CompatibleOpenAIChatModel
 from .tools import TOOLS
 
 load_dotenv()
@@ -41,7 +41,7 @@ def _normalize_openai_base_url(url: str) -> str:
 
 MODEL_NAME = os.environ.get("MODEL_NAME", "deepseek-v4-flash")
 
-model = CompatibleOpenAIChatModel(
+model = OpenAIChatModel(
     MODEL_NAME,
     provider=OpenAIProvider(base_url=_normalize_openai_base_url(BASE_URL), api_key=API_KEY),
 )

{zrcoder-0.3.0 → zrcoder-0.4.0}/core/agent/hooks.py

@@ -2,7 +2,8 @@
 挂在 Agent 上的 hooks：
 1. API 调用元数据记录（/api-detail 命令用）
 2. API 请求失败时的自动重试（wrap_model_request）
-3. 工具执行异常的兜底处理（on_tool_execute_error）
+3. 工具调用权限检查（on_tool_execute）
+4. 工具执行异常的兜底处理（on_tool_execute_error）
 """
 
 from __future__ import annotations
@@ -14,6 +15,7 @@ from typing import Any
 from pydantic_ai.capabilities import Hooks
 from pydantic_ai.exceptions import ModelAPIError, ModelHTTPError, UnexpectedModelBehavior
 
+from core import permissions
 from core.ui.render import console
 
 MAX_RETRIES = 3
@@ -132,6 +134,36 @@ async def _retry_on_error(ctx: Any, *, request_context: Any, handler: Any) -> An
     raise RuntimeError("unreachable")  # pragma: no cover
 
 
+# ---------- 工具调用权限检查 ----------
+
+
+@hooks.on.tool_execute
+async def _check_permission(ctx: Any, *, call: Any, tool_def: Any, args: Any, handler: Any) -> Any:
+    """
+    工具执行前的权限关卡。allow 就调用 handler 真正执行；
+    ask 就弹审批列表；deny 则把拒绝原因当作工具结果回填，让模型自行纠正。
+    """
+    decision = permissions.compute_decision(call.tool_name, args)
+    if decision == "allow":
+        # 放行，handler(args) 才是真正执行工具的那一步
+        return await handler(args)
+
+    # decision == "ask"，弹审批让用户决定
+    choice = await permissions.prompt_approval(call.tool_name, args)
+    if choice == "once":
+        return await handler(args)
+    if choice == "always":
+        # 记进会话白名单，本会话内这个工具不再询问
+        permissions.state.session_allowed.add(call.tool_name)
+        return await handler(args)
+
+    # 拒绝：不执行工具，把拒绝原因回填给模型，让它停下来等用户发话，而不是自作主张绕过去
+    return (
+        f"用户拒绝了对 {call.tool_name} 的调用，这次调用没有执行。"
+        "请停下手上的事，等用户告诉你接下来该怎么做。"
+    )
+
+
 # ---------- 工具执行异常兜底 ----------
 
 

{zrcoder-0.3.0 → zrcoder-0.4.0}/core/agent/tools.py

@@ -6,10 +6,16 @@ Coding Agent 用到的三个工具：读文件、写文件、跑 shell 命令。
 意料之外的异常由 hooks 里的 on_tool_execute_error 统一兜底。
 """
 
+from __future__ import annotations
+
+import re
 import subprocess
+from typing import Any
 
 from pydantic_ai.exceptions import ModelRetry
 
+from core import permissions
+
 
 def read_file(path: str) -> str:
     """
@@ -62,5 +68,29 @@ def run_command(command: str) -> str:
         return f"[错误] 无法执行命令 ({e})"
 
 
+# 高危命令的特征：删除文件、提权、直写磁盘
+DANGEROUS_PATTERNS = [
+    r"\brm\b",
+    r"\bsudo\b",
+    r"\bdd\b",
+    r"\bmkfs\w*\b",
+]
+
+
+def run_command_self_check(args: dict[str, Any]) -> str | None:
+    """
+    run_command 的权限自检：扫一遍命令字符串，命中高危特征就要求审批。
+    误伤的代价不过是多弹一次窗，绝不能把真正的高危命令漏过去。
+    """
+    command = str(args.get("command", ""))
+    if any(re.search(pattern, command) for pattern in DANGEROUS_PATTERNS):
+        return "ask"
+    # 没命中高危特征，交给通用规则决定
+    return None
+
+
+# 把自检挂到权限模块的注册表上
+permissions.register_self_check("run_command", run_command_self_check)
+
 # Pydantic AI 支持 tools=[plain_function]，从函数签名 + docstring 自动生成 JSON Schema
 TOOLS = [read_file, write_file, run_command]

{zrcoder-0.3.0 → zrcoder-0.4.0}/core/cli.py

@@ -5,44 +5,27 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 from typing import Any, Literal
 
-from prompt_toolkit import PromptSession
 from pydantic_ai import Agent
 from pydantic_graph import End
 
 from core.agent import MODEL_NAME, agent, api_call_log
 from core.session import append_messages, new_session_id
-from core.ui.commands import COMMANDS, SessionState, print_divider, print_part
+from core.ui.commands import COMMANDS, SessionState, print_part
+from core.ui.input import Repl
 from core.ui.render import console, print_welcome_banner
 
-# PromptSession 比内置 input() 好用：支持左右移光标编辑，并记住本次输入历史
-prompt_session: PromptSession[str] = PromptSession()
-
 CommandAction = Literal["pass", "continue", "break"]
 
 
-def read_user_input() -> str | None:
-    """
-    打印上横线并读一行用户输入；回车后再补一条下横线。
-    返回 None 表示用户希望退出（Ctrl-C / Ctrl-D）。
-    """
-    print_divider()
-    try:
-        user_input = prompt_session.prompt("❯ ").strip()
-    except (EOFError, KeyboardInterrupt):
-        print()
-        return None
-    print_divider()
-    return user_input
-
-
-def handle_command(user_input: str, state: SessionState) -> CommandAction:
+async def handle_command(user_input: str, state: SessionState) -> CommandAction:
     """
     处理以 / 开头的命令。
-    返回 'pass'：不是命令，主循环继续往下走交给 Agent；
-    返回 'continue'：命令已处理，主循环跳到下一轮；
-    返回 'break'：命令要求退出主循环。
+    返回 'pass'：不是命令，交给 Agent；
+    返回 'continue'：命令已处理，进入下一轮；
+    返回 'break'：命令要求退出程序。
     """
     if not user_input.startswith("/"):
         return "pass"
@@ -51,7 +34,11 @@ def handle_command(user_input: str, state: SessionState) -> CommandAction:
     if command is None:
         console.print(f"未知命令：/{cmd_name}，输入 /help 查看可用命令\n")
         return "continue"
-    return "continue" if command.handler(state) else "break"
+    result = command.handler(state)
+    # 个别命令（如 /resume）要弹交互式列表，是异步的，需要 await
+    if inspect.isawaitable(result):
+        result = await result
+    return "continue" if result else "break"
 
 
 def apply_result(state: SessionState, result: Any) -> None:
@@ -92,35 +79,40 @@ async def run_agent_loop(user_input: str, state: SessionState) -> None:
     console.print()
 
 
-def main() -> None:
+async def async_main() -> None:
     state = SessionState(
         model_name=MODEL_NAME,
         session_id=new_session_id(),
     )
     print_welcome_banner("Zrcoder")
 
-    while True:
-        # 读用户输入
-        user_input = read_user_input()
-        if user_input is None:
-            break
-        if not user_input:
-            continue
+    # 常驻输入区：输入框整个会话期间不消失
+    repl = Repl(state)
 
-        # 处理 / 开头的命令
-        action = handle_command(user_input, state)
+    async def on_submit(user_input: str) -> None:
+        # 每次回车提交一行输入，都走这里
+        # 先处理 / 开头的命令
+        action = await handle_command(user_input, state)
         if action == "break":
-            break
+            # 命令要求退出，结束常驻输入区
+            repl.exit()
+            return
         if action == "continue":
-            continue
-
-        # 核心 Agent 循环：自己驱动节点流转，实时打印每一步
-        try:
-            asyncio.run(run_agent_loop(user_input, state))
-        except KeyboardInterrupt:
-            console.print("\n[bold yellow]已中断[/]\n")
-        except Exception as e:
-            console.print(f"\n[bold red]✗ {type(e).__name__}: {e}[/]\n")
+            return
+
+        # 核心 Agent 循环：开请求时显示 working...，结束 / 被打断后由 Repl 统一隐藏；
+        # 中途按 ESC / Ctrl+C 会打断
+        repl.start_working()
+        await run_agent_loop(user_input, state)
+
+    await repl.run(on_submit)
+
+
+def main() -> None:
+    try:
+        asyncio.run(async_main())
+    except (KeyboardInterrupt, EOFError):
+        pass
 
 
 if __name__ == "__main__":

zrcoder-0.4.0/core/permissions.py

@@ -0,0 +1,234 @@
+"""
+权限管控：工具执行前，根据当前权限模式决定放行、询问还是拒绝。
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from prompt_toolkit.application import Application, in_terminal
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.layout import HSplit, Layout, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.styles import Style
+
+# 三种权限模式
+# default：写文件、跑命令要授权，读文件等只读操作自动放行
+DEFAULT = "default"
+# acceptEdits：读写文件自动放行，其他工具仍需授权
+ACCEPT_EDITS = "acceptEdits"
+# bypass：一切放行，不再询问
+BYPASS = "bypass"
+
+# 权限模式按 Shift+Tab 循环切换的顺序
+MODES = [DEFAULT, ACCEPT_EDITS, BYPASS]
+
+# 只读工具，任何模式都自动放行（读取不会改动系统，放行没风险）
+READONLY_TOOLS = {"read_file"}
+# 编辑文件类工具，acceptEdits 模式下自动放行
+EDIT_TOOLS = {"write_file"}
+
+# 工具自检：接收 args，返回 "ask" 表示要求审批，返回 None 表示交给通用规则
+SelfCheck = Callable[[dict[str, Any]], str | None]
+
+# 工具自检注册表：通用权限规则只认工具名，但危不危险往往取决于参数，只有工具自己最懂参数的语义
+TOOL_SELF_CHECKS: dict[str, SelfCheck] = {}
+
+
+def register_self_check(tool_name: str, check: SelfCheck) -> None:
+    """
+    工具模块调用它挂上自己的自检函数；
+    自检接收 args，返回 "ask" 表示要求审批，返回 None 表示交给通用规则。
+    """
+    TOOL_SELF_CHECKS[tool_name] = check
+
+
+@dataclass
+class PermissionState:
+    """
+    进程级权限状态：当前模式，加上本会话的放行白名单。
+    权限模式是进程级的：跨 /new、/resume 保持，不写进 jsonl，重启程序才回到 default。
+    白名单是会话级的：用 /new、/resume 切换会话时会清空。
+    """
+
+    # 当前权限模式
+    mode: str = DEFAULT
+    # 本会话内点过「不再询问」的工具名，后续直接放行
+    session_allowed: set[str] = field(default_factory=set)
+
+
+state = PermissionState()
+
+
+def compute_decision(tool_name: str, args: dict[str, Any]) -> str:
+    """
+    纯规则判定：在当前模式下，对给定的工具调用返回 "allow" 或 "ask"。
+    """
+    # bypass 模式：全部放行，连工具自检都不再过问（用户主动选择了这个模式，后果自负）
+    if state.mode == BYPASS:
+        return "allow"
+    # 工具自检：自检要求审批的调用，会话白名单也盖不过
+    check = TOOL_SELF_CHECKS.get(tool_name)
+    if check and check(args) == "ask":
+        return "ask"
+    # 本会话点过「不再询问」的工具：放行
+    if tool_name in state.session_allowed:
+        return "allow"
+    # 只读工具：任何模式都自动放行
+    if tool_name in READONLY_TOOLS:
+        return "allow"
+    # acceptEdits 模式：编辑文件放行，命令等其他工具仍要审批
+    if state.mode == ACCEPT_EDITS and tool_name in EDIT_TOOLS:
+        return "allow"
+    # default 模式，或没命中任何放行规则：询问用户
+    return "ask"
+
+
+def cycle_mode() -> str:
+    """
+    按 default -> acceptEdits -> bypass -> default 循环切换。
+    """
+    index = MODES.index(state.mode)
+    state.mode = MODES[(index + 1) % len(MODES)]
+    return state.mode
+
+
+# 可能装着整份文件内容的参数，预览里只留开头；命令、路径等参数完整展示
+BULKY_ARGS = {"content", "old_string", "new_string"}
+
+
+def _format_call(tool_name: str, args: dict[str, Any]) -> str:
+    """
+    把一次工具调用渲染成审批预览，例如 run_command(command=npm test)。
+    """
+
+    def show(key: str, value: Any) -> str:
+        text = " ".join(str(value).split())
+        if key in BULKY_ARGS and len(text) > 60:
+            return text[:60] + "..."
+        return text
+
+    inner = ", ".join(f"{key}={show(key, value)}" for key, value in args.items())
+    return f"{tool_name}({inner})"
+
+
+_STYLE = Style.from_dict(
+    {
+        "question": "bold",
+        "label-current": "#3b82f6 bold",
+        "label": "",
+        "footer": "#6b7280",
+    }
+)
+
+
+class _ApprovalPicker:
+    """
+    手绘单选审批 picker，视觉对齐 ask_user_question 的 picker。
+    """
+
+    def __init__(self, question: str, options: list[tuple[str, str]]) -> None:
+        # options 是 (value, label) 列表
+        self.question = question
+        self.options = options
+        self.cursor = 0
+        # 选中项的 value；取消时保持 None，run() 据此返回 deny
+        self.result: str | None = None
+        self.app = self._build_app()
+
+    def _render_question(self) -> FormattedText:
+        return FormattedText([("class:question", self.question)])
+
+    def _render_options(self) -> FormattedText:
+        lines: list[tuple[str, str]] = []
+        for i, (_value, label) in enumerate(self.options):
+            is_cursor = i == self.cursor
+            pointer = "❯" if is_cursor else " "
+            cls_label = "class:label-current" if is_cursor else "class:label"
+            lines.append((cls_label, f" {pointer}  {i + 1}. {label}"))
+            lines.append(("", "\n"))
+        return FormattedText(lines)
+
+    def _render_footer(self) -> FormattedText:
+        return FormattedText([("class:footer", "  ↑↓ 选择 · Enter 确认 · Esc 取消")])
+
+    def _move(self, delta: int) -> None:
+        self.cursor = (self.cursor + delta) % len(self.options)
+
+    def _build_app(self) -> Application[None]:
+        kb = KeyBindings()
+
+        # 堆叠装饰器让一个回调绑定多个键（kb.add 多参数是「按键序列」而非「任选其一」）
+        @kb.add("up")
+        @kb.add("k")
+        def _(event: KeyPressEvent) -> None:
+            self._move(-1)
+
+        @kb.add("down")
+        @kb.add("j")
+        def _(event: KeyPressEvent) -> None:
+            self._move(1)
+
+        @kb.add("enter")
+        def _(event: KeyPressEvent) -> None:
+            self.result = self.options[self.cursor][0]
+            self.app.exit()
+
+        @kb.add("escape")
+        @kb.add("c-c")
+        def _(event: KeyPressEvent) -> None:
+            self.app.exit()
+
+        # always_hide_cursor 藏掉终端光标，否则会落在左上角压住问句首字
+        layout = Layout(
+            HSplit(
+                [
+                    Window(
+                        FormattedTextControl(self._render_question),
+                        wrap_lines=True,
+                        dont_extend_height=True,
+                        always_hide_cursor=True,
+                    ),
+                    Window(
+                        FormattedTextControl(self._render_options),
+                        dont_extend_height=True,
+                        always_hide_cursor=True,
+                    ),
+                    Window(
+                        FormattedTextControl(self._render_footer), height=1, always_hide_cursor=True
+                    ),
+                ]
+            )
+        )
+        return Application(
+            layout=layout,
+            key_bindings=kb,
+            style=_STYLE,
+            full_screen=False,
+            mouse_support=False,
+            # 选完擦掉整个 picker，滚动区里不留下选项
+            erase_when_done=True,
+        )
+
+    async def run(self) -> str:
+        await self.app.run_async()
+        return self.result if self.result is not None else "deny"
+
+
+async def prompt_approval(tool_name: str, args: dict[str, Any]) -> str:
+    """
+    工具执行前弹出审批 picker，返回 "once" / "always" / "deny"。
+    """
+    options = [
+        ("once", "允许"),
+        ("always", f"允许，且本会话不再询问 {tool_name}"),
+        ("deny", "拒绝"),
+    ]
+    async with in_terminal():
+        question = f"是否允许执行 {_format_call(tool_name, args)}？"
+        choice = await _ApprovalPicker(question, options).run()
+    return choice

{zrcoder-0.3.0 → zrcoder-0.4.0}/core/ui/commands.py

@@ -1,16 +1,19 @@
-from collections.abc import Callable, Iterable
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Iterable
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any
 
 import questionary
+from prompt_toolkit.application import in_terminal
 from rich.console import Console, ConsoleOptions, RenderResult
 from rich.markdown import Heading, Markdown
 from rich.markup import escape
 from rich.padding import Padding
 from rich.rule import Rule
 
-from core import session
+from core import permissions, session
 
 from .render import console, print_step
 
@@ -50,8 +53,8 @@ class SessionState:
 class Command:
     name: str
     description: str
-    # handler 返回 False 表示主循环应当退出
-    handler: Callable[[SessionState], bool]
+    # handler 返回 False 表示主循环应当退出；可同步也可异步（如 /resume）
+    handler: Callable[[SessionState], bool | Awaitable[bool]]
 
 
 def print_divider() -> None:
@@ -163,13 +166,15 @@ def cmd_help(state: SessionState) -> bool:
 
 def cmd_new(state: SessionState) -> bool:
     """
-    开启新会话：清空历史、token 计数、API 调用记录，并换一个 session_id。
+    开启新会话：清空历史、token 计数、API 调用记录，换一个新的会话 ID。
     """
     state.history.clear()
     state.input_tokens = 0
     state.output_tokens = 0
     state.last_api_calls.clear()
     state.session_id = session.new_session_id()
+    # 权限白名单是会话级的，「本会话不再询问」不该带进新会话
+    permissions.state.session_allowed.clear()
     console.print("已开启新会话\n")
     return True
 
@@ -184,9 +189,10 @@ def _summary_line(mtime: datetime, prompt: str) -> str:
     return f"{mtime:%m-%d %H:%M}  {prompt}"
 
 
-def cmd_resume(state: SessionState) -> bool:
+async def cmd_resume(state: SessionState) -> bool:
     """
     列出当前项目的历史会话，选中后恢复对话历史。
+    它跑在 REPL 的事件循环里，所以是异步的：in_terminal 把终端让给 questionary，结束后再恢复输入框。
     """
     sessions = session.list_sessions()
     if not sessions:
@@ -197,10 +203,10 @@ def cmd_resume(state: SessionState) -> bool:
         questionary.Choice(title=_summary_line(mtime, prompt), value=sid)
         for sid, mtime, prompt in sessions
     ]
-    selected = questionary.select(
-        "选择要恢复的会话（上下键移动，回车确认）：",
-        choices=choices,
-    ).ask()
+    async with in_terminal():
+        selected = await questionary.select(
+            "选择要恢复的会话（上下键移动，回车确认）：", choices=choices
+        ).ask_async()
     # 用户按 Ctrl+C 取消选择
     if selected is None:
         return True
@@ -208,6 +214,8 @@ def cmd_resume(state: SessionState) -> bool:
     # 还原对话历史，并把会话 ID 切换成选中的旧会话，后续消息继续追加到同一个文件
     state.history = session.load_history(selected)
     state.session_id = selected
+    # 权限白名单是会话级的，切换会话后清空
+    permissions.state.session_allowed.clear()
 
     # jsonl 里每条模型回复都带 usage，把会话的 token 用量累加回来
     state.input_tokens = sum(
@@ -223,6 +231,7 @@ def cmd_resume(state: SessionState) -> bool:
     console.print(f"\n已恢复会话 {selected[:8]}，共 {len(state.history)} 条消息：\n")
     for msg in state.history:
         for part in msg.parts:
+            # 回放和实时输出共用同一套 part 渲染逻辑
             print_part(part)
     console.print()
     return True
@@ -230,7 +239,7 @@ def cmd_resume(state: SessionState) -> bool:
 
 def cmd_status(state: SessionState) -> bool:
     console.print(f"模型：           {state.model_name}")
-    console.print(f"会话 ID：        {state.session_id or '(无)'}")
+    console.print(f"权限模式：       {permissions.state.mode}")
     console.print(f"历史消息条数：    {len(state.history)}")
     console.print(f"累计输入 tokens：{state.input_tokens}")
     console.print(f"累计输出 tokens：{state.output_tokens}\n")

zrcoder-0.4.0/core/ui/input.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Awaitable, Callable
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.layout.containers import ConditionalContainer, HSplit, Window
+from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.patch_stdout import patch_stdout
+from rich.markup import escape
+
+from core import permissions
+
+from .commands import SessionState
+from .render import console
+
+# 常驻输入区：输入框整个会话期间挂在屏幕底部不消失，
+# Agent 输出通过 patch_stdout 打印在它上方，请求期间按 ESC / Ctrl+C 能立刻打断。
+
+# working 指示器的转圈动画帧
+_SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+class Repl:
+    # 常驻输入区，由 main 注入 on_submit 回调来处理每一行输入
+
+    def __init__(self, state: SessionState) -> None:
+        self.state = state
+        # on_submit 由 main 注入，处理一行输入（命令或交给 Agent）
+        self._on_submit: Callable[[str], Awaitable[None]] | None = None
+        # 当前处理输入的后台任务，ESC / Ctrl+C 据此打断；None 表示空闲
+        self._task: asyncio.Task[None] | None = None
+        # 是否正在请求模型，决定上方 working... 指示器的显隐
+        self.working = False
+        self._work_start = 0.0
+        self._frame = 0
+        self._buffer = Buffer(multiline=False, history=InMemoryHistory())
+        self.app = self._build_app()
+
+    def _prompt_prefix(self, line_number: int, wrap_count: int) -> HTML:
+        return HTML("<ansicyan>❯ </ansicyan>")
+
+    def _working_line(self) -> HTML:
+        # 输入框上方那行：转圈帧 + 已耗时 + 打断提示，只在请求期间显示
+        frame = _SPINNER[self._frame % len(_SPINNER)]
+        elapsed = int(time.monotonic() - self._work_start)
+        return HTML(
+            f"<ansigreen>{frame}</ansigreen> <b>Working…</b>"
+            f"<ansibrightblack>（已耗时 {elapsed}s · 按 esc 打断）</ansibrightblack>"
+        )
+
+    def _mode_line(self) -> HTML:
+        # 输入框下方那行：当前权限模式 + 切换提示
+        mode = permissions.state.mode
+        return HTML(
+            f"  <ansimagenta><b>▶▶ {mode}</b></ansimagenta>"
+            f"<ansibrightblack>（Shift+Tab 切换）</ansibrightblack>"
+        )
+
+    def _divider(self) -> Window:
+        # 一条横向分割线
+        return Window(height=1, char="─", style="fg:ansibrightblack")
+
+    def _build_app(self) -> Application[None]:
+        # 从上到下：working 指示器、分割线、输入行、分割线、模式行
+        layout = Layout(
+            HSplit(
+                [
+                    ConditionalContainer(
+                        Window(FormattedTextControl(self._working_line), height=1),
+                        filter=Condition(lambda: self.working),
+                    ),
+                    self._divider(),
+                    # 输入行只占内容高度，多行自动换行撑开
+                    Window(
+                        BufferControl(buffer=self._buffer),
+                        get_line_prefix=self._prompt_prefix,
+                        height=Dimension(min=1),
+                        wrap_lines=True,
+                        dont_extend_height=True,
+                    ),
+                    self._divider(),
+                    Window(FormattedTextControl(self._mode_line), height=1),
+                ]
+            )
+        )
+        return Application(layout=layout, key_bindings=self._build_key_bindings())
+
+    def _build_key_bindings(self) -> KeyBindings:
+        kb = KeyBindings()
+
+        @kb.add("enter")
+        def _(event: KeyPressEvent) -> None:
+            self._on_enter()
+
+        @kb.add("c-c")
+        def _(event: KeyPressEvent) -> None:
+            # 请求中打断当前 Agent loop；空闲时退出程序
+            if self._task is not None:
+                self._task.cancel()
+            else:
+                event.app.exit()
+
+        @kb.add("escape")
+        def _(event: KeyPressEvent) -> None:
+            # 请求中打断；空闲时清空输入行
+            if self._task is not None:
+                self._task.cancel()
+            else:
+                self._buffer.reset()
+
+        @kb.add("c-d")
+        def _(event: KeyPressEvent) -> None:
+            # 空闲且输入为空时退出
+            if self._task is None and not self._buffer.text:
+                event.app.exit()
+
+        @kb.add("s-tab")
+        def _(event: KeyPressEvent) -> None:
+            # 循环切换权限模式
+            permissions.cycle_mode()
+
+        return kb
+
+    def _on_enter(self) -> None:
+        # 请求中不接受新提交（输入框仍在，只是回车不触发新一轮）
+        if self._task is not None:
+            return
+        text = self._buffer.text.strip()
+        if not text:
+            self._buffer.reset()
+            return
+        # 存进输入历史，清空输入行
+        self._buffer.history.append_string(text)
+        self._buffer.reset()
+        # 把这行回显到上方滚动区，留下记录（输入框常驻，不回显的话提交后这行就没了）
+        self._echo_input(text)
+        # 把处理丢进后台任务，回车处理立刻返回，输入框继续渲染、随时能打断
+        self._task = self.app.create_background_task(self._process(text))
+
+    def _echo_input(self, text: str) -> None:
+        # 回显刚提交的一行：上下分割线夹住 ❯ 文本，和输入框观感一致
+        rule = "─" * console.width
+        console.print(f"[bright_black]{rule}[/]")
+        console.print(f"[cyan]❯[/] {escape(text)}")
+        console.print(f"[bright_black]{rule}[/]")
+        console.print()
+
+    async def _process(self, text: str) -> None:
+        # 后台任务：交给 on_submit，统一兜住打断和异常
+        assert self._on_submit is not None
+        try:
+            await self._on_submit(text)
+        except asyncio.CancelledError:
+            console.print("\n[bold yellow]已中断[/]\n")
+        except Exception as e:
+            console.print(f"\n[bold red]✗ {type(e).__name__}: {e}[/]\n")
+        finally:
+            self._task = None
+            self.working = False
+            self.app.invalidate()
+
+    def start_working(self) -> None:
+        # 进入请求中状态，上方显示 working...；请求结束 / 被打断后由 _process 的 finally 统一清掉
+        self.working = True
+        self._work_start = time.monotonic()
+        self.app.invalidate()
+
+    def exit(self) -> None:
+        # 结束常驻输入区（/exit 命令用）
+        self.app.exit()
+
+    async def run(self, on_submit: Callable[[str], Awaitable[None]]) -> None:
+        # 运行 REPL 直到用户退出；on_submit 是处理一行输入的异步回调
+        self._on_submit = on_submit
+        # 转圈动画的心跳：请求期间定时重绘
+        ticker = asyncio.ensure_future(self._tick())
+        try:
+            # patch_stdout 让 Agent 的 rich 输出打印在输入框上方而不是冲掉它
+            with patch_stdout(raw=True):
+                await self.app.run_async()
+        finally:
+            ticker.cancel()
+
+    async def _tick(self) -> None:
+        try:
+            while True:
+                await asyncio.sleep(0.1)
+                if self.working:
+                    self._frame += 1
+                    self.app.invalidate()
+        except asyncio.CancelledError:
+            pass

{zrcoder-0.3.0 → zrcoder-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zrcoder"
-version = "0.3.0"
+version = "0.4.0"
 description = "Terminal coding agent chat — OpenAI-compatible APIs, tools, and slash commands"
 readme = "README.md"
 license = "MIT"

{zrcoder-0.3.0 → zrcoder-0.4.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "zrcoder"
-version = "0.3.0"
+version = "0.4.0"
 description = "Terminal coding agent chat — OpenAI-compatible APIs, tools, and slash commands"
 readme = "README.md"
 license = "MIT"

zrcoder-0.3.0/core/agent/openai_compat.py

@@ -1,44 +0,0 @@
-"""
-对 OpenAI 兼容网关做响应清洗：部分服务商偶发返回不规范字段，
-导致 pydantic-ai 校验 ChatCompletion 失败（表现为「好一次、坏一次」）。
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from openai.types import chat
-from pydantic_ai.models import openai as openai_model
-from pydantic_ai.models.openai import OpenAIChatModel
-
-
-def _coerce_chat_completion_payload(data: dict[str, Any]) -> dict[str, Any]:
-    """
-    尽量把兼容网关的松散 JSON 修成 OpenAI ChatCompletion 能过校验的形状。
-    """
-    if data.get("object") != "chat.completion":
-        data["object"] = "chat.completion"
-
-    choices = data.get("choices")
-    if isinstance(choices, list):
-        for i, choice in enumerate(choices):
-            if not isinstance(choice, dict):
-                continue
-            index = choice.get("index", i)
-            if isinstance(index, str) and index.isdigit():
-                choice["index"] = int(index)
-            elif not isinstance(index, int):
-                choice["index"] = i
-            if choice.get("finish_reason") is None:
-                choice["finish_reason"] = "stop"
-    return data
-
-
-class CompatibleOpenAIChatModel(OpenAIChatModel):
-    """
-    覆盖校验钩子：先 coerce，再走与父类相同的 _ChatCompletion 校验。
-    """
-
-    def _validate_completion(self, response: chat.ChatCompletion) -> Any:
-        data = _coerce_chat_completion_payload(response.model_dump())
-        return openai_model._ChatCompletion.model_validate(data)