jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_agent/tool_share_manager.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+"""工具分享管理模块"""
+import os
+import glob
+import shutil
+from typing import List, Dict, Any, Set
+
+import typer
+
+from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_agent.share_manager import ShareManager
+from jarvis.jarvis_utils.config import get_central_tool_repo, get_data_dir
+
+
+class ToolShareManager(ShareManager):
+    """工具分享管理器"""
+
+    def __init__(self):
+        central_repo = get_central_tool_repo()
+        if not central_repo:
+            PrettyOutput.print(
+                "错误：未配置中心工具仓库（JARVIS_CENTRAL_TOOL_REPO）",
+                OutputType.ERROR,
+            )
+            PrettyOutput.print(
+                "请在配置文件中设置中心工具仓库的Git地址", OutputType.INFO
+            )
+            raise typer.Exit(code=1)
+
+        super().__init__(central_repo, "central_tool_repo")
+
+    def get_resource_type(self) -> str:
+        """获取资源类型名称"""
+        return "工具"
+
+    def format_resource_display(self, resource: Dict[str, Any]) -> str:
+        """格式化资源显示"""
+        return f"{resource['tool_name']} ({resource['filename']})"
+
+    def get_existing_resources(self) -> Set[str]:
+        """获取中心仓库中已有的工具文件名"""
+        existing_tools = set()
+        for filepath in glob.glob(os.path.join(self.repo_path, "*.py")):
+            existing_tools.add(os.path.basename(filepath))
+        return existing_tools
+
+    def get_local_resources(self) -> List[Dict[str, Any]]:
+        """获取本地工具"""
+        # 获取中心仓库中已有的工具文件名
+        existing_tools = self.get_existing_resources()
+
+        # 只从数据目录的tools目录获取工具
+        local_tools_dir = os.path.join(get_data_dir(), "tools")
+        if not os.path.exists(local_tools_dir):
+            PrettyOutput.print(
+                f"本地工具目录不存在: {local_tools_dir}",
+                OutputType.WARNING,
+            )
+            return []
+
+        # 收集本地工具文件（排除已存在的）
+        tool_files = []
+        for filepath in glob.glob(os.path.join(local_tools_dir, "*.py")):
+            filename = os.path.basename(filepath)
+            # 跳过__init__.py和已存在的文件
+            if filename == "__init__.py" or filename in existing_tools:
+                continue
+
+            # 尝试获取工具名称（通过简单解析）
+            tool_name = filename[:-3]  # 移除.py后缀
+            tool_files.append(
+                {
+                    "path": filepath,
+                    "filename": filename,
+                    "tool_name": tool_name,
+                }
+            )
+
+        return tool_files
+
+    def share_resources(self, resources: List[Dict[str, Any]]) -> List[str]:
+        """分享工具到中心仓库"""
+        # 确认操作
+        share_list = ["\n将要分享以下工具到中心仓库（注意：文件将被移动而非复制）："]
+        for tool in resources:
+            share_list.append(f"- {tool['tool_name']} ({tool['filename']})")
+        PrettyOutput.print("\n".join(share_list), OutputType.WARNING)
+
+        if not user_confirm("确认移动这些工具到中心仓库吗？（原文件将被删除）"):
+            return []
+
+        # 移动选中的工具到中心仓库
+        moved_list = []
+        for tool in resources:
+            src_file = tool["path"]
+            dst_file = os.path.join(self.repo_path, tool["filename"])
+            shutil.move(src_file, dst_file)  # 使用move而不是copy
+            moved_list.append(f"已移动: {tool['tool_name']}")
+
+        return moved_list
+
+    def run(self) -> None:
+        """执行工具分享流程"""
+        try:
+            # 更新中心仓库
+            self.update_central_repo()
+
+            # 获取本地资源
+            local_resources = self.get_local_resources()
+            if not local_resources:
+                PrettyOutput.print(
+                    "没有找到新的工具文件（所有工具可能已存在于中心仓库）",
+                    OutputType.WARNING,
+                )
+                return
+
+            # 选择要分享的资源
+            selected_resources = self.select_resources(local_resources)
+            if not selected_resources:
+                return
+
+            # 分享资源
+            moved_list = self.share_resources(selected_resources)
+            if moved_list:
+                # 一次性显示所有移动结果
+                PrettyOutput.print("\n".join(moved_list), OutputType.SUCCESS)
+
+                # 提交并推送
+                self.commit_and_push(len(selected_resources))
+
+                PrettyOutput.print("\n工具已成功分享到中心仓库！", OutputType.SUCCESS)
+                PrettyOutput.print(
+                    f"原文件已从 {os.path.join(get_data_dir(), 'tools')} 移动到中心仓库",
+                    OutputType.INFO,
+                )
+
+        except Exception as e:
+            PrettyOutput.print(f"分享工具时出错: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)

jarvis/jarvis_agent/user_interaction.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+UserInteractionHandler: 抽象用户交互（多行输入与确认）逻辑，便于将来替换为 TUI/WebUI。
+
+阶段一（最小变更）：
+- 仅提供封装，不直接修改 Agent 的现有调用
+- 后续步骤在 Agent 中以旁路方式接入，保持向后兼容
+"""
+from typing import Callable
+
+
+
+class UserInteractionHandler:
+    def __init__(
+        self,
+        multiline_inputer: Callable[..., str],
+        confirm_func: Callable[[str, bool], bool],
+    ) -> None:
+        """
+        参数:
+          - multiline_inputer: 提供多行输入的函数，优先支持 (tip, print_on_empty=bool)，兼容仅接受 (tip) 的实现
+          - confirm_func: 用户确认函数 (tip: str, default: bool) -> bool
+        """
+        self._multiline_inputer = multiline_inputer
+        self._confirm = confirm_func
+
+    def multiline_input(self, tip: str, print_on_empty: bool) -> str:
+        """
+        多行输入封装：兼容两类签名
+        1) func(tip, print_on_empty=True/False)
+        2) func(tip)
+        """
+        try:
+            return self._multiline_inputer(tip, print_on_empty=print_on_empty)  # type: ignore[call-arg]
+        except TypeError:
+            return self._multiline_inputer(tip)  # type: ignore[misc]
+
+    def confirm(self, tip: str, default: bool = True) -> bool:
+        """
+        用户确认封装，直接委派
+        """
+        return self._confirm(tip, default)

jarvis/jarvis_agent/utils.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+工具函数（jarvis_agent.utils）
+
+- join_prompts: 统一的提示拼接策略（仅拼接非空段落，使用双换行）
+- is_auto_complete: 统一的自动完成标记检测
+"""
+from typing import Iterable, List, Any
+from enum import Enum
+from jarvis.jarvis_utils.tag import ot
+
+def join_prompts(parts: Iterable[str]) -> str:
+    """
+    将多个提示片段按统一规则拼接：
+    - 过滤掉空字符串
+    - 使用两个换行分隔
+    - 不进行额外 strip，保持调用方原样语义
+    """
+    try:
+        non_empty: List[str] = [p for p in parts if isinstance(p, str) and p]
+    except Exception:
+        # 防御性处理：若 parts 不可迭代或出现异常，直接返回空字符串
+        return ""
+    return "\n\n".join(non_empty)
+
+def is_auto_complete(response: str) -> bool:
+    """
+    检测是否包含自动完成标记。
+    当前实现：包含 ot('!!!COMPLETE!!!') 即视为自动完成。
+    """
+    try:
+        return ot("!!!COMPLETE!!!") in response
+    except Exception:
+        # 防御性处理：即使 ot 出现异常，也不阻塞主流程
+        return "!!!COMPLETE!!!" in response
+
+def normalize_next_action(next_action: Any) -> str:
+    """
+    规范化下一步动作为字符串:
+    - 如果是 Enum, 返回其 value（若为字符串）
+    - 如果是 str, 原样返回
+    - 其他情况返回空字符串
+    """
+    try:
+        if isinstance(next_action, Enum):
+            value = getattr(next_action, "value", None)
+            return value if isinstance(value, str) else ""
+        if isinstance(next_action, str):
+            return next_action
+        return ""
+    except Exception:
+        return ""
+
+__all__ = ["join_prompts", "is_auto_complete", "normalize_next_action"]

