jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_agent/task_analyzer.py

@@ -6,8 +6,7 @@
 
 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.prompts import get_task_analysis_prompt
 from jarvis.jarvis_agent.utils import join_prompts
 from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL, AFTER_TOOL_CALL, BEFORE_SUMMARY, TASK_COMPLETED
 
@@ -46,7 +45,7 @@ class TaskAnalyzer:
             self._process_analysis_loop()
 
         except Exception:
-            PrettyOutput.print("分析失败", OutputType.ERROR)
+            print("❌ 分析失败")
         finally:
             # 标记已完成一次分析，避免事件回调重复执行
             self._analysis_done = True
@@ -57,7 +56,30 @@ class TaskAnalyzer:
 
     def _prepare_analysis_prompt(self, satisfaction_feedback: str) -> str:
         """准备分析提示"""
-        return join_prompts([TASK_ANALYSIS_PROMPT, satisfaction_feedback])
+        # 检查是否有 save_memory 工具（工具可用性）
+        has_save_memory = False
+        # 检查是否有 generate_new_tool 工具
+        has_generate_new_tool = False
+        try:
+            tool_registry = self.agent.get_tool_registry()
+            if tool_registry:
+                # 检查 save_memory 工具
+                save_memory_tool = tool_registry.get_tool("save_memory")
+                has_save_memory = save_memory_tool is not None
+                
+                # 检查 generate_new_tool 工具
+                generate_tool = tool_registry.get_tool("generate_new_tool")
+                has_generate_new_tool = generate_tool is not None
+        except Exception:
+            pass
+        
+        # 根据配置获取相应的提示词
+        analysis_prompt = get_task_analysis_prompt(
+            has_save_memory=has_save_memory,
+            has_generate_new_tool=has_generate_new_tool
+        )
+        
+        return join_prompts([analysis_prompt, satisfaction_feedback])
 
     def _process_analysis_loop(self):
         """处理分析循环"""
@@ -128,7 +150,7 @@ class TaskAnalyzer:
 
     def _handle_interrupt_with_tool_calls(self, user_input: str) -> str:
         """处理有工具调用时的中断"""
