jarvis-ai-assistant 0.3.34__py3-none-any.whl → 0.4.1__py3-none-any.whl

jarvis/jarvis_agent/rewrite_file_handler.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+from typing import Any, Dict, List, Tuple
+
+from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ct, ot
+
+
+class RewriteFileHandler(OutputHandler):
+    """
+    处理整文件重写指令的输出处理器。
+
+    指令格式：
+    <REWRITE file=文件路径>
+    新的文件完整内容
+    </REWRITE>
+
+    等价支持以下写法：
+    <REWRITE file=文件路径>
+    新的文件完整内容
+    </REWRITE>
+
+    说明：
+    - 该处理器用于完全重写文件内容，适用于新增文件或大范围改写
+    - 内部直接执行写入，提供失败回滚能力
+    - 支持同一响应中包含多个 REWRITE/REWRITE 块
+    """
+
+    def __init__(self) -> None:
+        # 允许 file 参数为单引号、双引号或无引号
+        self.rewrite_pattern_file = re.compile(
+            ot("REWRITE file=(?:'([^']+)'|\"([^\"]+)\"|([^>]+))")
+            + r"\s*"
+            + r"(.*?)"
+            + r"\s*"
+            + r"^"
+            + ct("REWRITE"),
+            re.DOTALL | re.MULTILINE,
+        )
+
+    def name(self) -> str:
+        """获取处理器名称，用于操作列表展示"""
+        return "REWRITE"
+
+    def prompt(self) -> str:
+        """返回用户提示，描述使用方法与格式"""
+        return f"""文件重写指令格式：
+{ot("REWRITE file=文件路径")}
+新的文件完整内容
+{ct("REWRITE")}
+
+注意：
+- {ot("REWRITE")}、{ct("REWRITE")} 必须出现在行首，否则不生效（会被忽略）
+- 整文件重写会完全替换文件内容，如需局部修改请使用 PATCH 操作
+- 该操作由处理器直接执行，具备失败回滚能力"""
+
+    def can_handle(self, response: str) -> bool:
+        """判断响应中是否包含 REWRITE/REWRITE 指令"""
+        return bool(self.rewrite_pattern_file.search(response))
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, str]:
+        """解析并执行整文件重写指令"""
+        rewrites = self._parse_rewrites(response)
+        if not rewrites:
+            return False, "未找到有效的文件重写指令"
+
+        # 记录 REWRITE 操作调用统计
+        try:
+            from jarvis.jarvis_stats.stats import StatsManager
+
+            StatsManager.increment("rewrite_file", group="tool")
+        except Exception:
+            # 统计失败不影响主流程
+            pass
+
+        results: List[str] = []
+        overall_success = True
+
+        for file_path, content in rewrites:
+            abs_path = os.path.abspath(file_path)
+            original_content = None
+            processed = False
+            try:
+                file_exists = os.path.exists(abs_path)
+                if file_exists:
+                    with open(abs_path, "r", encoding="utf-8") as rf:
+                        original_content = rf.read()
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                with open(abs_path, "w", encoding="utf-8") as wf:
+                    wf.write(content)
+                processed = True
+                results.append(f"✅ 文件 {abs_path} 重写成功")
+                # 记录成功处理的文件（使用绝对路径）
+                if agent:
+                    files = agent.get_user_data("files")
+                    if files:
+                        if abs_path not in files:
+                            files.append(abs_path)
+                    else:
+                        files = [abs_path]
+                    agent.set_user_data("files", files)
+            except Exception as e:
+                overall_success = False
+                # 回滚已修改内容
+                try:
+                    if processed:
+                        if original_content is None:
+                            if os.path.exists(abs_path):
+                                os.remove(abs_path)
+                        else:
+                            with open(abs_path, "w", encoding="utf-8") as wf:
+                                wf.write(original_content)
+                except Exception:
+                    pass
+                PrettyOutput.print(f"文件重写失败: {str(e)}", OutputType.ERROR)
+                results.append(f"❌ 文件 {abs_path} 重写失败: {str(e)}")
+
+        summary = "\n".join(results)
+        # 按现有 EditFileHandler 约定，始终返回 (False, summary) 以继续主循环
+        return False, summary
+
+    def _parse_rewrites(self, response: str) -> List[Tuple[str, str]]:
+        """
+        解析响应中的 REWRITE/REWRITE 指令块。
+        返回列表 [(file_path, content), ...]，按在响应中的出现顺序排序
+        """
+        items: List[Tuple[str, str]] = []
+        matches: List[Tuple[int, Any]] = []
+        for m in self.rewrite_pattern_file.finditer(response):
+            matches.append((m.start(), m))
+
+        # 按出现顺序排序
+        matches.sort(key=lambda x: x[0])
+
+        for _, m in matches:
+            file_path = m.group(1) or m.group(2) or m.group(3) or ""
+            file_path = file_path.strip()
+            content = m.group(4)
+            if file_path:
+                items.append((file_path, content))
+        return items

