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

jarvis/jarvis_tools/retrieve_memory.py

@@ -4,7 +4,6 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from jarvis.jarvis_utils.config import get_data_dir, get_max_input_token_count
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.globals import get_short_term_memories
 from jarvis.jarvis_utils.embedding import get_context_token_count
 
@@ -13,17 +12,7 @@ class RetrieveMemoryTool:
     """检索记忆工具，用于从长短期记忆系统中检索信息"""
 
     name = "retrieve_memory"
-    description = """从长短期记忆系统中检索信息。
-    
-    支持的记忆类型：
-    - project_long_term: 项目长期记忆（与当前项目相关的信息）
-    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
-    - short_term: 短期记忆（当前任务相关的信息）
-    - all: 从所有类型中检索
-    
-    可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
-    注意：标签数量建议不要超过10个，以保证检索效率
-    """
+    description = "从长短期记忆系统中检索信息。支持按类型（project_long_term/global_long_term/short_term/all）和标签过滤，标签建议不超过10个。"
 
     parameters = {
         "type": "object",
@@ -99,9 +88,7 @@ class RetrieveMemoryTool:
 
                     memories.append(memory_data)
                 except Exception as e:
-                    PrettyOutput.print(
-                        f"读取记忆文件 {memory_file} 失败: {str(e)}", OutputType.WARNING
-                    )
+                    print(f"⚠️ 读取记忆文件 {memory_file} 失败: {str(e)}")
 
         return memories
 
@@ -131,9 +118,23 @@ class RetrieveMemoryTool:
             # 按创建时间排序（最新的在前）
             all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
 
-            # 获取最大输入token数的2/3作为记忆的token限制
-            max_input_tokens = get_max_input_token_count()
-            memory_token_limit = int(max_input_tokens * 2 / 3)
+            # 优先使用剩余token数量，回退到输入窗口限制
+            memory_token_limit = None
+            agent = args.get("agent")
+            if agent and hasattr(agent, "model"):
+                try:
+                    remaining_tokens = agent.model.get_remaining_token_count()
+                    # 使用剩余token的2/3作为限制，保留1/3作为安全余量
+                    memory_token_limit = int(remaining_tokens * 2 / 3)
+                    if memory_token_limit <= 0:
+                        memory_token_limit = None
+                except Exception:
+                    pass
+            
+            # 回退方案：使用输入窗口的2/3
+            if memory_token_limit is None:
+                max_input_tokens = get_max_input_token_count()
+                memory_token_limit = int(max_input_tokens * 2 / 3)
 
             # 基于token限制和条数限制筛选记忆
             filtered_memories: List[Dict[str, Any]] = []
@@ -223,5 +224,5 @@ class RetrieveMemoryTool:
 
         except Exception as e:
             error_msg = f"检索记忆失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
+            print(f"❌ {error_msg}")
             return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/rewrite_file.py

@@ -1,191 +1,105 @@
 # -*- coding: utf-8 -*-
-"""
-文件重写工具类
-
-功能概述:
-1. 提供完整的文件重写功能
-2. 支持创建新文件或完全重写现有文件
-3. 实现原子操作：所有修改要么全部成功，要么全部回滚
-4. 自动创建所需目录结构
-
-核心特性:
-- 支持不存在的文件和空文件处理
-- 自动创建所需目录结构
-- 完善的错误处理和回滚机制
-- 保持文件格式和编码
-"""
+import os
 from typing import Any, Dict
 
 
-class FileRewriteTool:
+
+class RewriteFileTool:
+    """文件重写工具，用于完全重写文件内容"""
+
     name = "rewrite_file"
-    description = """文件重写工具，用于完全重写或创建文件
-
-# 文件重写规范
-
-## 重要提示
-此工具用于完全重写文件内容或创建新文件。与edit_file不同，此工具会替换文件的全部内容。
-
-## 基本使用
-1. 指定需要重写的文件路径
-2. 提供新的文件内容
-3. 所有操作要么全部成功，要么全部失败并回滚
-
-## 核心原则
-1. **完整重写**：提供完整的文件内容，将替换原文件的所有内容
-2. **格式保持**：
-   - 保持原始代码的缩进方式（空格或制表符）
-   - 保持原始代码的空行数量和位置
-   - 保持原始代码的行尾空格处理方式
-   - 不改变原始代码的换行风格
-
-## 最佳实践
-1. 确保提供格式良好的完整文件内容
-2. 创建新文件时提供完整、格式良好的内容
-3. 不要出现未实现的代码，如：TODO
-"""
+    description = "完全重写文件内容，适用于新增文件或大范围改写。具备失败回滚能力。局部修改请使用 edit_file。\n\n    ⚠️ 重要提示：\n    - 不要一次重写太多内容，建议分多次进行，避免超过LLM的上下文窗口大小\n    - 如果文件内容较长（超过2048字符），建议采用以下策略：\n      1. 第一次调用 rewrite_file 写入部分内容（如文件的前半部分或关键部分）\n      2. 然后多次调用 edit_file 工具，使用 insert_after 操作补充后续内容\n    - 这样可以避免单次操作内容过长导致上下文溢出"
+
     parameters = {
         "type": "object",
         "properties": {
-            "file": {"type": "string", "description": "需要重写的文件路径"},
+            "file_path": {
+                "type": "string",
+                "description": "要重写的文件路径（支持绝对路径和相对路径）",
+            },
             "content": {
                 "type": "string",
-                "description": "新的文件内容，将完全替换原文件内容",
+                "description": "新的文件完整内容",
             },
         },
-        "required": ["file", "content"],
+        "required": ["file_path", "content"],
     }
 
     def __init__(self):
         """初始化文件重写工具"""
         pass
 
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """
-        执行文件重写操作，完全替换文件内容
-
-        参数:
-            file (str): 文件路径
-            content (str): 新的文件内容
-
-        返回:
-            dict: 包含执行结果的字典
-            {
-                "success": bool,  # 是否成功完成重写
-                "stdout": str,    # 标准输出信息
-                "stderr": str     # 错误信息
-            }
-        """
-        import os
-
-        from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-        stdout_messages = []
-        stderr_messages = []
-        success = True
-
-        file_path = args["file"]
-        new_content = args["content"]
-        agent = args.get("agent", None)
-        abs_path = os.path.abspath(file_path)
-
-        # 创建已处理文件变量，用于失败时回滚
-        original_content = None
-        processed = False
-
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行文件重写操作"""
         try:
-            file_exists = os.path.exists(file_path)
+            file_path = args.get("file_path")
+            content = args.get("content")
+
+            if not file_path:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "缺少必需参数：file_path",
+                }
+
+            if content is None:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "缺少必需参数：content",
+                }
+
+            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 f:
-                        original_content = f.read()
+                    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 f:
-                    f.write(new_content)
-
+                with open(abs_path, "w", encoding="utf-8") as wf:
+                    wf.write(content)
                 processed = True
 
-                action = "创建并写入" if not file_exists else "成功重写"
-                stdout_message = f"文件 {abs_path} {action}"
-                stdout_messages.append(stdout_message)
+                # 记录 REWRITE 操作调用统计
+                try:
+                    from jarvis.jarvis_stats.stats import StatsManager
 
-            except Exception as e:
-                stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
-                stderr_messages.append(stderr_message)
-                PrettyOutput.print(stderr_message, OutputType.WARNING)
-                success = False
+                    StatsManager.increment("rewrite_file", group="tool")
+                except Exception:
+                    pass
 
-            # 如果操作失败，回滚已修改的文件
-            if not success and processed:
-                rollback_message = "操作失败，正在回滚修改..."
-                stderr_messages.append(rollback_message)
+                return {
+                    "success": True,
+                    "stdout": f"文件 {abs_path} 重写成功",
+                    "stderr": "",
+                }
 
+            except Exception as e:
+                # 回滚已修改内容
                 try:
-                    if original_content is None:
-                        # 如果是新创建的文件，则删除
-                        if os.path.exists(abs_path):
-                            os.remove(abs_path)
-                        rollback_file_message = f"已删除新创建的文件: {abs_path}"
-                    else:
-                        # 如果是修改的文件，则恢复原内容
-                        with open(abs_path, "w", encoding="utf-8") as f:
-                            f.write(original_content)
-                        rollback_file_message = f"已回滚文件: {abs_path}"
-
-                    stderr_messages.append(rollback_file_message)
-                except Exception as e:
-                    rollback_error = f"回滚文件 {file_path} 失败: {str(e)}"
-                    stderr_messages.append(rollback_error)
-                    PrettyOutput.print(rollback_error, OutputType.WARNING)
-
-            # 记录成功处理的文件（使用绝对路径）
-            if success and agent:
-                abs_path = os.path.abspath(file_path)
-                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)
-
-            return {
-                "success": success,
-                "stdout": "\n".join(stdout_messages),
-                "stderr": "\n".join(stderr_messages),
-            }
+                    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
+                error_msg = f"文件重写失败: {str(e)}"
+                print(f"❌ {error_msg}")
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": error_msg,
+                }
 
         except Exception as e:
-            error_msg = f"文件重写操作失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.WARNING)
+            error_msg = f"文件重写失败: {str(e)}"
+            print(f"❌ {error_msg}")
+            return {"success": False, "stdout": "", "stderr": error_msg}
 
-            # 如果有已修改的文件，尝试回滚
-            if processed:
-                rollback_message = "操作失败，正在回滚修改..."
-                stderr_messages.append(rollback_message)
-
-                try:
-                    if original_content is None:
-                        # 如果是新创建的文件，则删除
-                        if os.path.exists(file_path):
-                            os.remove(file_path)
-                        stderr_messages.append(f"已删除新创建的文件: {file_path}")
-                    else:
-                        # 如果是修改的文件，则恢复原内容
-                        with open(file_path, "w", encoding="utf-8") as f:
-                            f.write(original_content)
-                        stderr_messages.append(f"已回滚文件: {file_path}")
-                except:
-                    stderr_messages.append(f"回滚文件失败: {file_path}")
-
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": error_msg + "\n" + "\n".join(stderr_messages),
-            }

jarvis/jarvis_tools/save_memory.py

@@ -6,7 +6,6 @@ from pathlib import Path
 from typing import Any, Dict
 
 from jarvis.jarvis_utils.config import get_data_dir
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.globals import add_short_term_memory
 
 
@@ -14,18 +13,7 @@ class SaveMemoryTool:
     """保存记忆工具，用于将信息保存到长短期记忆系统"""
 
     name = "save_memory"
-    description = """保存信息到长短期记忆系统。
-    
-    支持批量保存多条记忆，可以同时保存不同类型的记忆。
-    
-    支持的记忆类型：
-    - project_long_term: 项目长期记忆（与当前项目相关的信息）
-    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
-    - short_term: 短期记忆（当前任务相关的信息）
-    
-    项目长期记忆存储在当前目录的 .jarvis/memory 下
-    全局长期记忆和短期记忆存储在数据目录的 memory 子目录下
-    """
+    description = "保存信息到长短期记忆系统。支持批量保存，记忆类型：project_long_term（项目长期）、global_long_term（全局长期）、short_term（短期）。"
 
     parameters = {
         "type": "object",
@@ -163,7 +151,7 @@ class SaveMemoryTool:
                 except Exception as e:
                     failed_count += 1
                     error_msg = f"保存第 {i+1} 条记忆失败: {str(e)}"
-                    PrettyOutput.print(error_msg, OutputType.ERROR)
+                    print(f"❌ {error_msg}")
                     results.append(
                         {
                             "error": error_msg,
@@ -190,5 +178,5 @@ class SaveMemoryTool:
 
         except Exception as e:
             error_msg = f"保存记忆失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
+            print(f"❌ {error_msg}")
             return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/search_web.py

@@ -2,7 +2,7 @@
 """网络搜索工具。"""
 from typing import Any, Dict
 
-import requests
+import requests  # type: ignore[import-untyped]
 from markdownify import markdownify as md  # type: ignore
 
 # pylint: disable=import-error,missing-module-docstring
@@ -17,7 +17,6 @@ from jarvis.jarvis_utils.config import (
     get_web_search_model_name,
 )
 from jarvis.jarvis_utils.http import get as http_get
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SearchWebTool:
@@ -65,12 +64,9 @@ class SearchWebTool:
                         visited_urls.append(url)
                         visited_count += 1
                 except requests.exceptions.HTTPError as e:
-                    PrettyOutput.print(
-                        f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}",
-                        OutputType.WARNING,
-                    )
+                    print(f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}")
                 except requests.exceptions.RequestException as e:
-                    PrettyOutput.print(f"⚠️ 请求错误: {e}", OutputType.WARNING)
+                    print(f"⚠️ 请求错误: {e}")
 
             if not full_content.strip():
                 return {
@@ -108,7 +104,7 @@ class SearchWebTool:
             return {"stdout": summary, "stderr": "", "success": True}
 
         except Exception as e:
-            PrettyOutput.print(f"❌ 网页搜索过程中发生错误: {e}", OutputType.ERROR)
+            print(f"❌ 网页搜索过程中发生错误: {e}")
             return {
                 "stdout": "",
                 "stderr": f"网页搜索过程中发生错误: {e}",
@@ -147,11 +143,13 @@ class SearchWebTool:
                 if model.support_web():
                     model.set_web(True)
                     model.set_suppress_output(False)
-                    return {
-                        "stdout": model.chat_until_success(query),
-                        "stderr": "",
-                        "success": True,
-                    }
+                    response = model.chat_until_success(query)
+                    if response and response.strip():
+                        return {
+                            "stdout": response,
+                            "stderr": "",
+                            "success": True,
+                        }
 
         # 否则使用现有的模型选择流程
         if agent.model.support_web():
@@ -161,11 +159,13 @@ class SearchWebTool:
             model.set_model_name(agent.model.name())
             model.set_web(True)
             model.set_suppress_output(False)
-            return {
-                "stdout": model.chat_until_success(query),
-                "stderr": "",
-                "success": True,
-            }
+            response = model.chat_until_success(query)
+            if response and response.strip():
+                return {
+                    "stdout": response,
+                    "stderr": "",
+                    "success": True,
+                }
 
         return self._search_with_ddgs(query, agent)
 

jarvis/jarvis_tools/sub_agent.py

@@ -4,17 +4,17 @@ sub_agent 工具
 将子任务交给通用 Agent 执行，并返回执行结果。
 
 约定：
-- 必填参数：task, name, background, system_prompt, summary_prompt, use_tools
-- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供
+- 必填参数：task, name, system_prompt, summary_prompt
+- 可选参数：background
+- 工具集：默认使用系统工具集（无需传入 use_tools）
+- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer、non_interactive、use_methodology、use_analysis；其他参数需显式提供
 - 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
 """
-from typing import Any, Dict, List
+from typing import Any, Dict
 import json
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.globals import delete_agent
-from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SubAgentTool:
@@ -27,7 +27,7 @@ class SubAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_agent"
-    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供，自动完成并生成总结）。"
+    description = "将子任务交给通用 Agent 执行并返回结果（继承父Agent部分配置，自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -41,7 +41,7 @@ class SubAgentTool:
             },
             "background": {
                 "type": "string",
-                "description": "任务背景与已知信息（必填，将与任务一并提供给子Agent）",
+                "description": "任务背景与已知信息（可选，将与任务一并提供给子Agent）",
             },
             "system_prompt": {
                 "type": "string",
@@ -51,25 +51,16 @@ class SubAgentTool:
                 "type": "string",
                 "description": "覆盖子Agent的总结提示词（必填）",
             },