jarvis/jarvis_agent/web_bridge.py

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+"""
+WebBridge: WebSocket 交互桥
+- 提供线程安全的广播能力（后续由 WebSocket 服务注册发送函数）
+- 提供阻塞式的多行输入与确认请求（通过 request_* 发起请求，等待浏览器端响应）
+- 适配 Agent 的输入注入接口：web_multiline_input / web_user_confirm
+- 事件约定（发往前端，均为 JSON 对象）:
+  * {"type":"input_request","mode":"multiline","tip": "...","print_on_empty": true/false,"request_id":"..."}
+  * {"type":"confirm_request","tip":"...","default": true/false,"request_id":"..."}
+  后续输出事件由输出Sink负责（使用 PrettyOutput.add_sink 接入），不在本桥内实现。
+- 事件约定（来自前端）:
+  * {"type":"user_input","request_id":"...","text":"..."}
+  * {"type":"confirm_response","request_id":"...","value": true/false}
+"""
+from __future__ import annotations
+
+import threading
+import uuid
+from queue import Queue, Empty
+from typing import Callable, Dict, Optional, Set, Any
+
+DEFAULT_WAIT_TIMEOUT = None  # 阻塞等待直到收到响应（可按需改为秒数）
+
+
+class WebBridge:
+    """
+    线程安全的 WebSocket 交互桥。
+    - 维护一组客户端发送函数（由Web服务注册），用于广播事件
+    - 维护挂起的输入/确认请求队列，按 request_id 匹配响应
+    """
+
+    _instance_lock = threading.Lock()
+    _instance: Optional["WebBridge"] = None
+
+    def __init__(self) -> None:
+        self._clients: Set[Callable[[Dict[str, Any]], None]] = set()
+        self._clients_lock = threading.Lock()
+
+        # 按 request_id 等待的阻塞队列
+        self._pending_inputs: Dict[str, Queue] = {}
+        self._pending_confirms: Dict[str, Queue] = {}
+        self._pending_lock = threading.Lock()
+
+    @classmethod
+    def instance(cls) -> "WebBridge":
+        with cls._instance_lock:
+            if cls._instance is None:
+                cls._instance = WebBridge()
+            return cls._instance
+
+    # ---------------------------
+    # 客户端管理与广播
+    # ---------------------------
+    def add_client(self, sender: Callable[[Dict[str, Any]], None]) -> None:
+        """
+        注册一个客户端发送函数。发送函数需接受一个 dict，并自行完成异步发送。
+        例如在 FastAPI/WS 中包装成 enqueue 到事件循环的任务。
+        """
+        with self._clients_lock:
+            self._clients.add(sender)
+
+    def remove_client(self, sender: Callable[[Dict[str, Any]], None]) -> None:
+        with self._clients_lock:
+            if sender in self._clients:
+                self._clients.remove(sender)
+
+    def broadcast(self, payload: Dict[str, Any]) -> None:
+        """
+        广播一条消息给所有客户端。失败的客户端不影响其他客户端。
+        """
+        with self._clients_lock:
+            targets = list(self._clients)
+        for send in targets:
+            try:
+                send(payload)
+            except Exception:
+                # 静默忽略单个客户端的发送异常
+                pass
+
+    # ---------------------------
+    # 输入/确认 请求-响应 管理
+    # ---------------------------
+    def request_multiline_input(self, tip: str, print_on_empty: bool = True, timeout: Optional[float] = DEFAULT_WAIT_TIMEOUT) -> str:
+        """
+        发起一个多行输入请求并阻塞等待浏览器返回。
+        返回用户输入的文本（可能为空字符串，表示取消）。
+        """
+        req_id = uuid.uuid4().hex
+        q: Queue = Queue(maxsize=1)
+        with self._pending_lock:
+            self._pending_inputs[req_id] = q
+
+        self.broadcast({
+            "type": "input_request",
+            "mode": "multiline",
+            "tip": tip,
+            "print_on_empty": bool(print_on_empty),
+            "request_id": req_id,
+        })
+
+        try:
+            if timeout is None:
+                result = q.get()  # 阻塞直到有结果
+            else:
+                result = q.get(timeout=timeout)
+        except Empty:
+            result = ""  # 超时回退为空
+        finally:
+            with self._pending_lock:
+                self._pending_inputs.pop(req_id, None)
+
+        # 规范化为字符串
+        return str(result or "")
+
+    def request_confirm(self, tip: str, default: bool = True, timeout: Optional[float] = DEFAULT_WAIT_TIMEOUT) -> bool:
+        """
+        发起一个确认请求并阻塞等待浏览器返回。
+        返回 True/False，若超时则回退为 default。
+        """
+        req_id = uuid.uuid4().hex
+        q: Queue = Queue(maxsize=1)
+        with self._pending_lock:
+            self._pending_confirms[req_id] = q
+
+        self.broadcast({
+            "type": "confirm_request",
+            "tip": tip,
+            "default": bool(default),
+            "request_id": req_id,
+        })
+
+        try:
+            if timeout is None:
+                result = q.get()
+            else:
+                result = q.get(timeout=timeout)
+        except Empty:
+            result = default
+        finally:
+            with self._pending_lock:
+                self._pending_confirms.pop(req_id, None)
+
+        return bool(result)
+
+    # ---------------------------
+    # 由 Web 服务回调：注入用户响应
+    # ---------------------------
+    def post_user_input(self, request_id: str, text: str) -> None:
+        """
+        注入浏览器端的多行输入响应。
+        """
+        with self._pending_lock:
+            q = self._pending_inputs.get(request_id)
+        if q:
+            try:
+                q.put_nowait(text)
+            except Exception:
+                pass
+
+    def post_confirm(self, request_id: str, value: bool) -> None:
+        """
+        注入浏览器端的确认响应。
+        """
+        with self._pending_lock:
+            q = self._pending_confirms.get(request_id)
+        if q:
+            try:
+                q.put_nowait(bool(value))
+            except Exception:
+                pass
+
+
+# ---------------------------
+# 供 Agent 注入的输入函数
+# ---------------------------
+def web_multiline_input(tip: str, print_on_empty: bool = True) -> str:
+    """
+    适配 Agent.multiline_inputer 签名的多行输入函数。
+    在 Web 模式下被注入到 Agent，转由浏览器端输入。
+    """
+    return WebBridge.instance().request_multiline_input(tip, print_on_empty)
+
+
+def web_user_confirm(tip: str, default: bool = True) -> bool:
+    """
+    适配 Agent.confirm_callback 签名的确认函数。
+    在 Web 模式下被注入到 Agent，转由浏览器端确认。
+    """
+    return WebBridge.instance().request_confirm(tip, default)