jarvis/jarvis_agent/run_loop.py

@@ -81,12 +81,13 @@ class AgentRunLoop:
                     pass
                 need_return, tool_prompt = ag._call_tools(current_response)
 
-                # 将上一个提示和工具提示安全地拼接起来
-                ag.session.prompt = join_prompts([ag.session.prompt, tool_prompt])
-
+                # 如果工具要求立即返回结果（例如 SEND_MESSAGE 需要将字典返回给上层），直接返回该结果
                 if need_return:
-                    return ag.session.prompt
+                    return tool_prompt
 
+                # 将上一个提示和工具提示安全地拼接起来（仅当工具结果为字符串时）
+                safe_tool_prompt = tool_prompt if isinstance(tool_prompt, str) else ""
+                ag.session.prompt = join_prompts([ag.session.prompt, safe_tool_prompt])
 
                 # 广播工具调用后的事件（不影响主流程）
                 try:

jarvis/jarvis_agent/stdio_redirect.py

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+"""
+Web STDIO 重定向模块：
+- 在 Web 模式下，将 Python 层的标准输出/错误（sys.stdout/sys.stderr）重定向到 WebSocket，通过 WebBridge 广播。
+- 适用于工具或第三方库直接使用 print()/stdout/stderr 的输出，从而不经过 PrettyOutput Sink 的场景。
+
+注意：
+- 这是进程级重定向，可能带来重复输出（PrettyOutput 已通过 Sink 广播一次，console.print 也会走到 stdout）。若需要避免重复，可在前端针对 'stdio' 类型进行独立显示或折叠。
+- 对于子进程输出（subprocess），通常由调用方决定是否捕获和打印；若直接透传到父进程的 stdout/stderr，也会被此重定向捕获。
+
+前端消息结构（通过 WebBridge.broadcast）：
+  { "type": "stdio", "stream": "stdout" | "stderr", "text": "..." }
+
+使用：
+  from jarvis.jarvis_agent.stdio_redirect import enable_web_stdio_redirect, disable_web_stdio_redirect
+  enable_web_stdio_redirect()
+  # ... 运行期间输出将通过 WS 广播 ...
+  disable_web_stdio_redirect()
+"""
+from __future__ import annotations
+
+import sys
+import threading
+from typing import Optional
+
+from jarvis.jarvis_agent.web_bridge import WebBridge
+
+
+_original_stdout = sys.stdout
+_original_stderr = sys.stderr
+_redirect_enabled = False
+_lock = threading.Lock()
+
+
+class _WebStreamWrapper:
+    """文件类兼容包装器，将 write() 的内容通过 WebBridge 广播。"""
+
+    def __init__(self, stream_name: str) -> None:
+        self._stream_name = stream_name
+        try:
+            self._encoding = getattr(_original_stdout, "encoding", "utf-8")
+        except Exception:
+            self._encoding = "utf-8"
+
+    def write(self, s: object) -> int:
+        try:
+            text = s if isinstance(s, str) else str(s)
+        except Exception:
+            text = repr(s)
+        try:
+            WebBridge.instance().broadcast({
+                "type": "stdio",
+                "stream": self._stream_name,
+                "text": text,
+            })
+        except Exception:
+            # 广播异常不影响主流程
+            pass
+        # 返回写入长度以兼容部分调用方
+        try:
+            return len(text)
+        except Exception:
+            return 0
+
+    def flush(self) -> None:
+        # 无需实际刷新；保持接口兼容
+        pass
+
+    def isatty(self) -> bool:
+        return False
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    def writelines(self, lines) -> None:
+        for ln in lines:
+            self.write(ln)
+
+    def __getattr__(self, name: str):
+        # 兼容性：必要时委派到原始 stdout/stderr 的属性（尽量避免）
+        try:
+            return getattr(_original_stdout if self._stream_name == "stdout" else _original_stderr, name)
+        except Exception:
+            raise AttributeError(name)
+
+
+def enable_web_stdio_redirect() -> None:
+    """启用全局 STDOUT/STDERR 到 WebSocket 的重定向。"""
+    global _redirect_enabled
+    with _lock:
+        if _redirect_enabled:
+            return
+        try:
+            sys.stdout = _WebStreamWrapper("stdout")  # type: ignore[assignment]
+            sys.stderr = _WebStreamWrapper("stderr")  # type: ignore[assignment]
+            _redirect_enabled = True
+        except Exception:
+            # 回退：保持原始输出
+            sys.stdout = _original_stdout
+            sys.stderr = _original_stderr
+            _redirect_enabled = False
+
+
+def disable_web_stdio_redirect() -> None:
+    """禁用全局 STDOUT/STDERR 重定向，恢复原始输出。"""
+    global _redirect_enabled
+    with _lock:
+        try:
+            sys.stdout = _original_stdout
+            sys.stderr = _original_stderr
+        except Exception:
+            pass
+        _redirect_enabled = False
+
+
+# ---------------------------
+# Web STDIN 重定向（浏览器 -> 后端）
+# ---------------------------
+# 目的：
+# - 将前端 xterm 的按键数据通过 WS 送回服务端，并作为 sys.stdin 的数据源
+# - 使得 Python 层的 input()/sys.stdin.readline() 等可以从浏览器获得输入
+# - 仅适用于部分交互式场景（非真正 PTY 行为），可满足基础行缓冲输入
+from queue import Queue, Empty
+
+
+_original_stdin = sys.stdin
+_stdin_enabled = False
+_stdin_wrapper = None  # type: ignore[assignment]
+
+
+class _WebInputWrapper:
+    """文件类兼容包装器：作为 sys.stdin 的替身，从队列中读取浏览器送来的数据。"""
+
+    def __init__(self) -> None:
+        self._queue: "Queue[str]" = Queue()
+        self._buffer: str = ""
+        self._lock = threading.Lock()
+        try:
+            self._encoding = getattr(_original_stdin, "encoding", "utf-8")  # type: ignore[name-defined]
+        except Exception:
+            self._encoding = "utf-8"
+
+    # 外部注入：由 WebSocket 端点调用
+    def feed(self, data: str) -> None:
+        try:
+            s = data if isinstance(data, str) else str(data)
+        except Exception:
+            s = repr(data)
+        # 将回车转换为换行，方便基于 readline 的读取
+        s = s.replace("\r", "\n")
+        self._queue.put_nowait(s)
+
+    # 基础读取：尽可能兼容常用调用
+    def read(self, size: int = -1) -> str:
+        # size < 0 表示尽可能多地读取（直到当前缓冲区内容）
+        if size == 0:
+            return ""
+
+        while True:
+            with self._lock:
+                if size > 0 and len(self._buffer) >= size:
+                    out = self._buffer[:size]
+                    self._buffer = self._buffer[size:]
+                    return out
+                if size < 0 and self._buffer:
+                    out = self._buffer
+                    self._buffer = ""
+                    return out
+            # 需要更多数据，阻塞等待
+            try:
+                chunk = self._queue.get(timeout=None)
+            except Exception:
+                chunk = ""
+            if not isinstance(chunk, str):
+                try:
+                    chunk = str(chunk)
+                except Exception:
+                    chunk = ""
+            with self._lock:
+                self._buffer += chunk
+
+    def readline(self, size: int = -1) -> str:
+        # 读取到换行符为止（包含换行），可选 size 限制
+        while True:
+            with self._lock:
+                idx = self._buffer.find("\n")
+                if idx != -1:
+                    # 找到换行
+                    end_index = idx + 1
+                    if size > 0:
+                        end_index = min(end_index, size)
+                    out = self._buffer[:end_index]
+                    self._buffer = self._buffer[end_index:]
+                    return out
+                # 未找到换行，但如果指定了 size 且缓冲已有足够数据，则返回
+                if size > 0 and len(self._buffer) >= size:
+                    out = self._buffer[:size]
+                    self._buffer = self._buffer[size:]
+                    return out
+            # 更多数据
+            try:
+                chunk = self._queue.get(timeout=None)
+            except Exception:
+                chunk = ""
+            if not isinstance(chunk, str):
+                try:
+                    chunk = str(chunk)
+                except Exception:
+                    chunk = ""
+            with self._lock:
+                self._buffer += chunk
+
+    def readlines(self, hint: int = -1):
+        lines = []
+        total = 0
+        while True:
+            ln = self.readline()
+            if not ln:
+                break
+            lines.append(ln)
+            total += len(ln)
+            if hint > 0 and total >= hint:
+                break
+        return lines
+
+    def writable(self) -> bool:
+        return False
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def flush(self) -> None:
+        pass
+
+    def isatty(self) -> bool:
+        # 伪装为 TTY，可改善部分库的行为（注意并非真正 PTY）
+        return True
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    def __getattr__(self, name: str):
+        # 尽量代理到原始 stdin 的属性以增强兼容性
+        try:
+            return getattr(_original_stdin, name)
+        except Exception:
+            raise AttributeError(name)
+
+
+def enable_web_stdin_redirect() -> None:
+    """启用 Web STDIN 重定向：将 sys.stdin 替换为浏览器数据源。"""
+    global _stdin_enabled, _stdin_wrapper, _original_stdin
+    with _lock:
+        if _stdin_enabled:
+            return
+        try:
+            # 记录原始 stdin（若尚未记录）
+            if "_original_stdin" not in globals() or _original_stdin is None:
+                _original_stdin = sys.stdin  # type: ignore[assignment]
+            _stdin_wrapper = _WebInputWrapper()
+            sys.stdin = _stdin_wrapper  # type: ignore[assignment]
+            _stdin_enabled = True
+        except Exception:
+            # 回退：保持原始输入
+            try:
+                sys.stdin = _original_stdin  # type: ignore[assignment]
+            except Exception:
+                pass
+            _stdin_enabled = False
+
+
+def disable_web_stdin_redirect() -> None:
+    """禁用 Web STDIN 重定向，恢复原始输入。"""
+    global _stdin_enabled, _stdin_wrapper
+    with _lock:
+        try:
+            sys.stdin = _original_stdin  # type: ignore[assignment]
+        except Exception:
+            pass
+        _stdin_wrapper = None
+        _stdin_enabled = False
+
+
+def feed_web_stdin(data: str) -> None:
+    """向 Web STDIN 注入数据（由 WebSocket /stdio 端点调用）。"""
+    try:
+        if _stdin_enabled and _stdin_wrapper is not None:
+            _stdin_wrapper.feed(data)  # type: ignore[attr-defined]
+    except Exception:
+        # 注入失败不影响主流程
+        pass

jarvis/jarvis_agent/utils.py

@@ -16,7 +16,11 @@ def join_prompts(parts: Iterable[str]) -> str:
     - 使用两个换行分隔
     - 不进行额外 strip，保持调用方原样语义
     """
-    non_empty: List[str] = [p for p in parts if p]
+    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:

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)