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

jarvis/jarvis_agent/shell_input_handler.py

@@ -3,6 +3,7 @@ from typing import Any, Tuple
 
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_agent.utils import join_prompts
 
 
 def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
@@ -11,9 +12,24 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
     if len(cmdline) == 0:
         return user_input, False
     else:
-        script = "\n".join([c[1:] for c in cmdline])
+        marker = "# JARVIS-NOCONFIRM"
+
+        def _clean(line: str) -> str:
+            s = line[1:]  # remove leading '!'
+            # strip no-confirm marker if present
+            idx = s.find(marker)
+            if idx != -1:
+                s = s[:idx]
+            return s.rstrip()
+
+        # Build script while stripping the no-confirm marker from each line
+        script = "\n".join([_clean(c) for c in cmdline])
         PrettyOutput.print(script, OutputType.CODE, lang="bash")
-        if user_confirm(f"是否要执行以上shell脚本？", default=True):
+
+        # If any line contains the no-confirm marker, skip the pre-execution confirmation
+        no_confirm = any(marker in c for c in cmdline)
+
+        if no_confirm or user_confirm("是否要执行以上shell脚本？", default=True):
             from jarvis.jarvis_tools.registry import ToolRegistry
 
             output = ToolRegistry().handle_tool_calls(
@@ -26,7 +42,11 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
             )
             if user_confirm("是否将执行结果反馈给Agent？", default=True):
                 return (
-                    f"{user_input}\n\n用户执行以下脚本：\n{script}\n\n执行结果：\n{output}",
+                    join_prompts([
+                        user_input,
+                        f"用户执行以下脚本：\n{script}",
+                        f"执行结果：\n{output}",
+                    ]),
                     False,
                 )
             return "", True

jarvis/jarvis_agent/stdio_redirect.py

