zrcoder 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zrcoder
-Version: 0.2.0
+Version: 0.3.0
 Summary: Terminal coding agent chat — OpenAI-compatible APIs, tools, and slash commands
 Keywords: cli,agent,coding,terminal,openai
 Author: Zr
@@ -18,6 +18,7 @@ Classifier: Topic :: Software Development
 Requires-Dist: prompt-toolkit>=3.0.53
 Requires-Dist: pydantic-ai>=2.40.0
 Requires-Dist: python-dotenv>=1.2.3
+Requires-Dist: questionary>=2.1.1
 Requires-Dist: rich>=15.0.0
 Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/ZRMYDYCG/ClaudeCode
@@ -28,7 +29,11 @@ Description-Content-Type: text/markdown
 
 # Zrcoder
 
-终端里的编程助手：连 OpenAI 兼容 API，可读写文件、执行命令，并支持 `/help` 等斜杠命令。
+<p align="center">
+  <img src="docs/zrcoder-banner.jpg" alt="Zrcoder — AI Terminal CLI" width="100%">
+</p>
+
+终端里的编程助手：连 OpenAI 兼容 API，可读写文件、执行命令，并支持斜杠命令与会话恢复。
 
 ## 安装
 
@@ -48,7 +53,11 @@ pip install zrcoder
 
 ## 配置
 
-在环境变量或项目目录的 `.env` 中设置（可参考 `.env.example`）：
+设置环境变量，或在以下位置之一创建 `.env`（可参考 `.env.example`）：
+
+- 当前目录：`./.env`
+- 用户配置：`~/.config/zrcoder/.env`
+- 兼容路径：`~/.zrcoder.env`
 
 ```bash
 export API_KEY=your_api_key
@@ -63,7 +72,7 @@ export BASE_URL=https://api.example.com/v1
 zrcoder
 ```
 
-常用命令：`/help`、`/status`、`/new`、`/api-detail`、`/exit`。
+常用命令：`/help`、`/status`、`/new`、`/resume`、`/api-detail`、`/exit`。
 
 ## 变更与发版
 

{zrcoder-0.2.0 → zrcoder-0.3.0}/README.md

@@ -1,6 +1,10 @@
 # Zrcoder
 
-终端里的编程助手：连 OpenAI 兼容 API，可读写文件、执行命令，并支持 `/help` 等斜杠命令。
+<p align="center">
+  <img src="docs/zrcoder-banner.jpg" alt="Zrcoder — AI Terminal CLI" width="100%">
+</p>
+
+终端里的编程助手：连 OpenAI 兼容 API，可读写文件、执行命令，并支持斜杠命令与会话恢复。
 
 ## 安装
 
@@ -20,7 +24,11 @@ pip install zrcoder
 
 ## 配置
 
-在环境变量或项目目录的 `.env` 中设置（可参考 `.env.example`）：
+设置环境变量，或在以下位置之一创建 `.env`（可参考 `.env.example`）：
+
+- 当前目录：`./.env`
+- 用户配置：`~/.config/zrcoder/.env`
+- 兼容路径：`~/.zrcoder.env`
 
 ```bash
 export API_KEY=your_api_key
@@ -35,7 +43,7 @@ export BASE_URL=https://api.example.com/v1
 zrcoder
 ```
 
-常用命令：`/help`、`/status`、`/new`、`/api-detail`、`/exit`。
+常用命令：`/help`、`/status`、`/new`、`/resume`、`/api-detail`、`/exit`。
 
 ## 变更与发版
 