-            "use_tools": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "限制子Agent可用的工具名称列表（必填）。兼容以逗号分隔的字符串输入。可用的工具列表："
-                + "\n".join(
-                    [
-                        t["name"] + ": " + t["description"]
-                        for t in ToolRegistry().get_all_tools()
-                    ]
-                ),
+            "non_interactive": {
+                "type": "boolean",
+                "description": "是否启用无交互模式（可选，默认继承父Agent或系统默认）",
             },
         },
         "required": [
             "task",
             "name",
-            "background",
             "system_prompt",
             "summary_prompt",
-            "use_tools",
         ],
     }
 
@@ -105,16 +96,6 @@ class SubAgentTool:
             summary_prompt = str(args.get("summary_prompt", "")).strip()
             agent_name = str(args.get("name", "")).strip()
 
-            # 解析可用工具列表（支持数组或以逗号分隔的字符串）
-            _use_tools = args.get("use_tools", None)
-            use_tools: List[str] = []
-            if isinstance(_use_tools, list):
-                use_tools = [str(x).strip() for x in _use_tools if str(x).strip()]
-            elif isinstance(_use_tools, str):
-                use_tools = [s.strip() for s in _use_tools.split(",") if s.strip()]
-            else:
-                use_tools = []
-
             errors = []
             if not system_prompt:
                 errors.append("system_prompt 不能为空")
