jarvis-ai-assistant 0.3.20__py3-none-any.whl → 0.3.21__py3-none-any.whl

jarvis/jarvis_tools/cli/main.py

@@ -23,12 +23,20 @@ def list_tools(
 
     if as_json:
         if detailed:
-            PrettyOutput.print(json.dumps(tools, indent=2, ensure_ascii=False), OutputType.CODE, lang="json")
+            PrettyOutput.print(
+                json.dumps(tools, indent=2, ensure_ascii=False),
+                OutputType.CODE,
+                lang="json",
+            )
         else:
             simple_tools = [
                 {"name": t["name"], "description": t["description"]} for t in tools
             ]
-            PrettyOutput.print(json.dumps(simple_tools, indent=2, ensure_ascii=False), OutputType.CODE, lang="json")
+            PrettyOutput.print(
+                json.dumps(simple_tools, indent=2, ensure_ascii=False),
+                OutputType.CODE,
+                lang="json",
+            )
     else:
         PrettyOutput.section("可用工具列表", OutputType.SYSTEM)
         for tool in tools:
@@ -37,18 +45,27 @@ def list_tools(
             if detailed:
                 PrettyOutput.print("   参数:", OutputType.INFO)
                 import json as _json  # local import to ensure available
-                PrettyOutput.print(_json.dumps(tool["parameters"], ensure_ascii=False, indent=2), OutputType.CODE, lang="json")
+
+                PrettyOutput.print(
+                    _json.dumps(tool["parameters"], ensure_ascii=False, indent=2),
+                    OutputType.CODE,
+                    lang="json",
+                )
 
 
 @app.command("stat")
 def stat_tools(
     as_json: bool = typer.Option(False, "--json", help="以JSON格式输出"),
-    last_days: Optional[int] = typer.Option(None, "--days", help="显示最近N天的统计（默认显示所有历史数据）"),
-    format: str = typer.Option("table", "--format", help="显示格式: table, chart, summary")
+    last_days: Optional[int] = typer.Option(
+        None, "--days", help="显示最近N天的统计（默认显示所有历史数据）"
+    ),
+    format: str = typer.Option(
+        "table", "--format", help="显示格式: table, chart, summary"
+    ),
 ):
     """显示工具调用统计信息"""
     from jarvis.jarvis_stats.stats import StatsManager
-    
+
     if format == "table":
         registry = ToolRegistry()
         stats = registry._get_tool_stats()
@@ -64,13 +81,24 @@ def stat_tools(
         table_data.sort(key=lambda x: x[1], reverse=True)
 
         if as_json:
-            PrettyOutput.print(json.dumps(dict(table_data), indent=2), OutputType.CODE, lang="json")
+            PrettyOutput.print(
+                json.dumps(dict(table_data), indent=2), OutputType.CODE, lang="json"
+            )
         else:
             time_desc = f"最近{last_days}天" if last_days else "所有历史"
             PrettyOutput.section(f"工具调用统计 ({time_desc})", OutputType.SYSTEM)
             if table_data:
-                PrettyOutput.print(tabulate(table_data, headers=["工具名称", "调用次数"], tablefmt="grid"), OutputType.CODE, lang="text")
-                PrettyOutput.print(f"\n总计: {len(table_data)} 个工具被使用，共 {sum(x[1] for x in table_data)} 次调用", OutputType.INFO)
+                PrettyOutput.print(
+                    tabulate(
+                        table_data, headers=["工具名称", "调用次数"], tablefmt="grid"
+                    ),
+                    OutputType.CODE,
+                    lang="text",
+                )
+                PrettyOutput.print(
+                    f"\n总计: {len(table_data)} 个工具被使用，共 {sum(x[1] for x in table_data)} 次调用",
+                    OutputType.INFO,
+                )
             else:
                 PrettyOutput.print("暂无工具调用记录", OutputType.INFO)
     else:
@@ -79,51 +107,59 @@ def stat_tools(
         # 显示所有标记为 tool 组的指标
         metrics = StatsManager.list_metrics()
         tool_metrics = []
-        
+
         for metric in metrics:
             # 检查是否是工具组的指标
             if last_days:
                 stats_data = StatsManager.get_stats(
-                    metric_name=metric,
-                    last_days=last_days,
-                    tags={"group": "tool"}
+                    metric_name=metric, last_days=last_days, tags={"group": "tool"}
                 )
             else:
                 # 获取所有历史数据
                 from datetime import datetime
+
                 stats_data = StatsManager.get_stats(
                     metric_name=metric,
                     start_time=datetime(2000, 1, 1),
                     end_time=datetime.now(),
-                    tags={"group": "tool"}
+                    tags={"group": "tool"},
                 )
             if stats_data and stats_data.get("records"):
                 tool_metrics.append(metric)
-        
+
         if tool_metrics:
             for metric in tool_metrics:
                 if format == "chart":
                     if last_days:
-                        StatsManager.plot(metric, last_days=last_days, tags={"group": "tool"})
+                        StatsManager.plot(
+                            metric, last_days=last_days, tags={"group": "tool"}
+                        )
                     else:
                         from datetime import datetime
+
                         StatsManager.plot(
-                            metric, 
-                            start_time=datetime(2000, 1, 1), 
-                            end_time=datetime.now(), 
-                            tags={"group": "tool"}
+                            metric,
+                            start_time=datetime(2000, 1, 1),
+                            end_time=datetime.now(),
+                            tags={"group": "tool"},
                         )
                 elif format == "summary":
                     if last_days:
-                        StatsManager.show(metric, last_days=last_days, format="summary", tags={"group": "tool"})
+                        StatsManager.show(
+                            metric,
+                            last_days=last_days,
+                            format="summary",
+                            tags={"group": "tool"},
+                        )
                     else:
                         from datetime import datetime
+
                         StatsManager.show(
-                            metric, 
-                            start_time=datetime(2000, 1, 1), 
-                            end_time=datetime.now(), 
-                            format="summary", 
-                            tags={"group": "tool"}
+                            metric,
+                            start_time=datetime(2000, 1, 1),
+                            end_time=datetime.now(),
+                            format="summary",
+                            tags={"group": "tool"},
                         )
         else:
             PrettyOutput.print("暂无工具调用记录", OutputType.INFO)
@@ -159,9 +195,7 @@ def call_tool(
             with open(args_file, "r", encoding="utf-8") as f:
                 tool_args = json.load(f)
         except (json.JSONDecodeError, FileNotFoundError) as e:
-            PrettyOutput.print(
-                f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR
-            )
+            PrettyOutput.print(f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR)
             raise typer.Exit(code=1)
 
     required_params = tool_obj.parameters.get("required", [])

jarvis/jarvis_tools/edit_file.py

@@ -148,12 +148,13 @@ class FileSearchReplaceTool:
                             content = f.read()
                             original_content = content
 
-
                     success, temp_content = EditFileHandler._fast_edit(
                         file_path, changes
                     )
                     if not success:
-                        PrettyOutput.print(f"文件 {file_path} 处理失败", OutputType.ERROR)
+                        PrettyOutput.print(
+                            f"文件 {file_path} 处理失败", OutputType.ERROR
+                        )
                         file_results.append(
                             {
                                 "file": file_path,
@@ -164,8 +165,6 @@ class FileSearchReplaceTool:
                         )
                         continue
 
-
-
                     # 只有当所有替换操作都成功时，才写回文件
                     if success and (
                         temp_content != original_content or not file_exists

jarvis/jarvis_tools/file_analyzer.py

@@ -105,7 +105,6 @@ class FileAnalyzerTool:
 
             analysis_result = platform.chat_until_success(analysis_request)
 
-
             # 清理会话
             platform.delete_chat()
 

jarvis/jarvis_tools/generate_new_tool.py

@@ -80,7 +80,9 @@ class generate_new_tool:
             # 验证工具代码中的名称是否与tool_name一致
             import re
 
-            match = re.search(r"^\s*name\s*=\s*[\"'](.+?)[\"']", tool_code, re.MULTILINE)
+            match = re.search(
+                r"^\s*name\s*=\s*[\"'](.+?)[\"']", tool_code, re.MULTILINE
+            )
             if not match:
                 return {
                     "success": False,
@@ -146,8 +148,6 @@ class generate_new_tool:
                     )
                     success_message += f"\n注册到当前会话失败，可能需要重新启动Jarvis"
 
-
-
             # 检查并安装缺失的依赖
             try:
                 required_packages = set()

jarvis/jarvis_tools/read_code.py

@@ -115,7 +115,6 @@ class ReadCodeTool:
                 f"{numbered_content}\n\n"
             )
 
-
             if agent:
                 files = agent.get_user_data("files")
                 if files:

jarvis/jarvis_tools/read_webpage.py

@@ -81,15 +81,25 @@ class WebpageTool:
                 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}"}
+                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": "无法从网页抓取有效内容。"}
-
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "无法从网页抓取有效内容。",
+                }
 
             summary_prompt = f"""以下是网页 {url} 的内容（已转换为Markdown）：
 ----------------

jarvis/jarvis_tools/registry.py

@@ -288,7 +288,6 @@ class ToolRegistry(OutputHandlerProtocol):
                 if tool_name in self.tools:
                     del self.tools[tool_name]
 
-
     def _load_mcp_tools(self) -> None:
         """加载MCP工具，优先从配置获取，其次从目录扫描"""
         from jarvis.jarvis_utils.config import get_mcp_config
@@ -351,7 +350,6 @@ class ToolRegistry(OutputHandlerProtocol):
                 try:
                     import subprocess
 
-
                     subprocess.run(
                         ["git", "clone", central_repo, central_repo_path], check=True
                     )
@@ -649,7 +647,6 @@ class ToolRegistry(OutputHandlerProtocol):
 
                         # Ask user for confirmation
 
-
                         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

@@ -166,7 +166,6 @@ class RetrieveMemoryTool:
 
             # 打印结果摘要
 
-
             if tags:
                 pass
 

jarvis/jarvis_tools/save_memory.py

@@ -174,7 +174,6 @@ class SaveMemoryTool:
 
             # 生成总结报告
 
-
             # 构建返回结果
             output = {
                 "total": len(memories),

jarvis/jarvis_tools/search_web.py

@@ -81,8 +81,6 @@ class SearchWebTool:
 
             url_list_str = "\n".join(f"  - {u}" for u in visited_urls)
 
-
-
             summary_prompt = f"请为查询“{query}”总结以下内容：\n\n{full_content}"
 
             if not agent.model:

jarvis/jarvis_tools/sub_agent.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+"""
+sub_agent 工具
+将子任务交给通用 Agent 执行，并返回执行结果。
+
+约定：
+- 仅接收一个参数：task
+- 不依赖父 Agent，所有配置使用系统默认与全局变量
+- 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
+"""
+from typing import Any, Dict, Optional
+import json
+
+from jarvis.jarvis_agent import Agent, origin_agent_system_prompt
+from jarvis.jarvis_utils.globals import delete_agent
+
+
+class SubAgentTool:
+    """
+    临时创建一个通用 Agent 执行子任务，执行完立即清理。
+    - 不注册至全局
+    - 使用系统默认/全局配置
+    - 启用自动完成与总结
+    """
+
+    # 必须与文件名一致，供 ToolRegistry 自动注册
+    name = "sub_agent"
+    description = "将子任务交给通用 Agent 执行，并返回执行结果（使用系统默认配置，自动完成并生成总结）。"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "task": {
+                "type": "string",
+                "description": "要执行的子任务内容（必填）",
+            },
+            "background": {
+                "type": "string",
+                "description": "任务背景与已知信息（可选，将与任务一并提供给子Agent）",
+            },
+        },
+        "required": ["task"],
+    }
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        执行子任务并返回结果。
+        返回:
+          - success: 是否成功
+          - stdout: 子 Agent 返回的结果（字符串或JSON字符串）
+          - stderr: 错误信息（如有）
+        """
+        try:
+            task: str = str(args.get("task", "")).strip()
+            if not task:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "task 不能为空",
+                }
+
+            # 读取背景信息并组合任务
+            background: str = str(args.get("background", "")).strip()
+            enhanced_task = (
+                f"背景信息:\n{background}\n\n任务:\n{task}" if background else task
+            )
+
+            # 读取背景信息并组合任务
+            background: str = str(args.get("background", "")).strip()
+            enhanced_task = (
+                f"背景信息:\n{background}\n\n任务:\n{task}" if background else task
+            )
+
+            # 继承父Agent的运行参数（用于覆盖默认值）；若无父Agent则使用默认/全局配置
+            parent_agent = args.get("agent")
+            # 如未注入父Agent，尝试从全局获取当前或任一已注册Agent
+            if parent_agent is None:
+                try:
+                    from jarvis.jarvis_utils import globals as G  # 延迟导入避免循环
+
+                    curr = getattr(G, "current_agent_name", "")
+                    if curr:
+                        parent_agent = getattr(G, "global_agents", {}).get(curr)
+                    if parent_agent is None and getattr(G, "global_agents", {}):
+                        try:
+                            parent_agent = next(iter(G.global_agents.values()))
+                        except Exception:
+                            parent_agent = None
+                except Exception:
+                    parent_agent = None
+            # 默认/全局
+            system_prompt = origin_agent_system_prompt
+            need_summary = True
+            auto_complete = True
+
+            # 可继承参数
+            model_group = None
+            summary_prompt = None
+            execute_tool_confirm = None
+            use_methodology = None
+            use_analysis = None
+            force_save_memory = None
+            use_tools: list[str] = []
+
+            try:
+                if parent_agent is not None:
+                    # 继承模型组
+                    if getattr(parent_agent, "model", None):
+                        model_group = getattr(parent_agent.model, "model_group", None)
+                    # 继承开关类参数
+                    summary_prompt = getattr(parent_agent, "summary_prompt", None)
+                    execute_tool_confirm = getattr(
+                        parent_agent, "execute_tool_confirm", None
+                    )
+                    use_methodology = getattr(parent_agent, "use_methodology", None)
+                    use_analysis = getattr(parent_agent, "use_analysis", None)
+                    force_save_memory = getattr(parent_agent, "force_save_memory", None)
+                    # 继承工具使用集（名称列表）
+                    parent_registry = parent_agent.get_tool_registry()
+                    if parent_registry:
+                        for t in parent_registry.get_all_tools():
+                            if isinstance(t, dict) and t.get("name"):
+                                use_tools.append(str(t["name"]))
+            except Exception:
+                # 忽略继承失败，退回默认配置
+                pass
+
+            # 为避免交互阻塞：提供自动确认与空输入处理器
+            def _auto_confirm(tip: str, default: bool = True) -> bool:
+                return default
+
+            # 创建子Agent（其余配置使用默认/全局）
+            agent = Agent(
+                system_prompt=system_prompt,
+                name="SubAgent",
+                description="Temporary sub agent for executing a subtask",
+                llm_type="normal",  # 使用默认模型类型
+                model_group=model_group,  # 继承父Agent模型组（如可用）
+                summary_prompt=summary_prompt,  # 继承父Agent总结提示词（如可用）
+                auto_complete=auto_complete,
+                output_handler=None,  # 默认 ToolRegistry
+                use_tools=None,  # 初始不限定，稍后同步父Agent工具集
+                input_handler=None,  # 允许使用系统默认输入链
+                execute_tool_confirm=execute_tool_confirm,  # 继承父Agent（如可用）
+                need_summary=need_summary,
+                multiline_inputer=None,  # 使用系统默认输入器（允许用户输入）
+                use_methodology=use_methodology,  # 继承父Agent（如可用）
+                use_analysis=use_analysis,  # 继承父Agent（如可用）
+                force_save_memory=force_save_memory,  # 继承父Agent（如可用）
+                files=None,
+                confirm_callback=_auto_confirm,  # 自动确认
+            )
+
+            # 同步父Agent的模型名称与工具使用集（若可用）
+            try:
+                if (
+                    parent_agent is not None
+                    and getattr(parent_agent, "model", None)
+                    and getattr(agent, "model", None)
+                ):
+                    try:
+                        model_name = parent_agent.model.name()  # type: ignore[attr-defined]
+                        if model_name:
+                            agent.model.set_model_name(model_name)  # type: ignore[attr-defined]
+                    except Exception:
+                        pass
+                if use_tools:
+                    agent.set_use_tools(use_tools)
+            except Exception:
+                pass
+
+            # 执行任务
+            result = agent.run(enhanced_task)
+
+            # 主动清理，避免污染父 Agent 的全局状态
+            try:
+                delete_agent(agent.name)
+            except Exception:
+                pass
+
+            # 规范化输出
+            if isinstance(result, (dict, list)):
+                stdout = json.dumps(result, ensure_ascii=False, indent=2)
+            else:
+                stdout = str(result) if result is not None else "任务执行完成"
+
+            return {
+                "success": True,
+                "stdout": stdout,
+                "stderr": "",
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"执行子任务失败: {str(e)}",
+            }