@@ -0,0 +1,295 @@
+# -*- 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 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  # noqa: E402
+
+
+_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/task_analyzer.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+"""
+任务分析器模块
+负责处理任务分析和方法论生成功能
+"""
+
+from jarvis.jarvis_utils.globals import get_interrupt, set_interrupt
+
+from jarvis.jarvis_agent.prompts import TASK_ANALYSIS_PROMPT
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_agent.utils import join_prompts
+from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL, AFTER_TOOL_CALL, BEFORE_SUMMARY, TASK_COMPLETED
+
+
+class TaskAnalyzer:
+    """任务分析器，负责任务分析和满意度反馈处理"""
+
+    def __init__(self, agent):
+        """
+        初始化任务分析器
+
+        参数:
+            agent: Agent实例
+        """
+        self.agent = agent
+        self._analysis_done = False
+        # 旁路集成事件订阅，失败不影响主流程
+        try:
+            self._subscribe_events()
+        except Exception:
+            pass
+
+    def analysis_task(self, satisfaction_feedback: str = ""):
+        """分析任务并生成方法论"""
+
+        try:
+            # 准备分析提示
+            self.agent.session.prompt = self._prepare_analysis_prompt(
+                satisfaction_feedback
+            )
+
+            if not self.agent.model:
+                raise RuntimeError("Model not initialized")
+
+            # 循环处理工具调用，直到没有工具调用为止
+            self._process_analysis_loop()
+
+        except Exception:
+            PrettyOutput.print("分析失败", OutputType.ERROR)
+        finally:
+            # 标记已完成一次分析，避免事件回调重复执行
+            self._analysis_done = True
+            try:
+                self.agent.set_user_data("__task_analysis_done__", True)
+            except Exception:
+                pass
+
+    def _prepare_analysis_prompt(self, satisfaction_feedback: str) -> str:
+        """准备分析提示"""
+        return join_prompts([TASK_ANALYSIS_PROMPT, satisfaction_feedback])
+
+    def _process_analysis_loop(self):
+        """处理分析循环"""
+        while True:
+            response = self.agent.model.chat_until_success(self.agent.session.prompt)  # type: ignore
+            self.agent.session.prompt = ""
+
+            # 处理用户中断
+            if get_interrupt():
+                if not self._handle_analysis_interrupt(response):
+                    break
+
+            # 执行工具调用（补充事件：before_tool_call/after_tool_call）
+            try:
+                self.agent.event_bus.emit(
+                    BEFORE_TOOL_CALL,
+                    agent=self.agent,
+                    current_response=response,
+                )
+            except Exception:
+                pass
+            need_return, tool_prompt = self.agent._call_tools(response)
+            self.agent.session.prompt = tool_prompt
+            try:
+                self.agent.event_bus.emit(
+                    AFTER_TOOL_CALL,
+                    agent=self.agent,
+                    current_response=response,
+                    need_return=need_return,
+                    tool_prompt=tool_prompt,
+                )
+            except Exception:
+                pass
+
+            # 如果没有工具调用或者没有新的提示，退出循环
+            if not self.agent.session.prompt:
+                break
+
+    def _handle_analysis_interrupt(self, response: str) -> bool:
+        """处理分析过程中的用户中断
+
+        返回:
+            bool: True 继续分析，False 退出分析
+        """
+        set_interrupt(False)
+        user_input = self.agent._multiline_input(
+            "分析任务期间被中断，请输入用户干预信息：", False
+        )
+
+        if not user_input:
+            # 用户输入为空，退出分析
+            return False
+
+        if self._has_tool_calls(response):
+            self.agent.session.prompt = self._handle_interrupt_with_tool_calls(
+                user_input
+            )
+        else:
+            self.agent.session.prompt = f"被用户中断，用户补充信息为：{user_input}"
+
+        return True
+
+    def _has_tool_calls(self, response: str) -> bool:
+        """检查响应中是否有工具调用"""
+        return any(
+            handler.can_handle(response) for handler in self.agent.output_handler
+        )
+
+    def _handle_interrupt_with_tool_calls(self, user_input: str) -> str:
+        """处理有工具调用时的中断"""
+        if self.agent.confirm_callback("检测到有工具调用，是否继续处理工具调用？", True):
+            return join_prompts([
+                f"被用户中断，用户补充信息为：{user_input}",
+                "用户同意继续工具调用。"
+            ])
+        else:
+            return join_prompts([
+                f"被用户中断，用户补充信息为：{user_input}",
+                "检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。"
+            ])
+
+    def collect_satisfaction_feedback(self, auto_completed: bool) -> str:
+        """收集满意度反馈"""
+        satisfaction_feedback = ""
+
+        if not auto_completed and self.agent.use_analysis:
+            if self.agent.confirm_callback("您对本次任务的完成是否满意？", True):
+                satisfaction_feedback = "用户对本次任务的完成表示满意。"
+            else:
+                feedback = self.agent._multiline_input(
+                    "请提供您的反馈意见（可留空直接回车）:", False
+                )
+                if feedback:
+                    satisfaction_feedback = (
+                        f"用户对本次任务的完成不满意，反馈意见如下：\n{feedback}"
+                    )
+                else:
+                    satisfaction_feedback = (
+                        "用户对本次任务的完成不满意，未提供具体反馈意见。"
+                    )
+        elif auto_completed and self.agent.use_analysis:
+            # 自动完成模式下，仍然执行分析，但不收集用户反馈
+            satisfaction_feedback = "任务已自动完成，无需用户反馈。"
+
+        return satisfaction_feedback
+
+    # -----------------------
+    # 事件订阅与处理（旁路）
+    # -----------------------
+    def _subscribe_events(self) -> None:
+        bus = self.agent.get_event_bus()  # type: ignore[attr-defined]
+        # 在生成总结前触发（保持与原顺序一致）
+        bus.subscribe(BEFORE_SUMMARY, self._on_before_summary)
+        # 当无需总结时，作为兜底触发分析
+        bus.subscribe(TASK_COMPLETED, self._on_task_completed)
+
+    def _on_before_summary(self, **payload) -> None:
+        if self._analysis_done:
+            return
+        # 避免与直接调用重复
+        try:
+            if bool(self.agent.get_user_data("__task_analysis_done__")):
+                self._analysis_done = True
+                return
+        except Exception:
+            pass
+        auto_completed = bool(payload.get("auto_completed", False))
+        try:
+            feedback = self.collect_satisfaction_feedback(auto_completed)
+            if getattr(self.agent, "use_analysis", False):
+                self.analysis_task(feedback)
+        except Exception:
+            # 忽略事件处理异常，保证主流程
+            self._analysis_done = True
+
+    def _on_task_completed(self, **payload) -> None:
+        # 当未在 before_summary 阶段执行过时，作为兜底
+        if self._analysis_done:
+            return
+        try:
+            if bool(self.agent.get_user_data("__task_analysis_done__")):
+                self._analysis_done = True
+                return
+        except Exception:
+            pass
+        auto_completed = bool(payload.get("auto_completed", False))
+        try:
+            feedback = self.collect_satisfaction_feedback(auto_completed)
+            if getattr(self.agent, "use_analysis", False):
+                self.analysis_task(feedback)
+        except Exception:
+            self._analysis_done = True