jarvis-ai-assistant 0.3.17__py3-none-any.whl → 0.3.19__py3-none-any.whl

jarvis/jarvis_tools/read_webpage.py

@@ -3,6 +3,13 @@ from typing import Any, Dict
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.config import (
+    get_web_search_platform_name,
+    get_web_search_model_name,
+)
+from jarvis.jarvis_utils.http import get as http_get
+from markdownify import markdownify as md  # type: ignore
+import requests
 
 
 class WebpageTool:
@@ -22,28 +29,82 @@ class WebpageTool:
     }
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """Read webpage content using Yuanbao model"""
+        """
+        读取网页内容。
+        优先使用配置的 web_search_platform 与模型的原生web能力；若不支持，则使用requests抓取页面并调用模型进行分析。
+        """
         try:
-            url = args["url"].strip()
-            want = args.get("want", "请总结这个网页的主要内容")
+            url = str(args.get("url", "")).strip()
+            want = str(args.get("want", "请总结这个网页的主要内容"))
 
-            # Create Yuanbao model instance
+            if not url:
+                return {"success": False, "stdout": "", "stderr": "缺少必需参数：url"}
+
+            # 1) 优先使用配置的 Web 搜索平台与模型（若支持web）
+            web_search_platform = get_web_search_platform_name()
+            web_search_model = get_web_search_model_name()
+            if web_search_platform and web_search_model:
+                model = PlatformRegistry().create_platform(web_search_platform)
+                if model:
+                    model.set_model_name(web_search_model)
+                    if model.support_web():
+
+                        model.set_web(True)
+                        model.set_suppress_output(False)  # type: ignore
+                        prompt = f"""请帮我处理这个网页：{url}
+用户的具体需求是：{want}
+请按照以下要求输出结果：
+1. 使用Markdown格式
+2. 包含网页标题
+3. 根据用户需求提供准确、完整的信息"""
+                        response = model.chat_until_success(prompt)  # type: ignore
+                        return {"success": True, "stdout": response, "stderr": ""}
+
+            # 2) 然后尝试使用默认平台（normal）的 web 能力
             model = PlatformRegistry().get_normal_platform()
-            model.set_web(True)
-            model.set_suppress_output(False)  # type: ignore
+            if model.support_web():
 
