abyss-cli 0.1.3__tar.gz → 0.1.4__tar.gz

{abyss_cli-0.1.3/src/abyss_cli.egg-info → abyss_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abyss-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: 终端AI开发助手
 Author: Abyss Team
 Requires-Python: >=3.9
@@ -9,3 +9,4 @@ Requires-Dist: click>=8.0.0
 Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: ddgs>=9.0.0
 Requires-Dist: httpx>=0.20.0
+Requires-Dist: mcp>=1.0.0

{abyss_cli-0.1.3 → abyss_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "abyss-cli"
-version = "0.1.3"
+version = "0.1.4"
 description = "终端AI开发助手"
 authors = [{name = "Abyss Team"}]
 requires-python = ">=3.9"
@@ -14,6 +14,7 @@ dependencies = [
     "prompt-toolkit>=3.0.0",
     "ddgs>=9.0.0",
     "httpx>=0.20.0",
+    "mcp>=1.0.0",
 ]
 
 [project.scripts]
@@ -25,7 +26,7 @@ packages = [
     "abyss", "abyss.tools", "abyss.prompts",
     "abyss.commands", "abyss.extensions",
     "abyss.hooks", "abyss.mcp", "abyss.skills",
-    "abyss.subagent",
+    "abyss.subagent", "abyss.runtime",
 ]
 include-package-data = true
 

{abyss_cli-0.1.3 → abyss_cli-0.1.4}/src/abyss/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Abyss - 终端AI开发助手"""
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 

{abyss_cli-0.1.3 → abyss_cli-0.1.4}/src/abyss/ansi_menu.py

@@ -34,6 +34,9 @@ COMMANDS = [
     ("/model", "查看/切换模型"),
     ("/thinking", "查看/开关思考模式"),
     ("/show-reasoning", "开关思考过程显示"),
+    ("/skills", "列出已加载的 Skill"),
+    ("/mcp", "列出 MCP server 和工具"),
+    ("/hooks", "列出已配置的 Hook"),
     ("/diagnose", "启动调试纪律流程"),
     ("/tdd", "启动 TDD 红-绿-重构流程"),
     ("/review", "审查当前 diff 的过度工程"),
@@ -412,8 +415,8 @@ def ansi_prompt(prompt_str: str = "> ") -> str:
         completions = []
         showing_menu = False
 
-    # 打印初始提示符
-    sys.stdout.write(prompt_str)
+    # 打印初始提示符（先清行，避免上一轮输出残留）
+    sys.stdout.write('\r\x1b[K' + prompt_str)
     sys.stdout.flush()
 
     while True:
@@ -447,8 +450,7 @@ def ansi_prompt(prompt_str: str = "> ") -> str:
                 continue
             elif special == 'P':  # 下箭头
                 if showing_menu and completions:
-                    vis = min(len(completions), max_visible)
-                    selected_idx = min(vis - 1, selected_idx + 1)
+                    selected_idx = min(len(completions) - 1, selected_idx + 1)
                     show_menu()
                 elif history_idx != -1:
                     # 历史翻看：↓ 调到更新一条（越界则回草稿）

{abyss_cli-0.1.3 → abyss_cli-0.1.4}/src/abyss/main.py

@@ -27,6 +27,7 @@ from .tools.registry import (
     create_default_registry, get_tc_field, merge_tool_calls, format_tool_result,
 )
 from .tools.spawn_subagents import SpawnSubagentsTool
+from .runtime import LifecycleHost
 from .ansi_menu import ansi_prompt
 from . import logger
 
@@ -34,6 +35,10 @@ from . import logger
 # 用 ToolRegistry 替代原硬编码 TOOLS dict，支持动态注册。
 REGISTRY = create_default_registry()
 
+# LifecycleHost 实例（run_with_pt 初始化，execute_tool 读取埋点）。
+# 模块级让 execute_tool 能访问 host 而无需改签名传递。
+_HOST: LifecycleHost = None
+
 # 工具调用往返轮数安全网（仅防 AI 死循环，正常任务不会达到）
 MAX_TOOL_ROUNDS = 100
 
@@ -54,6 +59,11 @@ _HELP_TEXT = """
   /thinking              查看或开关思考模式（on/off）
   /show-reasoning        开关思考过程在屏幕上的显示
 
+扩展系统：
+  /skills                列出已加载的 Skill
+  /mcp                   列出 MCP server 和工具
+  /hooks                 列出已配置的 Hook
+
 配置管理：
   /config set api-key <key>    设置 API Key
   /config set model <name>     设置模型（deepseek-v4-pro / deepseek-v4-flash）
@@ -178,6 +188,14 @@ def execute_tool(tool_call, batch_index: int = None, batch_total: int = None) ->
     if name not in REGISTRY:
         return json.dumps({"success": False, "error": f"未知工具: {name}"})
 
+    # PreToolUse 埋点：钩子可阻断工具调用
+    if _HOST is not None:
+        guard = _HOST.pre_tool(name, arguments)
+        if guard["block"]:
+            err = {"success": False, "error": f"被钩子阻断: {guard.get('reason', '')}"}
+            _show_tool_result(name, arguments, err)
+            return format_tool_result(name, err)
+
     _show_tool_action(name, arguments, batch_index, batch_total)
     logger.tool_start(name, args=args_str)
     t0 = time.time()
@@ -196,6 +214,10 @@ def execute_tool(tool_call, batch_index: int = None, batch_total: int = None) ->
     logger.tool_end(name, success=result.get("success", False), duration_ms=elapsed_ms,
                     out_len=len(format_tool_result(name, result)))
 
+    # PostToolUse 埋点：审计/日志，结果不回 LLM
+    if _HOST is not None:
+        _HOST.post_tool(name, arguments, result)
+
     return format_tool_result(name, result)
 
 
@@ -381,6 +403,10 @@ def process_tool_calls(session, client, tools_schemas, tool_calls, cfg, show_rea
 
         spinner.stop()
 
+        # PostLLMResponse 埋点：审计每轮 LLM 响应
+        if _HOST is not None:
+            _HOST.post_llm(content_buffer, new_tool_calls)
+
         if not content_buffer and not new_tool_calls:
             if show_reasoning and reasoning_buffer:
                 click.echo("\033[0m", nl=False)
@@ -558,6 +584,103 @@ def handle_slash_command(input_str: str, session, client, cfg, sr: list):
         click.echo(f"[OK] 思考过程显示: {'开' if sr[0] else '关'} (已保存)")
         return True
 
+    # /skills — Skill 列表/交互选择/直接注入
+    if cmd == "/skills":
+        if _HOST is None:
+            click.echo("[INFO] 扩展系统未加载")
+            return True
+        names = _HOST._skills.list_names()
+        if not names:
+            click.echo("[INFO] 未加载任何 skill（放入 ~/.abyss/skills/<name>/SKILL.md）")
+            return True
+        if len(parts) >= 2:
+            target = parts[1]
+            if target in names:
+                _HOST.inject_skill_by_name(session, target)
+                click.echo(f"[OK] 已注入 skill: {target}")
+            else:
+                click.echo(f"[ERR] 未找到 skill: {target}（可用: {', '.join(names)}）")
+            return True
+        from .ansi_menu import ansi_select
+        default_idx = 0
+        selected = ansi_select("选择 Skill 注入上下文 (Esc 取消)", names, default_idx=default_idx)
+        if selected:
+            _HOST.inject_skill_by_name(session, selected)
+            click.echo(f"[OK] 已注入 skill: {selected}")
+        return True
+
+    # /mcp — MCP server/工具 列表/详情
+    if cmd == "/mcp":
+        if _HOST is None:
+            click.echo("[INFO] 扩展系统未加载")
+            return True
+        servers = _HOST._mcp.servers
+        tools = _HOST._mcp.list_tool_names()
+        if len(parts) >= 2:
+            target = parts[1]
+            if target in servers:
+                srv_tools = [t for t in tools if t.startswith(f"mcp__{target}__")]
+                click.echo(f"server: {target} ({servers[target].transport.value}), {len(srv_tools)} 个工具:")
+                for t in srv_tools:
+                    desc = ""
+                    for s in _HOST._mcp.get_openai_schemas():
+                        if s.get("function", {}).get("name") == t:
+                            desc = s["function"].get("description", "")
+                            break
+                    click.echo(f"  • {t}  {desc}")
+            else:
+                click.echo(f"[ERR] 未找到 server: {target}（可用: {', '.join(servers.keys()) or '无'}）")
+            return True
+        if not servers and not tools:
+            click.echo("[INFO] 未配置 MCP server（编辑 ~/.abyss/mcp.json）")
+            return True
+        from .ansi_menu import ansi_select
+        options = [f"server: {n} ({c.transport.value})" for n, c in servers.items()]
+        options += [f"tool: {t}" for t in tools]
+        selected = ansi_select("MCP server / 工具 (Esc 取消)", options, default_idx=0)
+        if selected:
+            click.echo(f"  {selected}")
+            if selected.startswith("server: "):
+                sname = selected[8:].split(" ")[0]
+                srv_tools = [t for t in tools if t.startswith(f"mcp__{sname}__")]
+                for t in srv_tools:
+                    click.echo(f"    • {t}")
+        return True
+
+    # /hooks — Hook 事件列表/脚本详情
+    if cmd == "/hooks":
+        if _HOST is None:
+            click.echo("[INFO] 扩展系统未加载")
+            return True
+        events = ["PreToolUse", "PostToolUse", "PreLLMRequest", "PostLLMResponse"]
+        event_counts = {ev: len(_HOST._hooks.list_hooks(ev)) for ev in events}
+        if len(parts) >= 2:
+            target = parts[1]
+            if target in event_counts:
+                scripts = _HOST._hooks.list_hooks(target)
+                if scripts:
+                    click.echo(f"{target} ({len(scripts)} 个脚本):")
+                    for s in scripts:
+                        click.echo(f"  • {s.name}")
+                else:
+                    click.echo(f"[INFO] {target} 无脚本")
+            else:
+                click.echo(f"[ERR] 未知事件: {target}（可用: {', '.join(events)}）")
+            return True
+        options = [f"{ev} ({event_counts[ev]})" for ev in events if event_counts[ev] > 0]
+        if not options:
+            click.echo("[INFO] 未配置 hook（放入 ~/.abyss/hooks/<事件>/<脚本>）")
+            return True
+        from .ansi_menu import ansi_select
+        selected = ansi_select("Hook 事件 (Esc 取消)", options, default_idx=0)
+        if selected:
+            ev_name = selected.split(" ")[0]
+            scripts = _HOST._hooks.list_hooks(ev_name)
+            click.echo(f"  {ev_name}:")
+            for s in scripts:
+                click.echo(f"    • {s.name}")
+        return True
+
     return False
 
 
@@ -635,6 +758,7 @@ def resolve_at_references(user_input: str) -> str:
 
 def run_with_pt(cfg, show_reasoning=False):
     """运行对话循环（使用自定义 ANSI 补全菜单）"""
+    global _HOST
     logger.session_start(model=cfg.get("model"), cwd=os.getcwd())
 
     if not cfg.is_ready():
@@ -648,6 +772,14 @@ def run_with_pt(cfg, show_reasoning=False):
     )
     # 注册 spawn_subagents 工具（子 Agent 编排），6 个内置工具已在模块级注册
     REGISTRY.register(SpawnSubagentsTool(cfg=cfg, working_dir=os.getcwd()))
+
+    # 初始化 LifecycleHost：启动 Skill/MCP/Hook 三模块，注册 MCP 工具到 REGISTRY
+    _HOST = LifecycleHost.create_default(working_dir=os.getcwd())
+    _HOST.start()
+    mcp_count = _HOST.attach_mcp_tools(REGISTRY)
+    if mcp_count > 0:
+        click.echo(f"  \033[2m已加载 {mcp_count} 个 MCP 工具\033[0m")
+
     tools_schemas = REGISTRY.to_openai_schemas()
     sr = [show_reasoning]
 
@@ -682,6 +814,10 @@ def run_with_pt(cfg, show_reasoning=False):
                     click.echo("请先配置 API Key: /config set api-key <your-key>")
                     continue
 
+                # PreLLMRequest 埋点：用原始 user_input 匹配 skill 注入 system prompt
+                if _HOST is not None:
+                    _HOST.pre_llm(session, user_input)
+
                 user_input = resolve_at_references(user_input)
                 session.add_user(user_input)
 
@@ -712,6 +848,10 @@ def run_with_pt(cfg, show_reasoning=False):
 
             spinner.stop()
 
+            # PostLLMResponse 埋点：审计主循环 LLM 响应
+            if _HOST is not None:
+                _HOST.post_llm(content_buffer, current_tool_calls)
+
             if not content_buffer and not current_tool_calls:
                 # reasoning 后无 content 也无 tool_calls —— 手动关 dim
                 if sr[0] and reasoning_buffer:
@@ -740,11 +880,15 @@ def run_with_pt(cfg, show_reasoning=False):
         except KeyboardInterrupt:
             logger.keyboard_interrupt()
             logger.session_end("keyboard_interrupt")
+            if _HOST is not None:
+                _HOST.shutdown()
             click.echo("\n再见!")
             break
         except EOFError:
             logger.eof()
             logger.session_end("eof")
+            if _HOST is not None:
+                _HOST.shutdown()
             click.echo("\n再见!")
             break
 

abyss_cli-0.1.4/src/abyss/mcp/manager.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+"""
+MCP Client Manager 模块
+管理多个 MCP Server 连接，支持 stdio 传输（HTTP/SSE 暂未实现）。
+工具命名规则：mcp__<server_name>__<tool_name>，避免与内置工具冲突。
+
+配置文件格式（~/.abyss/mcp.json）：
+{
+  "mcp_servers": [
+    {"name": "github", "transport": "stdio", "command": "npx", "args": [...], "env": {...}}
+  ]
+}
+
+SDK 桥接：mcp 官方 SDK 全异步，本模块在内部维护后台事件循环线程，
+对外暴露同步接口（start_all/call_tool/stop_all），让 abyss 主同步代码无感调用。
+"""
+import asyncio
+import json
+import os
+import threading
+from contextlib import AsyncExitStack
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class MCPServerType(Enum):
+    """MCP Server 传输类型。"""
+    STDIO = "stdio"
+    HTTP = "http"
+    SSE = "sse"
+
+
+@dataclass
+class ServerConfig:
+    """单个 MCP Server 的配置。"""
+    name: str
+    transport: MCPServerType
+    command: Optional[str] = None
+    args: List[str] = field(default_factory=list)
+    env: Dict[str, str] = field(default_factory=dict)
+    url: Optional[str] = None
+    headers: Dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> Optional["ServerConfig"]:
+        """从配置字典构造 ServerConfig，必填字段缺失返回 None"""
+        name = data.get("name", "").strip()
+        transport_str = data.get("transport", "").strip().lower()
+        if not name or not transport_str:
+            return None
+        try:
+            transport = MCPServerType(transport_str)
+        except ValueError:
+            return None
+
+        if transport == MCPServerType.STDIO:
+            command = data.get("command", "").strip()
+            if not command:
+                return None
+            return cls(
+                name=name, transport=transport,
+                command=command,
+                args=data.get("args", []) or [],
+                env=data.get("env", {}) or {},
+            )
+        if transport in (MCPServerType.HTTP, MCPServerType.SSE):
+            url = data.get("url", "").strip()
+            if not url:
+                return None
+            return cls(
+                name=name, transport=transport,
+                url=url,
+                headers=data.get("headers", {}) or {},
+            )
+        return None
+
+
+class MCPClientManager:
+    """管理所有已注册的 MCP Server 连接与工具发现。
+    内部用后台事件循环线程桥接异步 mcp SDK，对外暴露同步接口。
+    """
+
+    def __init__(self, config_path: Optional[Path] = None):
+        self.servers: Dict[str, ServerConfig] = {}
+        # 工具全名 -> (server_name, original_tool_name, schema)
+        self._tools: Dict[str, Tuple[str, str, Dict[str, Any]]] = {}
+        # 运行中的 SDK 会话：server_name -> ClientSession
+        self._sessions: Dict[str, Any] = {}
+        # 持久化 async context（stdio_client + ClientSession 的 async with 栈）
+        self._cm_stacks: Dict[str, AsyncExitStack] = {}
+        # 后台事件循环（mcp SDK 全异步，用独立线程跑）
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._loop_thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+
+        if config_path is not None:
+            self._load_config(config_path)
+
+    def _load_config(self, config_path: Path) -> None:
+        """从 JSON 配置文件加载 mcp_servers"""
+        if not config_path.exists():
+            return
+        try:
+            with open(config_path, "r", encoding="utf-8-sig") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return
+        for server_data in data.get("mcp_servers", []) or []:
+            cfg = ServerConfig.from_dict(server_data)
+            if cfg is not None:
+                self.servers[cfg.name] = cfg
+
+    @staticmethod
+    def make_tool_name(server_name: str, tool_name: str) -> str:
+        """生成 MCP 工具的全名：mcp__<server>__<tool>"""
+        return f"mcp__{server_name}__{tool_name}"
+
+    def register_tool(self, server_name: str, tool_schema: Dict[str, Any]) -> None:
+        """注册一个已发现的 MCP 工具"""
+        original_name = tool_schema.get("name", "")
+        if not original_name:
+            return
+        full_name = self.make_tool_name(server_name, original_name)
+        self._tools[full_name] = (server_name, original_name, tool_schema)
+
+    def get_server_for_tool(self, full_name: str) -> Tuple[Optional[str], Optional[str]]:
+        """根据工具全名返回 (server_name, original_tool_name)，未注册返回 (None, None)"""
+        entry = self._tools.get(full_name)
+        if entry is None:
+            return (None, None)
+        return (entry[0], entry[1])
+
+    def get_openai_schemas(self) -> List[Dict[str, Any]]:
+        """生成所有 MCP 工具的 OpenAI function calling 定义"""
+        schemas = []
+        for full_name, (_, _, tool_schema) in self._tools.items():
+            schemas.append({
+                "type": "function",
+                "function": {
+                    "name": full_name,
+                    "description": tool_schema.get("description", ""),
+                    "parameters": tool_schema.get("inputSchema", {"type": "object", "properties": {}}),
+                }
+            })
+        return schemas
+
+    def list_tool_names(self) -> List[str]:
+        """返回所有已注册 MCP 工具的全名"""
+        return list(self._tools.keys())
+
+    def start_all(self) -> None:
+        """启动后台事件循环，握手所有 stdio MCP Server 并 discover 工具。失败仅告警不抛。"""
+        if self._loop is not None:
+            return  # 已启动
+        self._loop = asyncio.new_event_loop()
+        self._loop_thread = threading.Thread(target=self._loop.run_forever, daemon=True)
+        self._loop_thread.start()
+        # 在后台循环中跑握手 + discover
+        future = asyncio.run_coroutine_threadsafe(self._start_all_async(), self._loop)
+        try:
+            future.result(timeout=30)
+        except Exception as e:
+            # 握手失败不致命，工具调用时再报错
+            pass
+
+    async def _start_all_async(self) -> None:
+        """异步握手所有 stdio server：stdio_client + ClientSession + initialize + list_tools"""
+        from mcp import ClientSession
+        from mcp.client.stdio import stdio_client, StdioServerParameters
+
+        for name, cfg in self.servers.items():
+            if cfg.transport != MCPServerType.STDIO:
+                continue
+            if name in self._sessions:
+                continue
+            try:
+                stack = AsyncExitStack()
+                await stack.__aenter__()
+                env = {**os.environ, **cfg.env}
+                params = StdioServerParameters(
+                    command=cfg.command, args=list(cfg.args), env=env
+                )
+                read, write = await stack.enter_async_context(stdio_client(params))
+                session = await stack.enter_async_context(ClientSession(read, write))
+                await session.initialize()
+                self._sessions[name] = session
+                self._cm_stacks[name] = stack
+                # discover 工具并注册
+                tools_result = await session.list_tools()
+                for tool in tools_result.tools:
+                    self.register_tool(name, {
+                        "name": tool.name,
+                        "description": tool.description or "",
+                        "inputSchema": tool.inputSchema or {"type": "object", "properties": {}},
+                    })
+            except Exception:
+                # 单个 server 失败不影响其他
+                continue
+
+    def call_tool(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """同步调用 MCP 工具，通过后台事件循环提交异步任务。"""
+        if server_name not in self._sessions:
+            return {"success": False, "error": f"MCP server 未启动: {server_name}"}
+        if self._loop is None:
+            return {"success": False, "error": "MCP 事件循环未启动"}
+        future = asyncio.run_coroutine_threadsafe(
+            self._call_tool_async(server_name, tool_name, arguments),
+            self._loop,
+        )
+        try:
+            return future.result(timeout=30)
+        except Exception as e:
+            return {"success": False, "error": f"MCP 调用异常: {e}"}
+
+    async def _call_tool_async(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """异步调用单个 MCP 工具，把 SDK result 转成 dict。"""
+        session = self._sessions[server_name]
+        result = await session.call_tool(tool_name, arguments)
+        # SDK result.content 是 list[TextContent | ...]，拼成文本
+        text_parts = []
+        for block in (result.content or []):
+            text = getattr(block, "text", None)
+            if text:
+                text_parts.append(text)
+        return {
+            "success": not result.isError,
+            "stdout": "\n".join(text_parts),
+            "stderr": "" if not result.isError else "\n".join(text_parts),
+        }
+
+    def stop_all(self) -> None:
+        """关闭所有 MCP 会话 + 停止后台事件循环。幂等。"""
+        if self._loop is not None:
+            future = asyncio.run_coroutine_threadsafe(self._stop_async(), self._loop)
+            try:
+                future.result(timeout=5)
+            except Exception:
+                pass
+            self._loop.call_soon_threadsafe(self._loop.stop)
+            if self._loop_thread:
+                self._loop_thread.join(timeout=2)
+        self._sessions.clear()
+        self._cm_stacks.clear()
+        self._loop = None
+        self._loop_thread = None
+
+    async def _stop_async(self) -> None:
+        """异步关闭所有 async context 栈（stdio_client + ClientSession）。"""
+        for stack in self._cm_stacks.values():
+            try:
+                await stack.aclose()
+            except Exception:
+                pass
+
+
+def create_default_manager() -> MCPClientManager:
+    """创建指向 ~/.abyss/mcp.json 的默认 MCPClientManager"""
+    return MCPClientManager(config_path=Path.home() / ".abyss" / "mcp.json")

abyss_cli-0.1.4/src/abyss/runtime/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""
+运行时协调层
+LifecycleHost 在主 Agent 生命周期的关键节点统一调度 Skill / MCP / Hook 三模块。
+子 Agent 不接入 host（通过 create_subagent_registry() 天然隔离）。
+"""
+from .host import LifecycleHost, MCPToolProxy
+
+__all__ = ["LifecycleHost", "MCPToolProxy"]