{zrcoder-0.2.0 → zrcoder-0.3.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 = OpenAIChatModel(
+model = CompatibleOpenAIChatModel(
     MODEL_NAME,
     provider=OpenAIProvider(base_url=_normalize_openai_base_url(BASE_URL), api_key=API_KEY),
 )

zrcoder-0.3.0/core/agent/hooks.py

@@ -0,0 +1,147 @@
+"""
+挂在 Agent 上的 hooks：
+1. API 调用元数据记录（/api-detail 命令用）
+2. API 请求失败时的自动重试（wrap_model_request）
+3. 工具执行异常的兜底处理（on_tool_execute_error）
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any
+
+from pydantic_ai.capabilities import Hooks
+from pydantic_ai.exceptions import ModelAPIError, ModelHTTPError, UnexpectedModelBehavior
+
+from core.ui.render import console
+
+MAX_RETRIES = 3
+
+
+@dataclass
+class ApiCall:
+    """
+    一次 model API 调用的元数据。before_model_request 创建并填充上半部分，
+    after_model_request 填充下半部分。
+    """
+
+    # request 侧
+    model: str
+    messages_count: int
+    # 这次发送给模型的 messages 中最后一条消息的最后一个 part
+    last_part: Any
+    tools: list[str]
+    # response 侧（after hook 填充）
+    finish_reason: str = ""
+    parts_kinds: list[str] = field(default_factory=list)
+    input_tokens: int = 0
+    output_tokens: int = 0
+
+
+# 主循环在每轮 agent.iter() 之前清空它
+api_call_log: list[ApiCall] = []
+
+hooks = Hooks()
+
+
+# ---------- API 调用记录 ----------
+
+
+@hooks.on.before_model_request
+async def _record_request(ctx: Any, request_context: Any) -> Any:
+    """
+    每次发起 model 调用之前，创建一条 ApiCall 记录。
+    """
+    msgs = list(request_context.messages)
+    last_part = msgs[-1].parts[-1] if msgs and msgs[-1].parts else None
+    try:
+        tool_names = [t.name for t in request_context.model_request_parameters.function_tools]
+    except AttributeError:
+        tool_names = []
+    api_call_log.append(
+        ApiCall(
+            model=request_context.model.model_name,
+            messages_count=len(msgs),
+            last_part=last_part,
+            tools=tool_names,
+        )
+    )
+    return request_context
+
+
+@hooks.on.after_model_request
+async def _record_response(ctx: Any, *, request_context: Any, response: Any) -> Any:
+    """
+    每次 model 调用返回后，填充上面这条 ApiCall 的 response 字段。
+    """
+    if api_call_log:
+        call = api_call_log[-1]
+        call.finish_reason = str(response.finish_reason) if response.finish_reason else "unknown"
+        call.parts_kinds = [p.part_kind for p in response.parts]
+        call.input_tokens = response.usage.input_tokens
+        call.output_tokens = response.usage.output_tokens
+    return response
+
+
+# ---------- API 请求重试 ----------
+
+
+@hooks.on.model_request
+async def _retry_on_error(ctx: Any, *, request_context: Any, handler: Any) -> Any:
+    """
+    包裹 model 请求，遇到可重试错误时自动指数退避重试。
+
+    重试在 wrap 内部完成，对话历史和 before/after hooks 不受影响。
+    兼容网关偶发的 UnexpectedModelBehavior（响应 schema 不对）也会重试。
+    """
+    for attempt in range(MAX_RETRIES + 1):
+        try:
+            return await handler(request_context)
+        except ModelHTTPError as e:
+            if e.status_code < 500:
+                raise
+            if attempt >= MAX_RETRIES:
+                console.print(f"[bold red]✗ HTTP {e.status_code}，重试 {MAX_RETRIES} 次后仍失败[/]")
+                raise
+            wait = 2**attempt
+            console.print(
+                f"[bold yellow]⟳ HTTP {e.status_code}，{wait}s 后重试 "
+                f"({attempt + 1}/{MAX_RETRIES})...[/]"
+            )
+            await asyncio.sleep(wait)
+        except UnexpectedModelBehavior as e:
+            if attempt >= MAX_RETRIES:
+                console.print(f"[bold red]✗ 模型响应异常，重试 {MAX_RETRIES} 次后仍失败：{e}[/]")
+                raise
+            wait = 2**attempt
+            console.print(
+                f"[bold yellow]⟳ 模型响应异常，{wait}s 后重试 ({attempt + 1}/{MAX_RETRIES})...[/]"
+            )
+            await asyncio.sleep(wait)
+        except ModelAPIError:
+            if attempt >= MAX_RETRIES:
+                console.print(f"[bold red]✗ 网络连接失败，重试 {MAX_RETRIES} 次后仍无法连接[/]")
+                raise
+            wait = 2**attempt
+            console.print(
+                f"[bold yellow]⟳ 网络连接失败，{wait}s 后重试 ({attempt + 1}/{MAX_RETRIES})...[/]"
+            )
+            await asyncio.sleep(wait)
+
+    raise RuntimeError("unreachable")  # pragma: no cover
+
+
+# ---------- 工具执行异常兜底 ----------
+
+
+@hooks.on.tool_execute_error
+async def _handle_tool_error(
+    ctx: Any, *, call: Any, tool_def: Any, args: Any, error: Exception
+) -> str:
+    """
+    工具函数抛出未捕获异常时，不让进程崩溃，
+    而是把错误信息作为 tool result 返回给模型，让它自行纠正。
+    """
+    console.print(f"[bold red]✗ 工具 {call.tool_name} 出错：{error}[/]")
+    return f"工具执行出错：{type(error).__name__}: {error}"

zrcoder-0.3.0/core/agent/openai_compat.py

@@ -0,0 +1,44 @@
+"""
+对 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)

zrcoder-0.3.0/core/agent/tools.py

@@ -0,0 +1,66 @@
+"""
+Coding Agent 用到的三个工具：读文件、写文件、跑 shell 命令。
+
+每个工具自己处理已知错误：能靠换参数纠正的（路径不存在、没权限）抛 ModelRetry
+让模型重试，不能纠正的（二进制文件、命令出错）直接返回错误信息。
+意料之外的异常由 hooks 里的 on_tool_execute_error 统一兜底。
+"""
+
+import subprocess
+
+from pydantic_ai.exceptions import ModelRetry
+
+
+def read_file(path: str) -> str:
+    """
+    读取指定文件的内容。
+    """
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError as e:
+        raise ModelRetry(f"文件 {path} 不存在，请确认路径或换一个文件") from e
+    except PermissionError as e:
+        raise ModelRetry(f"没有权限读取 {path}，请换一个可读的文件") from e
+    except IsADirectoryError as e:
+        raise ModelRetry(f"{path} 是一个目录，请指定目录下的具体文件") from e
+    except UnicodeDecodeError:
+        return f"错误：{path} 不是文本文件，无法读取"
+
+
+def write_file(path: str, content: str) -> str:
+    """
+    将内容写入指定文件。
+    """
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"已写入 {path}"
+    except FileNotFoundError as e:
+        raise ModelRetry(f"目录不存在，无法写入 {path}，请换一个已存在的目录") from e
+    except PermissionError as e:
+        raise ModelRetry(f"没有权限写入 {path}，请换一个可写的路径") from e
+    except OSError as e:
+        return f"错误：写入 {path} 失败 ({e})"
+
+
+def run_command(command: str) -> str:
+    """
+    执行一条 shell 命令并返回输出。
+    """
+    try:
+        result = subprocess.run(
+            command, shell=True, capture_output=True, text=True, errors="replace", timeout=10
+        )
+        output = result.stdout
+        if result.returncode != 0:
+            output += f"\n[错误] {result.stderr}"
+        return output or "(无输出)"
+    except subprocess.TimeoutExpired:
+        return "[错误] 命令执行超时（10秒）"
+    except OSError as e:
+        return f"[错误] 无法执行命令 ({e})"
+
+
+# Pydantic AI 支持 tools=[plain_function]，从函数签名 + docstring 自动生成 JSON Schema
+TOOLS = [read_file, write_file, run_command]

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

@@ -12,6 +12,7 @@ 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.render import console, print_welcome_banner
 
@@ -55,18 +56,19 @@ def handle_command(user_input: str, state: SessionState) -> CommandAction:
 
 def apply_result(state: SessionState, result: Any) -> None:
     """
-    跑完一轮 Agent 后，把结果同步到 SessionState。
+    跑完一轮 Agent 后，把结果同步到 SessionState，并追加写入会话文件。
     """
     state.history = result.all_messages()
     usage = result.usage
     state.input_tokens += usage.input_tokens
     state.output_tokens += usage.output_tokens
     state.last_api_calls = list(api_call_log)
+    append_messages(state.session_id, result.new_messages())
 
 
 async def run_agent_loop(user_input: str, state: SessionState) -> None:
     """
-    逐节点驱动 Agent 循环，每步实时打印。
+    展开 agent.run_sync()，逐节点驱动 Agent 循环，每步实时打印。
     """
     api_call_log.clear()
 
@@ -82,7 +84,8 @@ async def run_agent_loop(user_input: str, state: SessionState) -> None:
 
             elif Agent.is_model_request_node(node):
                 for request_part in node.request.parts:
-                    if getattr(request_part, "part_kind", None) == "tool-return":
+                    kind = getattr(request_part, "part_kind", None)
+                    if kind in ("tool-return", "retry-prompt"):
                         print_part(request_part)
 
         apply_result(state, run.result)
@@ -90,7 +93,10 @@ async def run_agent_loop(user_input: str, state: SessionState) -> None:
 
 
 def main() -> None:
-    state = SessionState(model_name=MODEL_NAME)
+    state = SessionState(
+        model_name=MODEL_NAME,
+        session_id=new_session_id(),
+    )
     print_welcome_banner("Zrcoder")
 
     while True:
@@ -109,7 +115,12 @@ def main() -> None:
             continue
 
         # 核心 Agent 循环：自己驱动节点流转，实时打印每一步
-        asyncio.run(run_agent_loop(user_input, state))
+        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")
 
 
 if __name__ == "__main__":

zrcoder-0.3.0/core/session.py

@@ -0,0 +1,91 @@
+"""
+会话持久化：把对话历史写成 jsonl 文件，支持扫描和恢复历史会话。
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from pydantic_ai.messages import ModelMessagesTypeAdapter
+from pydantic_core import to_jsonable_python
+
+# 所有会话记录的根目录
+STORAGE_ROOT = Path.home() / ".zrcoder" / "projects"
+
+
+def sanitize_path(path: str) -> str:
+    """
+    把项目绝对路径转码成合法的目录名：非字母数字字符一律换成 -
+    """
+    return re.sub(r"[^a-zA-Z0-9]", "-", path)
+
+
+def project_dir() -> Path:
+    """
+    当前项目（工作目录）对应的会话存储目录。
+    """
+    return STORAGE_ROOT / sanitize_path(str(Path.cwd()))
+
+
+def new_session_id() -> str:
+    return str(uuid.uuid4())
+
+
+def session_file(session_id: str) -> Path:
+    return project_dir() / f"{session_id}.jsonl"
+
+
+def append_messages(session_id: str, messages: Any) -> None:
+    """
+    把本轮新增的消息追加到会话文件末尾，一行一条。
+    """
+    if not session_id:
+        return
+    path = session_file(session_id)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "a", encoding="utf-8") as f:
+        for msg in messages:
+            f.write(json.dumps(to_jsonable_python(msg), ensure_ascii=False) + "\n")
+
+
+def load_history(session_id: str) -> list[Any]:
+    """
+    读取整个会话文件，把每行 JSON 还原成 SDK 的消息对象列表。
+    """
+    lines = session_file(session_id).read_text(encoding="utf-8").splitlines()
+    return ModelMessagesTypeAdapter.validate_python([json.loads(line) for line in lines])
+
+
+def first_prompt(path: Path) -> str:
+    """
+    只读文件第一行，提取首条用户输入作为这个会话的摘要。
+    """
+    with open(path, encoding="utf-8") as f:
+        head = f.readline()
+    if not head:
+        return "(空会话)"
+    msg = json.loads(head)
+    for part in msg.get("parts", []):
+        if part.get("part_kind") == "user-prompt":
+            return str(part.get("content", ""))
+    return "(空会话)"
+
+
+def list_sessions() -> list[tuple[str, datetime, str]]:
+    """
+    扫描当前项目的所有会话文件，按修改时间从新到旧返回
+    (session_id, 修改时间, 首条用户输入) 列表。
+    """
+    if not project_dir().exists():
+        return []
+    files = sorted(
+        project_dir().glob("*.jsonl"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+    return [(p.stem, datetime.fromtimestamp(p.stat().st_mtime), first_prompt(p)) for p in files]

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

@@ -1,13 +1,17 @@
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass, field
+from datetime import datetime
 from typing import Any
 
+import questionary
 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 .render import console, print_step
 
 
@@ -38,6 +42,8 @@ class SessionState:
     model_name: str = ""
     # 最近一轮 user input 触发的所有 model API 调用记录
     last_api_calls: list[Any] = field(default_factory=list)
+    # 当前会话 id，对应 ~/.…/projects/<cwd>/<id>.jsonl
+    session_id: str = ""
 
 
 @dataclass
@@ -157,18 +163,74 @@ def cmd_help(state: SessionState) -> bool:
 
 def cmd_new(state: SessionState) -> bool:
     """
-    开启新会话：清空历史、token 计数、API 调用记录。
+    开启新会话：清空历史、token 计数、API 调用记录，并换一个 session_id。
     """
     state.history.clear()
     state.input_tokens = 0
     state.output_tokens = 0
     state.last_api_calls.clear()
+    state.session_id = session.new_session_id()
     console.print("已开启新会话\n")
     return True
 
 
+def _summary_line(mtime: datetime, prompt: str) -> str:
+    """
+    拼一条会话列表的展示文本：修改时间 + 首条用户输入摘要。
+    """
+    prompt = " ".join(str(prompt).split())
+    if len(prompt) > 50:
+        prompt = prompt[:50] + "..."
+    return f"{mtime:%m-%d %H:%M}  {prompt}"
+
+
+def cmd_resume(state: SessionState) -> bool:
+    """
+    列出当前项目的历史会话，选中后恢复对话历史。
+    """
+    sessions = session.list_sessions()
+    if not sessions:
+        console.print("(当前项目还没有历史会话)\n")
+        return True
+
+    choices = [
+        questionary.Choice(title=_summary_line(mtime, prompt), value=sid)
+        for sid, mtime, prompt in sessions
+    ]
+    selected = questionary.select(
+        "选择要恢复的会话（上下键移动，回车确认）：",
+        choices=choices,
+    ).ask()
+    # 用户按 Ctrl+C 取消选择
+    if selected is None:
+        return True
+
+    # 还原对话历史，并把会话 ID 切换成选中的旧会话，后续消息继续追加到同一个文件
+    state.history = session.load_history(selected)
+    state.session_id = selected
+
+    # jsonl 里每条模型回复都带 usage，把会话的 token 用量累加回来
+    state.input_tokens = sum(
+        m.usage.input_tokens for m in state.history if getattr(m, "kind", None) == "response"
+    )
+    state.output_tokens = sum(
+        m.usage.output_tokens for m in state.history if getattr(m, "kind", None) == "response"
+    )
+    # 最近一轮的 API 调用记录只在进程内有效，没法恢复，清空
+    state.last_api_calls.clear()
+
+    # 把恢复的对话回放到屏幕上
+    console.print(f"\n已恢复会话 {selected[:8]}，共 {len(state.history)} 条消息：\n")
+    for msg in state.history:
+        for part in msg.parts:
+            print_part(part)
+    console.print()
+    return True
+
+
 def cmd_status(state: SessionState) -> bool:
     console.print(f"模型：           {state.model_name}")
+    console.print(f"会话 ID：        {state.session_id or '(无)'}")
     console.print(f"历史消息条数：    {len(state.history)}")
     console.print(f"累计输入 tokens：{state.input_tokens}")
     console.print(f"累计输出 tokens：{state.output_tokens}\n")
@@ -205,6 +267,7 @@ def cmd_api_detail(state: SessionState) -> bool:
 
 COMMANDS = {
     "new": Command("new", "开启新会话", cmd_new),
+    "resume": Command("resume", "恢复历史会话", cmd_resume),
     "status": Command("status", "显示当前会话状态", cmd_status),
     "api-detail": Command("api-detail", "显示最近一轮 model API 调用详情", cmd_api_detail),
     "help": Command("help", "显示可用命令", cmd_help),

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

@@ -1,6 +1,6 @@
 [project]
 name = "zrcoder"
-version = "0.2.0"
+version = "0.3.0"
 description = "Terminal coding agent chat — OpenAI-compatible APIs, tools, and slash commands"
 readme = "README.md"
 license = "MIT"
@@ -9,6 +9,7 @@ dependencies = [
     "prompt-toolkit>=3.0.53",
     "pydantic-ai>=2.40.0",
     "python-dotenv>=1.2.3",
+    "questionary>=2.1.1",
     "rich>=15.0.0",
 ]
 keywords = [

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

@@ -1,6 +1,6 @@
 [project]
 name = "zrcoder"
-version = "0.2.0"
+version = "0.3.0"
 description = "Terminal coding agent chat — OpenAI-compatible APIs, tools, and slash commands"
 readme = "README.md"
 license = "MIT"
@@ -12,6 +12,7 @@ dependencies = [
     "prompt-toolkit>=3.0.53",
     "pydantic-ai>=2.40.0",
     "python-dotenv>=1.2.3",
+    "questionary>=2.1.1",
     "rich>=15.0.0",
 ]
 keywords = ["cli", "agent", "coding", "terminal", "openai"]

zrcoder-0.2.0/core/agent/hooks.py

@@ -1,73 +0,0 @@
-"""
-挂在 Agent 上的 hooks，用来抓每次 model API 调用的元数据。
-
-主循环在每轮 run_sync 之前清空 api_call_log，跑完后快照到 SessionState 里，
-/api-detail 命令再把这一轮的所有调用展示给用户。
-"""
-
-from dataclasses import dataclass, field
-from typing import Any
-
-from pydantic_ai.capabilities import Hooks
-
-
-@dataclass
-class ApiCall:
-    """
-    一次 model API 调用的元数据。before_model_request 创建并填充上半部分，
-    after_model_request 填充下半部分。
-    """
-
-    # request 侧
-    model: str
-    messages_count: int
-    # 这次发送给模型的 messages 中最后一条消息的最后一个 part
-    last_part: Any
-    tools: list[str]
-    # response 侧（after hook 填充）
-    finish_reason: str = ""
-    parts_kinds: list[str] = field(default_factory=list)
-    input_tokens: int = 0
-    output_tokens: int = 0
-
-
-# 主循环在每轮 run_sync 之前清空它
-api_call_log: list[ApiCall] = []
-
-hooks = Hooks()
-
-
-@hooks.on.before_model_request
-async def _record_request(ctx: Any, request_context: Any) -> Any:
-    """
-    每次发起 model 调用之前，创建一条 ApiCall 记录。
-    """
-    msgs = list(request_context.messages)
-    last_part = msgs[-1].parts[-1] if msgs and msgs[-1].parts else None
-    try:
-        tool_names = [t.name for t in request_context.model_request_parameters.function_tools]
-    except AttributeError:
-        tool_names = []
-    api_call_log.append(
-        ApiCall(
-            model=request_context.model.model_name,
-            messages_count=len(msgs),
-            last_part=last_part,
-            tools=tool_names,
-        )
-    )
-    return request_context
-
-
-@hooks.on.after_model_request
-async def _record_response(ctx: Any, request_context: Any, response: Any) -> Any:
-    """
-    每次 model 调用返回后，填充上面这条 ApiCall 的 response 字段。
-    """
-    if api_call_log:
-        call = api_call_log[-1]
-        call.finish_reason = str(response.finish_reason) if response.finish_reason else "unknown"
-        call.parts_kinds = [p.part_kind for p in response.parts]
-        call.input_tokens = response.usage.input_tokens
-        call.output_tokens = response.usage.output_tokens
-    return response

zrcoder-0.2.0/core/agent/tools.py

@@ -1,45 +0,0 @@
-"""
-Coding Agent 用到的三个工具：读文件、写文件、跑 shell 命令。
-"""
-
-import subprocess
-
-
-def read_file(path: str) -> str:
-    """
-    读取指定文件的内容。
-    """
-    try:
-        with open(path, encoding="utf-8") as f:
-            return f.read()
-    except FileNotFoundError:
-        return f"错误：文件 {path} 不存在"
-
-
-def write_file(path: str, content: str) -> str:
-    """
-    将内容写入指定文件。
-    """
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-    return f"已写入 {path}"
-
-
-def run_command(command: str) -> str:
-    """
-    执行一条 shell 命令并返回输出。
-    """
-    try:
-        result = subprocess.run(
-            command, shell=True, capture_output=True, text=True, errors="replace", timeout=10
-        )
-        output = result.stdout
-        if result.returncode != 0:
-            output += f"\n[错误] {result.stderr}"
-        return output or "(无输出)"
-    except subprocess.TimeoutExpired:
-        return "[错误] 命令执行超时（10秒）"
-
-
-# Pydantic AI 支持 tools=[plain_function]，从函数签名 + docstring 自动生成 JSON Schema
-TOOLS = [read_file, write_file, run_command]