-            # Construct prompt based on want parameter
-            prompt = f"""请帮我处理这个网页：{url}
+                model.set_web(True)
+                model.set_suppress_output(False)  # type: ignore
+                prompt = f"""请帮我处理这个网页：{url}
 用户的具体需求是：{want}
 请按照以下要求输出结果：
 1. 使用Markdown格式
 2. 包含网页标题
 3. 根据用户需求提供准确、完整的信息"""
+                response = model.chat_until_success(prompt)  # type: ignore
+                return {"success": True, "stdout": response, "stderr": ""}
+
+            # 3) 回退：使用 requests 抓取网页，再用模型分析
+
+            try:
+                resp = http_get(url, timeout=10.0, allow_redirects=True)
+                content_md = md(resp.text, strip=["script", "style"])
+            except requests.exceptions.HTTPError as e:
+                PrettyOutput.print(f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}", OutputType.WARNING)
+                return {"success": False, "stdout": "", "stderr": f"HTTP错误：{e.response.status_code}"}
+            except requests.exceptions.RequestException as e:
+                PrettyOutput.print(f"⚠️ 请求错误: {e}", OutputType.WARNING)
+                return {"success": False, "stdout": "", "stderr": f"请求错误：{e}"}
+
+            if not content_md or not content_md.strip():
+                return {"success": False, "stdout": "", "stderr": "无法从网页抓取有效内容。"}
 
-            # Get response from Yuanbao model
-            response = model.chat_until_success(prompt)  # type: ignore
 
-            return {"success": True, "stdout": response, "stderr": ""}
+            summary_prompt = f"""以下是网页 {url} 的内容（已转换为Markdown）：
+----------------
+{content_md}
+----------------
+请根据用户的具体需求“{want}”进行总结与回答：
+- 使用Markdown格式
+- 包含网页标题（若可推断）
+- 提供准确、完整的信息"""
+
+            model = PlatformRegistry().get_normal_platform()
+            model.set_suppress_output(False)  # type: ignore
+            summary = model.chat_until_success(summary_prompt)  # type: ignore
+
+            return {"success": True, "stdout": summary, "stderr": ""}
 
         except Exception as e:
             PrettyOutput.print(f"读取网页失败: {str(e)}", OutputType.ERROR)
@@ -55,5 +116,5 @@ class WebpageTool:
 
     @staticmethod
     def check() -> bool:
-        """检查当前平台是否支持web功能"""
-        return PlatformRegistry().get_normal_platform().support_web()
+        """工具可用性检查：始终可用；若模型不支持web将回退到requests抓取。"""
+        return True

jarvis/jarvis_tools/registry.py

@@ -287,10 +287,7 @@ class ToolRegistry(OutputHandlerProtocol):
             for tool_name in dont_use_list:
                 if tool_name in self.tools:
                     del self.tools[tool_name]
-                    PrettyOutput.print(
-                        f"已排除工具: {tool_name}",
-                        OutputType.INFO,
-                    )
+
 
     def _load_mcp_tools(self) -> None:
         """加载MCP工具，优先从配置获取，其次从目录扫描"""
@@ -354,9 +351,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 try:
                     import subprocess
 
-                    PrettyOutput.print(
-                        f"正在克隆中心工具仓库: {central_repo}", OutputType.INFO
-                    )
+
                     subprocess.run(
                         ["git", "clone", central_repo, central_repo_path], check=True
                     )
@@ -399,10 +394,7 @@ class ToolRegistry(OutputHandlerProtocol):
 
             # 检查enable标志
             if not config.get("enable", True):
-                PrettyOutput.print(
-                    f"MCP配置{config.get('name', '')}已禁用(enable=false)，跳过注册",
-                    OutputType.INFO,
-                )
+
                 return False
 
             name = config.get("name", "mcp")
@@ -414,10 +406,7 @@ class ToolRegistry(OutputHandlerProtocol):
                     args.pop("agent", None)
                     args.pop("want", None)
                     ret = client.get_resource_list()
-                    PrettyOutput.print(
-                        f"MCP {name} 资源列表:\n{yaml.safe_dump(ret, allow_unicode=True)}",
-                        OutputType.TOOL,
-                    )
+
                     return {
                         "success": True,
                         "stdout": yaml.safe_dump(ret, allow_unicode=True),
@@ -438,10 +427,7 @@ class ToolRegistry(OutputHandlerProtocol):
                             "stderr": "缺少必需的uri参数",
                         }
                     ret = client.get_resource(args["uri"])
-                    PrettyOutput.print(
-                        f"MCP {name} 获取资源:\n{yaml.safe_dump(ret, allow_unicode=True)}",
-                        OutputType.TOOL,
-                    )
+
                     return ret
 
                 return execute
@@ -452,10 +438,7 @@ class ToolRegistry(OutputHandlerProtocol):
                     args.pop("agent", None)
                     args.pop("want", None)
                     ret = client.execute(tool_name, args)
-                    PrettyOutput.print(
-                        f"MCP {name} {tool_name} 执行结果:\n{yaml.safe_dump(ret, allow_unicode=True)}",
-                        OutputType.TOOL,
-                    )
+
                     return ret
 
                 return execute
@@ -665,11 +648,8 @@ class ToolRegistry(OutputHandlerProtocol):
                         yaml.safe_load(temp_data[0])  # Check if valid YAML
 
                         # Ask user for confirmation
-                        PrettyOutput.print(
-                            f"检测到缺失的 {ct('TOOL_CALL')} 标签，已自动修复。修复后的内容如下:",
-                            OutputType.INFO,
-                        )
-                        PrettyOutput.print(fixed_content, OutputType.TOOL)
+
+
                         data = temp_data
                     except (yaml.YAMLError, EOFError, KeyboardInterrupt):
                         # Even after fixing, it's not valid YAML, or user cancelled.

jarvis/jarvis_tools/retrieve_memory.py

@@ -147,17 +147,12 @@ class RetrieveMemoryTool:
 
                 # 检查是否超过token限制
                 if total_tokens + memory_tokens > memory_token_limit:
-                    PrettyOutput.print(
-                        f"达到token限制 ({total_tokens}/{memory_token_limit})，停止加载更多记忆",
-                        OutputType.INFO,
-                    )
+
                     break
 
                 # 检查是否超过50条限制
                 if len(filtered_memories) >= 50:
-                    PrettyOutput.print(
-                        f"达到记忆条数限制 (50条)，停止加载更多记忆", OutputType.INFO
-                    )
+
                     break
 
                 filtered_memories.append(memory)
@@ -170,10 +165,10 @@ class RetrieveMemoryTool:
                 all_memories = all_memories[:limit]
 
             # 打印结果摘要
-            PrettyOutput.print(f"检索到 {len(all_memories)} 条记忆", OutputType.INFO)
+
 
             if tags:
-                PrettyOutput.print(f"使用标签过滤: {', '.join(tags)}", OutputType.INFO)
+                pass
 
             # 格式化为Markdown输出
             markdown_output = f"# 记忆检索结果\n\n"
@@ -216,17 +211,11 @@ class RetrieveMemoryTool:
 
             # 如果记忆较多，在终端显示摘要
             if len(all_memories) > 5:
-                PrettyOutput.print(f"记忆较多，仅显示前5条摘要：", OutputType.INFO)
+                # 静默模式下不再打印摘要，完整结果已包含在返回的markdown_output中
                 for i, memory in enumerate(all_memories[:5]):
                     content_preview = memory.get("content", "")[:100]
                     if len(memory.get("content", "")) > 100:
                         content_preview += "..."
-                    PrettyOutput.print(
-                        f"{i+1}. [{memory.get('type')}] {memory.get('id')}\n"
-                        f"   标签: {', '.join(memory.get('tags', []))}\n"
-                        f"   内容: {content_preview}",
-                        OutputType.INFO,
-                    )
 
             return {
                 "success": True,

jarvis/jarvis_tools/rewrite_file.py

@@ -114,7 +114,6 @@ class FileRewriteTool:
                 action = "创建并写入" if not file_exists else "成功重写"
                 stdout_message = f"文件 {abs_path} {action}"
                 stdout_messages.append(stdout_message)
-                PrettyOutput.print(stdout_message, OutputType.SUCCESS)
 
             except Exception as e:
                 stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
@@ -126,7 +125,6 @@ class FileRewriteTool:
             if not success and processed:
                 rollback_message = "操作失败，正在回滚修改..."
                 stderr_messages.append(rollback_message)
-                PrettyOutput.print(rollback_message, OutputType.WARNING)
 
                 try:
                     if original_content is None:
@@ -141,7 +139,6 @@ class FileRewriteTool:
                         rollback_file_message = f"已回滚文件: {abs_path}"
 
                     stderr_messages.append(rollback_file_message)
-                    PrettyOutput.print(rollback_file_message, OutputType.INFO)
                 except Exception as e:
                     rollback_error = f"回滚文件 {file_path} 失败: {str(e)}"
                     stderr_messages.append(rollback_error)
@@ -172,7 +169,6 @@ class FileRewriteTool:
             if processed:
                 rollback_message = "操作失败，正在回滚修改..."
                 stderr_messages.append(rollback_message)
-                PrettyOutput.print(rollback_message, OutputType.WARNING)
 
                 try:
                     if original_content is None:

jarvis/jarvis_tools/save_memory.py

@@ -159,12 +159,7 @@ class SaveMemoryTool:
                     # 打印单条记忆保存信息
                     memory_type = memory_data["memory_type"]
                     tags = memory_data.get("tags", [])
-                    PrettyOutput.print(
-                        f"[{i+1}/{len(memories)}] {memory_type} 记忆已保存\n"
-                        f"ID: {result['memory_id']}\n"
-                        f"标签: {', '.join(tags)}",
-                        OutputType.SUCCESS,
-                    )
+
                 except Exception as e:
                     failed_count += 1
                     error_msg = f"保存第 {i+1} 条记忆失败: {str(e)}"
@@ -178,10 +173,7 @@ class SaveMemoryTool:
                     )
 
             # 生成总结报告
-            PrettyOutput.print(
-                f"\n批量保存完成：成功 {success_count} 条，失败 {failed_count} 条",
-                OutputType.INFO,
-            )
+
 
             # 构建返回结果
             output = {

jarvis/jarvis_tools/search_web.py

@@ -34,7 +34,7 @@ class SearchWebTool:
         # pylint: disable=too-many-locals, broad-except
         """执行网络搜索、抓取内容并总结结果。"""
         try:
-            PrettyOutput.print("▶️ 使用 DuckDuckGo 开始网页搜索...", OutputType.INFO)
+
             results = list(DDGS().text(query, max_results=50, page=3))
 
             if not results:
@@ -50,17 +50,14 @@ class SearchWebTool:
 
             for r in results:
                 if visited_count >= 10:
-                    PrettyOutput.print("ℹ️ 已成功获取10个网页，停止抓取。", OutputType.INFO)
+
                     break
 
                 url = r["href"]
                 title = r.get("title", url)
 
                 try:
-                    PrettyOutput.print(
-                        f"📄 ({visited_count + 1}/10) 正在抓取: {title} ({url})",
-                        OutputType.INFO,
-                    )
+
                     response = http_get(url, timeout=10.0, allow_redirects=True)
                     content = md(response.text, strip=["script", "style"])
                     if content:
@@ -83,9 +80,9 @@ class SearchWebTool:
                 }
 
             url_list_str = "\n".join(f"  - {u}" for u in visited_urls)
-            PrettyOutput.print(f"🔍 已成功访问并处理以下URL:\n{url_list_str}", OutputType.INFO)
 
-            PrettyOutput.print("🧠 正在总结内容...", OutputType.INFO)
+
+
             summary_prompt = f"请为查询“{query}”总结以下内容：\n\n{full_content}"
 
             if not agent.model:

jarvis/jarvis_tools/virtual_tty.py

@@ -3,6 +3,7 @@ import os
 import sys
 import time
 from typing import Any, Dict, TYPE_CHECKING
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 # 为了类型检查，总是导入这些模块
 if TYPE_CHECKING:
@@ -126,62 +127,50 @@ class VirtualTTYTool:
         try:
             if action == "launch":
                 if args.get("keys", "") != "":
-                    print(f"🚫 启动虚拟终端时，不能同时指定keys参数")
+                    PrettyOutput.print("启动虚拟终端时，不能同时指定 keys 参数", OutputType.ERROR)
                     return {
                         "success": False,
                         "stdout": "",
                         "stderr": "启动虚拟终端时，不能同时指定keys参数",
                     }
-                print(f"🚀 正在启动虚拟终端 [{tty_id}]...")
+
                 result = self._launch_tty(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 启动虚拟终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"启动虚拟终端 [{tty_id}] 失败", OutputType.ERROR)
                 return result
             elif action == "send_keys":
                 keys = args.get("keys", "").strip()
                 add_enter = args.get("add_enter", True)
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
-                print(f"⌨️ 正在向终端 [{tty_id}] 发送按键序列: {keys}...")
+
                 result = self._input_command(agent, tty_id, keys, timeout, add_enter)
-                if result["success"]:
-                    print(f"✅ 发送按键序列到终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 发送按键序列到终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"发送按键序列到终端 [{tty_id}] 失败", OutputType.ERROR)
                 return result
             elif action == "output":
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
-                print(f"📥 正在获取终端 [{tty_id}] 输出...")
+
                 result = self._get_output(agent, tty_id, timeout)
-                if result["success"]:
-                    print(f"✅ 获取终端 [{tty_id}] 输出成功")
-                else:
-                    print(f"❌ 获取终端 [{tty_id}] 输出失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"获取终端 [{tty_id}] 输出失败", OutputType.ERROR)
                 return result
             elif action == "close":
-                print(f"🔒 正在关闭虚拟终端 [{tty_id}]...")
+
                 result = self._close_tty(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 关闭虚拟终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"关闭虚拟终端 [{tty_id}] 失败", OutputType.ERROR)
                 return result
             elif action == "get_screen":
-                print(f"🖥️ 正在获取终端 [{tty_id}] 屏幕内容...")
+
                 result = self._get_screen(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 获取终端 [{tty_id}] 屏幕内容成功")
-                else:
-                    print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"获取终端 [{tty_id}] 屏幕内容失败", OutputType.ERROR)
                 return result
             elif action == "list":
-                print("📋 正在获取所有虚拟终端列表...")
+
                 result = self._list_ttys(agent)
-                if result["success"]:
-                    print("✅ 获取虚拟终端列表成功")
-                else:
-                    print("❌ 获取虚拟终端列表失败")
+                if not result["success"]:
+                    PrettyOutput.print("获取虚拟终端列表失败", OutputType.ERROR)
                 return result
             return {"success": False, "stdout": "", "stderr": "不支持的操作"}
 
@@ -241,8 +230,7 @@ class VirtualTTYTool:
                     except BlockingIOError:
                         continue
 
-                if output:
-                    print(f"📤 终端 [{tty_id}]: {output}")
+
 
                 return {"success": True, "stdout": output, "stderr": ""}
 
@@ -309,8 +297,7 @@ class VirtualTTYTool:
                 except _queue.Empty:
                     continue
 
-            if output:
-                print(f"📤 终端 [{tty_id}]: {output}")
+
 
             return {"success": True, "stdout": output, "stderr": ""}
 
@@ -388,7 +375,6 @@ class VirtualTTYTool:
                             output += data.decode()
                 except BlockingIOError:
                     continue
-            print(f"📤 终端 [{tty_id}]: {output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -437,7 +423,6 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
-            print(f"📤 终端 [{tty_id}]: {output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -490,8 +475,6 @@ class VirtualTTYTool:
                                 break
                         except BlockingIOError:
                             break
-            print(f"📤 终端 [{tty_id}]: {output}")
-
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -523,7 +506,6 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
-            print(f"📤 终端 [{tty_id}]: {output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:

jarvis/jarvis_utils/clipboard.py

@@ -11,9 +11,9 @@ def copy_to_clipboard(text: str) -> None:
     参数:
         text: 要复制的文本
     """
-    print("--- 剪贴板内容开始 ---")
-    print(text)
-    print("--- 剪贴板内容结束 ---")
+    PrettyOutput.print("--- 剪贴板内容开始 ---", OutputType.INFO)
+    PrettyOutput.print(text, OutputType.CODE, lang="text")
+    PrettyOutput.print("--- 剪贴板内容结束 ---", OutputType.INFO)
 
     system = platform.system()
 

jarvis/jarvis_utils/config.py

@@ -624,3 +624,11 @@ def is_enable_builtin_config_selector() -> bool:
     return (
         GLOBAL_CONFIG_DATA.get("JARVIS_ENABLE_STARTUP_CONFIG_SELECTOR", False) is True
     )
+
+
+def is_immediate_abort() -> bool:
+    """
+    是否启用立即中断：当在对话过程中检测到用户中断信号时，立即停止输出并返回。
+    默认关闭
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_IMMEDIATE_ABORT", False) is True