@@ -122,8 +103,6 @@ class SubAgentTool:
                 errors.append("summary_prompt 不能为空")
             if not agent_name:
                 errors.append("name 不能为空")
-            if not use_tools:
-                errors.append("use_tools 不能为空")
             if not background:
                 errors.append("background 不能为空")
 
@@ -137,20 +116,29 @@ class SubAgentTool:
             # 基于父Agent（如有）继承部分配置后创建子Agent
             parent_agent = args.get("agent", None)
             parent_model_group = None
-            parent_input_handler = None
             parent_execute_tool_confirm = None
             parent_multiline_inputer = None
+            parent_non_interactive = None
+            parent_use_methodology = None
+            parent_use_analysis = None
             try:
                 if parent_agent is not None:
                     if getattr(parent_agent, "model", None):
                         parent_model_group = getattr(parent_agent.model, "model_group", None)
-                    parent_input_handler = getattr(parent_agent, "input_handler", None)
                     parent_execute_tool_confirm = getattr(parent_agent, "execute_tool_confirm", None)
                     parent_multiline_inputer = getattr(parent_agent, "multiline_inputer", None)
+                    parent_non_interactive = getattr(parent_agent, "non_interactive", None)
+                    parent_use_methodology = getattr(parent_agent, "use_methodology", None)
+                    parent_use_analysis = getattr(parent_agent, "use_analysis", None)
             except Exception:
                 # 安全兜底：无法从父Agent获取配置则保持为None，使用系统默认
                 pass
 