-        if self.agent.user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
+        if self.agent.confirm_callback("检测到有工具调用，是否继续处理工具调用？", True):
             return join_prompts([
                 f"被用户中断，用户补充信息为：{user_input}",
                 "用户同意继续工具调用。"
@@ -144,7 +166,7 @@ class TaskAnalyzer:
         satisfaction_feedback = ""
 
         if not auto_completed and self.agent.use_analysis:
-            if self.agent.user_confirm("您对本次任务的完成是否满意？", True):
+            if self.agent.confirm_callback("您对本次任务的完成是否满意？", True):
                 satisfaction_feedback = "用户对本次任务的完成表示满意。"
             else:
                 feedback = self.agent._multiline_input(
@@ -158,6 +180,9 @@ class TaskAnalyzer:
                     satisfaction_feedback = (
                         "用户对本次任务的完成不满意，未提供具体反馈意见。"
                     )
+        elif auto_completed and self.agent.use_analysis:
+            # 自动完成模式下，仍然执行分析，但不收集用户反馈
+            satisfaction_feedback = "任务已自动完成，无需用户反馈。"
 
         return satisfaction_feedback
 

jarvis/jarvis_agent/task_manager.py

@@ -9,8 +9,6 @@ from rich.table import Table
 from rich.console import Console
 
 from jarvis.jarvis_agent import (
-    OutputType,
-    PrettyOutput,
     get_multiline_input,
     user_confirm,
 )
@@ -31,9 +29,7 @@ class TaskManager:
         data_dir = get_data_dir()
         pre_command_path = os.path.join(data_dir, "pre-command")
         if os.path.exists(pre_command_path):
-            PrettyOutput.print(
-                f"从{pre_command_path}加载预定义任务...", OutputType.INFO
-            )
+            print(f"ℹ️ 从{pre_command_path}加载预定义任务...")
             try:
                 with open(
                     pre_command_path, "r", encoding="utf-8", errors="ignore"
@@ -43,19 +39,15 @@ class TaskManager:
                     for name, desc in user_tasks.items():
                         if desc:
                             tasks[str(name)] = str(desc)
-                PrettyOutput.print(
-                    f"预定义任务加载完成 {pre_command_path}", OutputType.SUCCESS
-                )
+                print(f"✅ 预定义任务加载完成 {pre_command_path}")
             except (yaml.YAMLError, OSError):
-                PrettyOutput.print(
-                    f"预定义任务加载失败 {pre_command_path}", OutputType.ERROR
-                )
+                print(f"❌ 预定义任务加载失败 {pre_command_path}")
 
         # Check .jarvis/pre-command in current directory
         pre_command_path = ".jarvis/pre-command"
         if os.path.exists(pre_command_path):
             abs_path = os.path.abspath(pre_command_path)
-            PrettyOutput.print(f"从{abs_path}加载预定义任务...", OutputType.INFO)
+            print(f"ℹ️ 从{abs_path}加载预定义任务...")
             try:
                 with open(
                     pre_command_path, "r", encoding="utf-8", errors="ignore"
@@ -65,13 +57,9 @@ class TaskManager:
                     for name, desc in local_tasks.items():
                         if desc:
                             tasks[str(name)] = str(desc)
-                PrettyOutput.print(
-                    f"预定义任务加载完成 {pre_command_path}", OutputType.SUCCESS
-                )
+                print(f"✅ 预定义任务加载完成 {pre_command_path}")
             except (yaml.YAMLError, OSError):
-                PrettyOutput.print(
-                    f"预定义任务加载失败 {pre_command_path}", OutputType.ERROR
-                )
+                print(f"❌ 预定义任务加载失败 {pre_command_path}")
 
         return tasks
 
@@ -89,7 +77,7 @@ class TaskManager:
         for i, name in enumerate(task_names, 1):
             table.add_row(str(i), name)
         Console().print(table)
-        PrettyOutput.print("[0] 跳过预定义任务", OutputType.INFO)
+        print("ℹ️ [0] 跳过预定义任务")
 
         # Try fzf selection first (with numbered options and a skip option)
         fzf_list = [f"{0:>3} | 跳过预定义任务"] + [
@@ -104,7 +92,7 @@ class TaskManager:
                     return ""
                 if 1 <= idx <= len(task_names):
                     selected_task = tasks[task_names[idx - 1]]
-                    PrettyOutput.print(f"将要执行任务:\n {selected_task}", OutputType.INFO)
+                    print(f"ℹ️ 将要执行任务:\n {selected_task}")
                     # 询问是否需要补充信息
                     need_additional = user_confirm("需要为此任务添加补充信息吗？", default=False)
                     if need_additional:
@@ -129,9 +117,7 @@ class TaskManager:
                     return ""
                 if 1 <= choice <= len(task_names):
                     selected_task = tasks[task_names[choice - 1]]
-                    PrettyOutput.print(
-                        f"将要执行任务:\n {selected_task}", OutputType.INFO
-                    )
+                    print(f"ℹ️ 将要执行任务:\n {selected_task}")
                     # 询问是否需要补充信息
                     need_additional = user_confirm(
                         "需要为此任务添加补充信息吗？", default=False
@@ -144,11 +130,9 @@ class TaskManager:
                                 f"补充信息:\n{additional_input}"
                             ])
                     return selected_task
-                PrettyOutput.print(
-                    "无效的选择。请选择列表中的一个号码。", OutputType.WARNING
-                )
+                print("⚠️ 无效的选择。请选择列表中的一个号码。")
 
             except (KeyboardInterrupt, EOFError):
                 return ""
             except ValueError as val_err:
-                PrettyOutput.print(f"选择任务失败: {str(val_err)}", OutputType.ERROR)
+                print(f"❌ 选择任务失败: {str(val_err)}")

jarvis/jarvis_agent/tool_executor.py

@@ -2,7 +2,6 @@
 from typing import Any, Tuple, TYPE_CHECKING
 
 from jarvis.jarvis_utils.input import user_confirm
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 if TYPE_CHECKING:
     from jarvis.jarvis_agent import Agent
@@ -31,7 +30,7 @@ def execute_tool_call(response: str, agent: "Agent") -> Tuple[bool, Any]:
             f"操作失败：检测到多个操作。一次只能执行一个操作。"
             f"尝试执行的操作：{', '.join([handler.name() for handler in tool_list])}"
         )
-        PrettyOutput.print(error_message, OutputType.WARNING)
+        print(f"⚠️ {error_message}")
         return False, error_message
 
     if not tool_list:
@@ -47,7 +46,7 @@ def execute_tool_call(response: str, agent: "Agent") -> Tuple[bool, Any]:
             print(f"✅ {tool_to_execute.name()}执行完成")
             return result
         except Exception as e:
-            PrettyOutput.print(f"工具执行失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 工具执行失败: {str(e)}")
             return False, str(e)
 
     return False, ""

jarvis/jarvis_agent/tool_share_manager.py

@@ -7,7 +7,7 @@ from typing import List, Dict, Any, Set
 
 import typer
 
-from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_agent import user_confirm
 from jarvis.jarvis_agent.share_manager import ShareManager
 from jarvis.jarvis_utils.config import get_central_tool_repo, get_data_dir
 
@@ -18,13 +18,8 @@ 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
-            )
+            print("❌ 错误：未配置中心工具仓库（JARVIS_CENTRAL_TOOL_REPO）")
+            print("ℹ️ 请在配置文件中设置中心工具仓库的Git地址")
             raise typer.Exit(code=1)
 
         super().__init__(central_repo, "central_tool_repo")
@@ -52,10 +47,7 @@ class ToolShareManager(ShareManager):
         # 只从数据目录的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,
-            )
+            print(f"⚠️ 本地工具目录不存在: {local_tools_dir}")
             return []
 
         # 收集本地工具文件（排除已存在的）
@@ -84,7 +76,8 @@ class ToolShareManager(ShareManager):
         share_list = ["\n将要分享以下工具到中心仓库（注意：文件将被移动而非复制）："]
         for tool in resources:
             share_list.append(f"- {tool['tool_name']} ({tool['filename']})")
-        PrettyOutput.print("\n".join(share_list), OutputType.WARNING)
+        joined_list = '\n'.join(share_list)
+        print(f"⚠️ {joined_list}")
 
         if not user_confirm("确认移动这些工具到中心仓库吗？（原文件将被删除）"):
             return []
@@ -108,10 +101,7 @@ class ToolShareManager(ShareManager):
             # 获取本地资源
             local_resources = self.get_local_resources()
             if not local_resources:
-                PrettyOutput.print(
-                    "没有找到新的工具文件（所有工具可能已存在于中心仓库）",
-                    OutputType.WARNING,
-                )
+                print("⚠️ 没有找到新的工具文件（所有工具可能已存在于中心仓库）")
                 return
 
             # 选择要分享的资源
@@ -123,17 +113,15 @@ class ToolShareManager(ShareManager):
             moved_list = self.share_resources(selected_resources)
             if moved_list:
                 # 一次性显示所有移动结果
-                PrettyOutput.print("\n".join(moved_list), OutputType.SUCCESS)
+                joined_moved = '\n'.join(moved_list)
+                print(f"✅ {joined_moved}")
 
                 # 提交并推送
                 self.commit_and_push(len(selected_resources))
 
-                PrettyOutput.print("\n工具已成功分享到中心仓库！", OutputType.SUCCESS)
-                PrettyOutput.print(
-                    f"原文件已从 {os.path.join(get_data_dir(), 'tools')} 移动到中心仓库",
-                    OutputType.INFO,
-                )
+                print("✅ 工具已成功分享到中心仓库！")
+                print(f"ℹ️ 原文件已从 {os.path.join(get_data_dir(), 'tools')} 移动到中心仓库")
 
         except Exception as e:
-            PrettyOutput.print(f"分享工具时出错: {str(e)}", OutputType.ERROR)
+            print(f"❌ 分享工具时出错: {str(e)}")
             raise typer.Exit(code=1)

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)

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