abyss-cli 0.1.0__py3-none-any.whl

abyss/main.py

@@ -0,0 +1,763 @@
+# -*- coding: utf-8 -*-
+"""
+Abyss CLI 主入口
+类似 Claude Code，一个命令启动，一切在工具内完成。
+补全菜单使用自定义 ANSI 渲染（ansi_menu），绕过 prompt_toolkit 灰色背景问题。
+"""
+import click
+import json
+import os
+import sys
+import re
+import threading
+import time
+import itertools
+import traceback
+import inspect
+from .config import Config
+from .api_client import DeepSeekClient
+from .session import Session
+from .prompts import load_system_prompt
+from .tools import (
+    FileReadTool, FileWriteTool, FileEditTool,
+    ShellExecTool, WebSearchTool
+)
+from .ansi_menu import ansi_prompt
+from . import logger
+
+TOOLS = {
+    "file_read": FileReadTool(),
+    "file_write": FileWriteTool(),
+    "file_edit": FileEditTool(),
+    "shell_exec": ShellExecTool(),
+    "web_search": WebSearchTool()
+}
+
+# 工具调用往返轮数安全网（仅防 AI 死循环，正常任务不会达到）
+MAX_TOOL_ROUNDS = 100
+
+_SPINNER_CHARS = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+class Spinner:
+    """终端动画旋转指示器，类 Claude Code 风格。"""
+
+    def __init__(self, message="思考中"):
+        self._message = message
+        self._running = False
+        self._thread = None
+        self._lock = threading.Lock()
+
+    def start(self):
+        logger.spinner_start(self._message)
+        self._running = True
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        with self._lock:
+            if not self._running:
+                return
+            self._running = False
+        if self._thread:
+            self._thread.join(timeout=0.5)
+        sys.stdout.write("\r\x1b[K")
+        sys.stdout.flush()
+        logger.spinner_stop(self._message)
+
+    def _spin(self):
+        chars = itertools.cycle(_SPINNER_CHARS)
+        while True:
+            with self._lock:
+                if not self._running:
+                    break
+                sys.stdout.write(f"\r  \033[2m{next(chars)} {self._message}\033[0m")
+                sys.stdout.flush()
+            time.sleep(0.08)
+
+
+def _get_tc_field(tc, name, default=None):
+    """兼容 dict 和 SDK 对象两种 tool_call 格式"""
+    if isinstance(tc, dict):
+        return tc.get(name, default)
+    return getattr(tc, name, default)
+
+
+def _extract_missing_param(exc: TypeError, func) -> str:
+    """从 TypeError 消息中提取缺失的参数名。找不到时返回空串。
+
+    Python 的 TypeError 形如：
+      "FileEditTool.execute() missing 1 required positional argument: 'path'"
+    对多余参数（unexpected keyword argument）也能识别。
+    """
+    msg = str(exc)
+    if "missing 1 required positional argument:" in msg:
+        # 提取 'xxx' 中的 xxx
+        try:
+            return msg.split("argument: '", 1)[1].split("'", 1)[0]
+        except IndexError:
+            return ""
+    if "missing" in msg and "required" in msg:
+        # 兜底：列出 func 的所有必填参数
+        try:
+            sig = inspect.signature(func)
+            required = [
+                p.name for p in sig.parameters.values()
+                if p.default is inspect.Parameter.empty
+                and p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                               inspect.Parameter.KEYWORD_ONLY)
+            ]
+            return ", ".join(required)
+        except (ValueError, TypeError):
+            return ""
+    return ""
+
+
+def merge_tool_calls(chunks):
+    """合并流式 tool_calls delta，按 index 聚合 arguments。返回完整 tool_calls 列表"""
+    merged = {}
+    for tc in chunks:
+        idx = _get_tc_field(tc, "index", 0)
+        if idx not in merged:
+            merged[idx] = {"id": None, "type": "function", "function": {"name": "", "arguments": ""}}
+        m = merged[idx]
+        tc_id = _get_tc_field(tc, "id", None)
+        if tc_id:
+            m["id"] = tc_id
+        func = _get_tc_field(tc, "function", {})
+        func_name = _get_tc_field(func, "name", "")
+        if func_name:
+            m["function"]["name"] = func_name
+        func_args = _get_tc_field(func, "arguments", "")
+        if func_args:
+            m["function"]["arguments"] += func_args
+    return [merged[i] for i in sorted(merged)]
+
+
+def execute_tool(tool_call, batch_index: int = None, batch_total: int = None) -> str:
+    """执行单个工具调用，返回给 AI 的结果 JSON。batch_index/batch_total 非空时 UI 加 [i/total] 前缀"""
+    func = _get_tc_field(tool_call, "function", {})
+    name = _get_tc_field(func, "name", "")
+    args_str = _get_tc_field(func, "arguments", "")
+    try:
+        arguments = json.loads(args_str) if args_str else {}
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": f"参数解析失败: {args_str}"})
+    if name not in TOOLS:
+        return json.dumps({"success": False, "error": f"未知工具: {name}"})
+
+    _show_tool_action(name, arguments, batch_index, batch_total)
+    logger.tool_start(name, args=args_str)
+    t0 = time.time()
+    try:
+        result = TOOLS[name].execute(**arguments)
+    except TypeError as e:
+        # AI 生成的 tool call 缺必要参数（如 file_edit 漏掉 path）。
+        # 解析错误信息找出缺失字段名，返回结构化错误让 AI 修正后重试，
+        # 而不是让 TypeError 杀死整个 CLI、丢失多轮对话上下文。
+        missing = _extract_missing_param(e, TOOLS[name].execute)
+        hint = f"（缺失必要参数: {missing}）" if missing else ""
+        result = {"success": False, "error": f"工具参数不合法: {e} {hint}"}
+    elapsed_ms = int((time.time() - t0) * 1000)
+    _show_tool_result(name, arguments, result)
+    logger.tool_end(name, success=result.get("success", False), duration_ms=elapsed_ms,
+                    out_len=len(json.dumps(result, ensure_ascii=False)))
+
+    if name == "shell_exec":
+        # 限制给 AI 的输出长度，避免超出 context
+        max_len = 4000
+        stdout = (result.get("stdout", "") or "")
+        stderr = (result.get("stderr", "") or "")
+        if len(stdout) > max_len:
+            stdout = stdout[:max_len] + f"\n...[截断, 共 {result.get('stdout','').count(chr(10))+1} 行]"
+        if len(stderr) > max_len:
+            stderr = stderr[:max_len] + f"\n...[截断]"
+        return json.dumps({
+            "success": result.get("success", False),
+            "stdout": stdout,
+            "stderr": stderr,
+            "returncode": result.get("returncode", None),
+        }, ensure_ascii=False)
+
+    return json.dumps(result, ensure_ascii=False)
+
+
+def _show_tool_action(name: str, args: dict, batch_index: int = None, batch_total: int = None):
+    """显示工具调用信息。batch_index/batch_total 非空时输出 [i/total] 编号前缀"""
+    prefix = ""
+    if batch_index is not None and batch_total is not None:
+        prefix = f"\033[2m[{batch_index}/{batch_total}]\033[0m "
+    if name == "shell_exec":
+        click.echo(f"  {prefix}\033[33m$ {args.get('command', '')}\033[0m", nl=False)
+    elif name == "file_write":
+        click.echo(f"  {prefix}\033[36m写入文件: {args.get('path', '')}\033[0m", nl=False)
+    elif name == "file_read":
+        click.echo(f"  {prefix}\033[36m读取文件: {args.get('path', '')}\033[0m", nl=False)
+    elif name == "file_edit":
+        click.echo(f"  {prefix}\033[36m编辑文件: {args.get('path', '')}\033[0m", nl=False)
+    elif name == "web_search":
+        click.echo(f"  {prefix}\033[35m搜索: {args.get('query', '')}\033[0m", nl=False)
+        sys.stdout.flush()
+    else:
+        click.echo(f"  {prefix}[tool] {name}", nl=False)
+
+
+def _show_batch_header(round_num: int, total: int, max_rounds: int = MAX_TOOL_ROUNDS):
+    """打印工具调用批次头，旋转动画 → ● 落定。
+    先 \\n 换到新行：保护上一行 AI 输出不被 \\r 动画覆盖掉。"""
+    logger.batch_header(round_num, total, max_rounds)
+    header = f"工具调用 (第 {round_num} 轮 / {max_rounds}) — 共 {total} 个"
+    # 避免 AI 流式输出最后一行被动画 \r 覆盖：先换行到新行再开始
+    sys.stdout.write('\n')
+    sys.stdout.flush()
+    frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+    for i, c in enumerate(frames):
+        if i > 0:
+            time.sleep(0.06)
+        sys.stdout.write(f"\r\x1b[K  \033[2m{c} {header}\033[0m")
+        sys.stdout.flush()
+    sys.stdout.write(f"\r\x1b[K  \033[1m●\033[0m \033[2m{header}\033[0m\n")
+    sys.stdout.flush()
+
+
+def _start_thinking_spinner(message="推理中"):
+    """启动动画旋转指示器，返回 Spinner 实例供调用方在首段内容到达时停止"""
+    spinner = Spinner(message)
+    spinner.start()
+    return spinner
+
+
+def _show_tool_result(name: str, args: dict, result: dict):
+    """在终端显示工具执行结果"""
+    success = result.get("success", False)
+
+    if name == "shell_exec":
+        if success:
+            stdout = result.get("stdout", "").strip()
+            stderr = result.get("stderr", "").strip()
+            has_output = bool(stdout or stderr)
+            if has_output:
+                click.echo()
+                if stdout:
+                    click.echo(stdout)
+                if stderr:
+                    click.echo(f"\033[33m{stderr}\033[0m")
+                click.echo(f"  \033[32m完成\033[0m")
+            else:
+                click.echo()
+                click.echo(f"  \033[32m完成 (无输出)\033[0m")
+        else:
+            click.echo()
+            err = result.get("error", result.get("stderr", ""))
+            click.echo(f"  \033[31m失败: {err}\033[0m")
+
+    elif name in ("file_write", "file_read", "file_edit"):
+        click.echo()
+        if success:
+            click.echo(f"  \033[32m完成\033[0m")
+        else:
+            click.echo(f"  \033[31m失败: {result.get('error', '')}\033[0m")
+
+    elif name == "web_search":
+        if success:
+            count = len(result.get("results", []))
+            click.echo(f"  \033[32m搜索完成 ({count}条)\033[0m")
+        else:
+            click.echo()
+            click.echo(f"  \033[31m搜索失败: {result.get('error', '')}\033[0m")
+
+    else:
+        click.echo()
+        if success:
+            click.echo(f"  \033[32m完成\033[0m")
+        else:
+            click.echo(f"  \033[31m失败\033[0m")
+
+
+def _execute_tool_batch(round_num: int, tool_calls: list) -> list:
+    """执行一批工具调用，带批次头和编号前缀。返回每个 tool_call 对应的 result 列表"""
+    _show_batch_header(round_num, len(tool_calls))
+    results = []
+    total = len(tool_calls)
+    for i, tc in enumerate(tool_calls, 1):
+        result = execute_tool(tc, batch_index=i, batch_total=total)
+        results.append(result)
+    return results
+
+
+def process_tool_calls(session, client, tools_schemas, tool_calls, cfg, show_reasoning=False):
+    """执行工具调用并获取后续回复，支持多轮循环。首批 = 第 1 轮，for 循环从第 2 轮开始"""
+    session.add_assistant(tool_calls=tool_calls)
+
+    # 第 1 轮：执行 run_with_pt 传过来的首批 tool_calls
+    results = _execute_tool_batch(1, tool_calls)
+    for tc, result in zip(tool_calls, results):
+        session.add_tool_result(_get_tc_field(tc, "id"), result)
+
+    for round_num in range(2, MAX_TOOL_ROUNDS + 1):
+        spinner = _start_thinking_spinner()
+        content_buffer = ""
+        reasoning_buffer = ""
+        new_tool_calls = []
+        api_start = time.time()
+        first_token_logged = False
+
+        try:
+            for chunk in client.chat(
+                messages=session.get_messages_for_api(),
+                tools=tools_schemas, stream=True,
+                model=cfg.get("model"), thinking=cfg.get("thinking"),
+                reasoning_effort=cfg.get("reasoning_effort"),
+                max_tokens=cfg.get("max_tokens"), user_id=cfg.get("user_id")
+            ):
+                if not first_token_logged and (chunk.get("reasoning_content") or chunk.get("content")):
+                    logger.api_first_token(int((time.time() - api_start) * 1000))
+                    first_token_logged = True
+                if chunk.get("reasoning_content"):
+                    if show_reasoning and not reasoning_buffer:
+                        spinner.stop()
+                        # 整段 reasoning 走灰色样式（\033[2;90m = dim + 亮黑色 = 真正的灰色），
+                        # 与正式回答的常规字体做明显区分。
+                        click.echo("  \033[2;90m思考: ", nl=False)
+                    reasoning_buffer += chunk["reasoning_content"]
+                    if show_reasoning:
+                        click.echo(chunk["reasoning_content"], nl=False)
+                        sys.stdout.flush()
+                if chunk.get("content"):
+                    if not content_buffer:
+                        # 关闭暗色样式，回复正常字体
+                        if show_reasoning and reasoning_buffer:
+                            click.echo("\033[0m", nl=False)
+                        spinner.stop()
+                        click.echo()
+                        logger.stream_content_start()
+                    content_buffer += chunk["content"]
+                    click.echo(chunk["content"], nl=False)
+                    sys.stdout.flush()
+                if chunk.get("tool_calls"):
+                    new_tool_calls.extend(chunk["tool_calls"])
+            logger.api_response(api_ms=int((time.time() - api_start) * 1000),
+                                content_len=len(content_buffer),
+                                reasoning_len=len(reasoning_buffer),
+                                tool_calls=len(new_tool_calls))
+        except Exception as e:
+            spinner.stop()
+            logger.api_error(str(e))
+            click.echo()
+            click.echo(f"  \033[31mAPI 调用失败: {e}\033[0m")
+            return ""
+
+        spinner.stop()
+
+        if new_tool_calls:
+            merged_new = merge_tool_calls(new_tool_calls)
+            if show_reasoning:
+                # reasoning 后直接 tool_calls，没 content 触发复位 —— 手动关 dim
+                if reasoning_buffer and not content_buffer:
+                    click.echo("\033[0m", nl=False)
+                click.echo()
+            session.add_assistant(
+                tool_calls=merged_new,
+                reasoning_content=reasoning_buffer if reasoning_buffer else None
+            )
+            results = _execute_tool_batch(round_num, merged_new)
+            for tc, result in zip(merged_new, results):
+                session.add_tool_result(_get_tc_field(tc, "id"), result)
+            continue
+
+        session.add_assistant(
+            content=content_buffer if content_buffer else None,
+            reasoning_content=reasoning_buffer if reasoning_buffer else None
+        )
+        return content_buffer
+
+    # 达到 MAX_TOOL_ROUNDS 安全网仍未收敛（防 AI 死循环）
+    click.echo()
+    click.echo(f"  \033[33m(达到 {MAX_TOOL_ROUNDS} 轮安全网上限，疑似死循环，已停止)\033[0m")
+    return ""
+
+
+def handle_slash_command(input_str: str, session, client, cfg, sr: list):
+    """
+    处理 / 命令。返回 True=已处理, "exit"=退出, False=非命令
+    """
+    stripped = input_str.strip()
+    parts = stripped.split()
+    if not parts:
+        return False
+    cmd = parts[0].lower()
+
+    if cmd == "/clear":
+        session.clear()
+        click.echo("[OK] 上下文已清空")
+        return True
+
+    if cmd in ("/exit", "/quit"):
+        return "exit"
+
+    if cmd == "/help":
+        click.echo("")
+        click.echo("\033[1;36m╭─────────────────────────────────────────────╮\033[0m")
+        click.echo("\033[1;36m│  Abyss CLI · 使用帮助                       │\033[0m")
+        click.echo("\033[1;36m╰─────────────────────────────────────────────╯\033[0m")
+        click.echo("")
+        click.echo("\033[1m内置命令：\033[0m")
+        click.echo("  \033[36m/help\033[0m                  显示本帮助")
+        click.echo("  \033[36m/clear\033[0m                 清空当前会话上下文")
+        click.echo("  \033[36m/exit\033[0m, \033[36m/quit\033[0m            退出 CLI")
+        click.echo("  \033[36m/config\033[0m                查看当前配置")
+        click.echo("  \033[36m/model\033[0m                 交互式切换模型（上下键选 + 回车）")
+        click.echo("  \033[36m/thinking\033[0m              查看或开关思考模式（on/off）")
+        click.echo("  \033[36m/show-reasoning\033[0m        开关思考过程在屏幕上的显示")
+        click.echo("")
+        click.echo("\033[1m配置管理：\033[0m")
+        click.echo("  \033[33m/config set api-key <key>\033[0m    设置 API Key")
+        click.echo("  \033[33m/config set model <name>\033[0m     设置模型（deepseek-v4-pro / deepseek-v4-flash）")
+        click.echo("  \033[33m/config set thinking <on|off>\033[0m 开关思考模式")
+        click.echo("  \033[33m/config set max-tokens <n>\033[0m   设置单次响应最大 token 数")
+        click.echo("  \033[33m/config unset <key>\033[0m         删除某项配置（恢复默认值）")
+        click.echo("")
+        click.echo("\033[1m小贴士：\033[0m")
+        click.echo("  • 输入 \033[33m/\033[0m 会弹出补全菜单（上下键选 + Tab 补全）")
+        click.echo("  • 输入 \033[33m@\033[0m 引用文件或目录到上下文")
+        click.echo("  • 按 \033[33m↑\033[0m / \033[33m↓\033[0m 翻历史消息")
+        click.echo("  • 按 \033[33mEsc\033[0m 取消当前补全菜单")
+        click.echo("  • 配置文件位置：\033[33m~/.abyss/config.json\033[0m")
+        click.echo("")
+        return True
+
+    # /config
+    if cmd == "/config":
+        if len(parts) == 1:
+            click.echo("当前配置:")
+            for k, v in cfg.to_dict().items():
+                if k == "api_key" and v:
+                    v = v[:8] + "****" + v[-4:]
+                click.echo(f"  {k}: {v}")
+            return True
+        if len(parts) >= 3 and parts[1] == "set":
+            key = parts[2]
+            has_value = len(parts) >= 4
+            val_str = parts[3] if has_value else None
+
+            if key == "api-key":
+                if has_value:
+                    val = " ".join(parts[3:])
+                    cfg.set("api_key", val)
+                    client.api_key = val
+                    client.client.api_key = val
+                    click.echo(f"[OK] API Key 已保存")
+                else:
+                    click.echo(f"用法: /config set api-key <你的Key>")
+                return True
+            if key == "model":
+                if has_value:
+                    cfg.set("model", val_str)
+                    click.echo(f"[OK] 模型 → {val_str}")
+                else:
+                    click.echo(f"当前模型: {cfg.get('model')}")
+                    click.echo(f"用法: /config set model <模型名>")
+                return True
+            if key == "thinking":
+                if has_value:
+                    val = val_str.lower() in ("on", "true", "1", "yes")
+                    cfg.set("thinking", val)
+                else:
+                    val = not cfg.get("thinking")
+                    cfg.set("thinking", val)
+                click.echo(f"[OK] 思考模式: {'开' if val else '关'}")
+                return True
+            if key == "max-tokens":
+                if has_value:
+                    try:
+                        cfg.set("max_tokens", int(val_str))
+                        click.echo(f"[OK] max_tokens → {val_str}")
+                    except ValueError:
+                        click.echo(f"请输入有效数字，当前: {cfg.get('max_tokens')}")
+                else:
+                    click.echo(f"当前 max_tokens: {cfg.get('max_tokens')}")
+                    click.echo(f"用法: /config set max-tokens <数字>")
+                return True
+
+            click.echo(f"未知配置项: {key}")
+            click.echo(f"可用: api-key, model, thinking, max-tokens")
+            return True
+        # /config unset <key>
+        if len(parts) >= 3 and parts[1] == "unset":
+            key = parts[2]
+            if cfg.delete(key):
+                click.echo(f"[OK] 已删除配置项: {key}")
+            else:
+                click.echo(f"[INFO] 配置项 {key} 本就不存在（已忽略）")
+            return True
+        return True
+
+    # /model
+    if cmd == "/model":
+        if len(parts) == 1:
+            # 无参数：弹出交互式选择器（上下键选 + 回车确认）
+            from .ansi_menu import ansi_select
+            options = ["deepseek-v4-pro", "deepseek-v4-flash"]
+            current = cfg.get("model")
+            # 高亮当前正在用的模型（如果存在）
+            try:
+                default_idx = options.index(current)
+            except ValueError:
+                default_idx = 0
+            selected = ansi_select("选择模型", options, default_idx=default_idx)
+            if selected:
+                cfg.set("model", selected)
+                click.echo(f"[OK] 已切换: {selected}")
+            return True
+        m = parts[1]
+        if m in ("deepseek-v4-pro", "deepseek-v4-flash"):
+            cfg.set("model", m)
+            click.echo(f"[OK] 已切换: {m}")
+        else:
+            click.echo(f"未知模型: {m}，可用: deepseek-v4-pro, deepseek-v4-flash")
+        return True
+
+    # /thinking
+    if cmd == "/thinking":
+        if len(parts) == 1:
+            click.echo(f"思考模式: {'开' if cfg.get('thinking') else '关'}")
+            return True
+        val = parts[1].lower() in ("on", "true", "1", "yes")
+        cfg.set("thinking", val)
+        click.echo(f"[OK] 思考模式: {'开' if val else '关'}")
+        return True
+
+    # /show-reasoning
+    if cmd == "/show-reasoning":
+        sr[0] = not sr[0]
+        # 同步写盘，重启后不丢失（用户反馈：UI 切到 true 磁盘仍是 false）
+        cfg.set("show_reasoning", sr[0])
+        click.echo(f"[OK] 思考过程显示: {'开' if sr[0] else '关'} (已保存)")
+        return True
+
+    return False
+
+
+def first_time_setup(cfg):
+    """首次启动引导设置 API Key"""
+    click.echo("""
+  ╔══════════════════════════════════╗
+  ║       abyss - 终端 AI 助手       ║
+  ╚══════════════════════════════════╝
+
+  首次使用需要配置 DeepSeek API Key。
+  获取 Key: https://platform.deepseek.com/api_keys
+""")
+    key = click.prompt("API Key", type=str, default="").strip()
+    if key:
+        cfg.set("api_key", key)
+        click.echo("[OK] 配置完成\n")
+        return True
+    else:
+        click.echo("跳过，稍后可用 /config set api-key <key> 配置\n")
+        return False
+
+
+def resolve_at_references(user_input: str) -> str:
+    """解析 @ 文件引用，将当前目录下的文件内容添加到消息上下文中"""
+    pattern = re.compile(r'@([^\s@,，。;；:：!！?？\'\"\(\)\[\]{}<>]+)')
+    matches = list(pattern.finditer(user_input))
+    if not matches:
+        return user_input
+
+    cwd = os.getcwd()
+    file_contents = []
+
+    for m in matches:
+        file_path = m.group(1)
+        full_path = os.path.join(cwd, file_path)
+        full_path = os.path.normpath(full_path)
+
+        if not os.path.isfile(full_path):
+            continue
+
+        try:
+            with open(full_path, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+
+            if len(content) > 8000:
+                total = len(content)
+                content = content[:8000] + f"\n...[文件过长, 已截断, 共 {total} 字符]"
+
+            file_contents.append((file_path, content))
+        except Exception:
+            continue
+
+    if not file_contents:
+        return user_input
+
+    for fp, _ in file_contents:
+        click.echo(f"  \033[2m📎 @{fp}\033[0m")
+
+    parts = []
+    for fp, content in file_contents:
+        ext = os.path.splitext(fp)[1].lstrip(".") or "text"
+        parts.append(f"[文件: {fp}]\n```{ext}\n{content}\n```")
+
+    return "\n\n".join(parts) + "\n\n---\n" + user_input
+
+
+def run_with_pt(cfg, show_reasoning=False):
+    """运行对话循环（使用自定义 ANSI 补全菜单）"""
+    logger.session_start(model=cfg.get("model"), cwd=os.getcwd())
+
+    if not cfg.is_ready():
+        first_time_setup(cfg)
+
+    system_prompt = load_system_prompt()
+    session = Session(system_prompt)
+    client = DeepSeekClient(
+        api_key=cfg.get("api_key"),
+        base_url=cfg.get("base_url")
+    )
+    tools_schemas = [t.to_openai_schema() for t in TOOLS.values()]
+    sr = [show_reasoning]
+
+    click.echo(f"模型: {cfg.get('model')}  |  / 命令  @ 文件\n")
+
+    while True:
+        try:
+            sys.stdout.flush()
+            user_input = ansi_prompt("> ").strip()
+            if not user_input:
+                continue
+
+            if user_input.startswith("/"):
+                logger.slash_command(user_input)
+                # 回显用户输入的命令，给个视觉确认（避免以为命令没收到）
+                click.echo(f"  \033[2m> {user_input}\033[0m")
+                result = handle_slash_command(user_input, session, client, cfg, sr)
+                if result == "exit":
+                    logger.session_end("exit_command")
+                    break
+                if result:
+                    continue
+
+            logger.user_input(user_input)
+
+            if not cfg.is_ready():
+                click.echo("请先配置 API Key: /config set api-key <your-key>")
+                continue
+
+            user_input = resolve_at_references(user_input)
+            session.add_user(user_input)
+
+            reasoning_buffer = ""
+            content_buffer = ""
+            current_tool_calls = []
+
+            spinner = Spinner()
+            spinner.start()
+
+            api_start = time.time()
+            first_token_logged = False
+            try:
+                for chunk in client.chat(
+                    messages=session.get_messages_for_api(),
+                    tools=tools_schemas, stream=True,
+                    model=cfg.get("model"), thinking=cfg.get("thinking"),
+                    reasoning_effort=cfg.get("reasoning_effort"),
+                    max_tokens=cfg.get("max_tokens"), user_id=cfg.get("user_id")
+                ):
+                    if not first_token_logged and (chunk.get("reasoning_content") or chunk.get("content")):
+                        logger.api_first_token(int((time.time() - api_start) * 1000))
+                        first_token_logged = True
+                    if chunk.get("reasoning_content"):
+                        if sr[0] and not reasoning_buffer:
+                            spinner.stop()
+                            # 整段 reasoning 走灰色（dim + 亮黑 = 真正的灰色）
+                            click.echo("  \033[2;90m思考: ", nl=False)
+                            logger.stream_reasoning_start()
+                        reasoning_buffer += chunk["reasoning_content"]
+                        if sr[0]:
+                            click.echo(chunk["reasoning_content"], nl=False)
+                            sys.stdout.flush()
+                    if chunk.get("content"):
+                        if not content_buffer:
+                            # 关闭暗色样式，回复正常字体
+                            if sr[0] and reasoning_buffer:
+                                click.echo("\033[0m", nl=False)
+                            spinner.stop()
+                            click.echo()
+                            logger.stream_content_start()
+                        content_buffer += chunk["content"]
+                        click.echo(chunk["content"], nl=False)
+                        sys.stdout.flush()
+                    if chunk.get("tool_calls"):
+                        current_tool_calls.extend(chunk["tool_calls"])
+                logger.api_response(api_ms=int((time.time() - api_start) * 1000),
+                                    content_len=len(content_buffer),
+                                    reasoning_len=len(reasoning_buffer),
+                                    tool_calls=len(current_tool_calls))
+            except Exception as e:
+                spinner.stop()
+                logger.api_error(str(e))
+                click.echo()
+                click.echo(f"  \033[31mAPI 调用失败: {e}\033[0m")
+                continue
+
+            spinner.stop()
+
+            if not content_buffer and not current_tool_calls:
+                # reasoning 后无 content 也无 tool_calls —— 手动关 dim
+                if sr[0] and reasoning_buffer:
+                    click.echo("\033[0m", nl=False)
+                click.echo()
+                click.echo(f"  \033[33m(模型未返回内容，请重试)\033[0m")
+                continue
+
+            if current_tool_calls:
+                # reasoning 后直接 tool_calls，没 content 触发复位 —— 手动关 dim
+                if sr[0] and reasoning_buffer and not content_buffer:
+                    click.echo("\033[0m", nl=False)
+                merged = merge_tool_calls(current_tool_calls)
+                process_tool_calls(session, client, tools_schemas,
+                                   merged, cfg, sr[0])
+            else:
+                session.add_assistant(
+                    content=content_buffer,
+                    reasoning_content=reasoning_buffer if reasoning_buffer else None
+                )
+
+            # AI 回复结束后确保光标在行首新行，
+            # 否则 ansi_prompt 的菜单会叠在回复文字下面。
+            click.echo()
+
+        except KeyboardInterrupt:
+            logger.keyboard_interrupt()
+            logger.session_end("keyboard_interrupt")
+            click.echo("\n再见!")
+            break
+        except EOFError:
+            logger.eof()
+            logger.session_end("eof")
+            click.echo("\n再见!")
+            break
+
+
+@click.command()
+@click.option("--model", "-m", help="指定模型 (deepseek-v4-pro / deepseek-v4-flash)")
+@click.option("--hide-reasoning", is_flag=True, help="隐藏思考过程（默认显示）")
+@click.option("--version", "-v", is_flag=True, help="显示版本")
+def cli(model, hide_reasoning, version):
+    """abyss - 终端 AI 开发助手"""
+    if version:
+        from . import __version__
+        click.echo(f"abyss v{__version__}")
+        return
+
+    cfg = Config()
+    if model:
+        cfg.set("model", model)
+
+    # 默认显示思考过程（用户已确认要"看效果"），--hide-reasoning 关闭
+    run_with_pt(cfg, show_reasoning=not hide_reasoning)
+
+
+if __name__ == "__main__":
+    cli()