+            # 可选参数：允许显式覆盖无交互模式
+            explicit_non_interactive = args.get("non_interactive", None)
+            if explicit_non_interactive is not None:
+                parent_non_interactive = bool(explicit_non_interactive)
+
             agent = Agent(
                 system_prompt=system_prompt,
                 name=agent_name,
@@ -158,22 +146,30 @@ class SubAgentTool:
                 model_group=parent_model_group,
                 summary_prompt=summary_prompt,
                 auto_complete=auto_complete,
-                output_handler=None,
                 use_tools=None,
-                input_handler=parent_input_handler,
                 execute_tool_confirm=parent_execute_tool_confirm,
                 need_summary=need_summary,
                 multiline_inputer=parent_multiline_inputer,
-                use_methodology=None,
-                use_analysis=None,
+                use_methodology=parent_use_methodology,
+                use_analysis=parent_use_analysis,
                 force_save_memory=None,
                 files=None,
+                non_interactive=parent_non_interactive,
             )
 
-            # 设置可用工具列表
+            # 禁用 sub_agent 和 sub_code_agent，避免无限递归
             try:
-                agent.set_use_tools(use_tools)
+                # 获取当前启用的工具列表
+                tool_registry = agent.get_tool_registry()
+                if tool_registry:
+                    current_tools = [t.get("name") for t in tool_registry.get_all_tools() if isinstance(t, dict) and t.get("name")]
+                    # 过滤掉禁止的工具
+                    forbidden_tools = {"sub_agent", "sub_code_agent"}
+                    filtered_tools = [t for t in current_tools if t not in forbidden_tools]
+                    if filtered_tools:
+                        agent.set_use_tools(filtered_tools)
             except Exception:
+                # 如果禁用工具失败，不影响主流程
                 pass
 
             # 校验子Agent所用模型是否有效，必要时回退到平台可用模型
@@ -185,10 +181,7 @@ class SubAgentTool:
                         available_names = [m for m, _ in available_models]
                         current_model_name = platform.name()
                         if current_model_name not in available_names:
-                            PrettyOutput.print(
-                                f"检测到子Agent模型 {current_model_name} 不存在于平台 {platform.platform_name()} 的可用模型列表，将回退到 {available_names[0]}",
-                                OutputType.WARNING,
-                            )
+                            print(f"⚠️ 检测到子Agent模型 {current_model_name} 不存在于平台 {platform.platform_name()} 的可用模型列表，将回退到 {available_names[0]}")
                             platform.set_model_name(available_names[0])
             except Exception:
                 # 获取模型列表或设置模型失败时，保持原设置并继续，交由底层报错处理