jarvis/jarvis_agent/web_output_sink.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""
+WebSocketOutputSink: 将 PrettyOutput 的输出事件通过 WebBridge 广播给前端（WebSocket 客户端）
+
+用法：
+- 在 Web 模式启动时，注册该 Sink：
+    from jarvis.jarvis_utils.output import PrettyOutput
+    from jarvis.jarvis_agent.web_output_sink import WebSocketOutputSink
+    PrettyOutput.add_sink(WebSocketOutputSink())
+
+- Web 端收到的消息结构：
+    {
+      "type": "output",
+      "payload": {
+        "text": "...",
+        "output_type": "INFO" | "ERROR" | ...,
+        "timestamp": true/false,
+        "lang": "markdown" | "python" | ... | null,
+        "traceback": false,
+        "section": null | "标题",
+        "context": { ... } | null
+      }
+    }
+"""
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from jarvis.jarvis_utils.output import OutputSink, OutputEvent
+from jarvis.jarvis_agent.web_bridge import WebBridge
+
+
+class WebSocketOutputSink(OutputSink):
+    """将输出事件广播到 WebSocket 前端的 OutputSink 实现。"""
+
+    def emit(self, event: OutputEvent) -> None:
+        try:
+            payload: Dict[str, Any] = {
+                "type": "output",
+                "payload": {
+                    "text": event.text,
+                    "output_type": event.output_type.value,
+                    "timestamp": bool(event.timestamp),
+                    "lang": event.lang,
+                    "traceback": bool(event.traceback),
+                    "section": event.section,
+                    "context": event.context,
+                },
+            }
+            WebBridge.instance().broadcast(payload)
+        except Exception:
+            # 广播过程中的异常不应影响其他输出后端
+            pass