jarvis-ai-assistant 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

jarvis/jarvis_tools/clear_memory.py

@@ -0,0 +1,252 @@
+# -*- coding: utf-8 -*-
+import json
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.globals import (
+    clear_short_term_memories,
+    get_short_term_memories,
+    short_term_memories,
+)
+
+
+class ClearMemoryTool:
+    """清除记忆工具，用于批量清除指定的记忆"""
+
+    name = "clear_memory"
+    description = """批量清除指定的记忆。
+    
+    支持的清除方式：
+    1. 按记忆类型清除所有记忆
+    2. 按标签清除特定记忆
+    3. 按记忆ID清除单个记忆
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆
+    - global_long_term: 全局长期记忆
+    - short_term: 短期记忆
+    - all: 所有类型的记忆
+    
+    注意：清除操作不可恢复，请谨慎使用
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memory_types": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "project_long_term",
+                        "global_long_term",
+                        "short_term",
+                        "all",
+                    ],
+                },
+                "description": "要清除的记忆类型列表",
+            },
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要清除的记忆标签列表（可选，如果指定则只清除带有这些标签的记忆）",
+            },
+            "memory_ids": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要清除的具体记忆ID列表（可选）",
+            },
+            "confirm": {
+                "type": "boolean",
+                "description": "确认清除操作（必须为true才会执行清除）",
+                "default": False,
+            },
+        },
+        "required": ["memory_types", "confirm"],
+    }
+
+    def __init__(self):
+        """初始化清除记忆工具"""
+        self.project_memory_dir = Path(".jarvis/memory")
+        self.global_memory_dir = Path(get_data_dir()) / "memory"
+
+    def _get_memory_dir(self, memory_type: str) -> Path:
+        """根据记忆类型获取存储目录"""
+        if memory_type == "project_long_term":
+            return self.project_memory_dir
+        elif memory_type in ["global_long_term", "short_term"]:
+            return self.global_memory_dir / memory_type
+        else:
+            raise ValueError(f"未知的记忆类型: {memory_type}")
+
+    def _clear_short_term_memories(
+        self, tags: Optional[List[str]] = None, memory_ids: Optional[List[str]] = None
+    ) -> Dict[str, int]:
+        """清除短期记忆"""
+        global short_term_memories
+
+        initial_count = len(short_term_memories)
+        removed_count = 0
+
+        if memory_ids:
+            # 按ID清除
+            new_memories = []
+            for memory in short_term_memories:
+                if memory.get("id") not in memory_ids:
+                    new_memories.append(memory)
+                else:
+                    removed_count += 1
+            short_term_memories[:] = new_memories
+        elif tags:
+            # 按标签清除
+            new_memories = []
+            for memory in short_term_memories:
+                memory_tags = memory.get("tags", [])
+                if not any(tag in memory_tags for tag in tags):
+                    new_memories.append(memory)
+                else:
+                    removed_count += 1
+            short_term_memories[:] = new_memories
+        else:
+            # 清除所有
+            clear_short_term_memories()
+            removed_count = initial_count
+
+        return {"total": initial_count, "removed": removed_count}
+
+    def _clear_long_term_memories(
+        self,
+        memory_type: str,
+        tags: Optional[List[str]] = None,
+        memory_ids: Optional[List[str]] = None,
+    ) -> Dict[str, int]:
+        """清除长期记忆"""
+        memory_dir = self._get_memory_dir(memory_type)
+
+        if not memory_dir.exists():
+            return {"total": 0, "removed": 0}
+
+        total_count = 0
+        removed_count = 0
+
+        # 获取所有记忆文件
+        memory_files = list(memory_dir.glob("*.json"))
+        total_count = len(memory_files)
+
+        for memory_file in memory_files:
+            try:
+                # 读取记忆内容
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+
+                should_remove = False
+
+                if memory_ids:
+                    # 按ID判断
+                    if memory_data.get("id") in memory_ids:
+                        should_remove = True
+                elif tags:
+                    # 按标签判断
+                    memory_tags = memory_data.get("tags", [])
+                    if any(tag in memory_tags for tag in tags):
+                        should_remove = True
+                else:
+                    # 清除所有
+                    should_remove = True
+
+                if should_remove:
+                    memory_file.unlink()
+                    removed_count += 1
+
+            except Exception as e:
+                PrettyOutput.print(
+                    f"处理记忆文件 {memory_file} 时出错: {str(e)}", OutputType.WARNING
+                )
+
+        # 如果目录为空，可以删除目录
+        if not any(memory_dir.iterdir()) and memory_dir != self.project_memory_dir:
+            memory_dir.rmdir()
+
+        return {"total": total_count, "removed": removed_count}
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行清除记忆操作"""
+        try:
+            memory_types = args.get("memory_types", [])
+            tags = args.get("tags", [])
+            memory_ids = args.get("memory_ids", [])
+            confirm = args.get("confirm", False)
+
+            if not confirm:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "必须设置 confirm=true 才能执行清除操作",
+                }
+
+            # 确定要清除的记忆类型
+            if "all" in memory_types:
+                types_to_clear = ["project_long_term", "global_long_term", "short_term"]
+            else:
+                types_to_clear = memory_types
+
+            # 统计结果
+            results = {}
+            total_removed = 0
+
+            # 清除各类型的记忆
+            for memory_type in types_to_clear:
+                if memory_type == "short_term":
+                    result = self._clear_short_term_memories(tags, memory_ids)
+                else:
+                    result = self._clear_long_term_memories(
+                        memory_type, tags, memory_ids
+                    )
+
+                results[memory_type] = result
+                total_removed += result["removed"]
+
+            # 生成结果报告
+            PrettyOutput.print(
+                f"记忆清除完成，共清除 {total_removed} 条记忆", OutputType.SUCCESS
+            )
+
+            # 详细报告
+            report = f"# 记忆清除报告\n\n"
+            report += f"**总计清除**: {total_removed} 条记忆\n\n"
+
+            if tags:
+                report += f"**使用标签过滤**: {', '.join(tags)}\n\n"
+
+            if memory_ids:
+                report += f"**指定记忆ID**: {', '.join(memory_ids)}\n\n"
+
+            report += "## 详细结果\n\n"
+
+            for memory_type, result in results.items():
+                report += f"### {memory_type}\n"
+                report += f"- 原有记忆: {result['total']} 条\n"
+                report += f"- 已清除: {result['removed']} 条\n"
+                report += f"- 剩余: {result['total'] - result['removed']} 条\n\n"
+
+            # 在终端显示摘要
+            for memory_type, result in results.items():
+                if result["removed"] > 0:
+                    PrettyOutput.print(
+                        f"{memory_type}: 清除了 {result['removed']}/{result['total']} 条记忆",
+                        OutputType.INFO,
+                    )
+
+            return {
+                "success": True,
+                "stdout": report,
+                "stderr": "",
+            }
+
+        except Exception as e:
+            error_msg = f"清除记忆失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/registry.py

@@ -107,17 +107,13 @@ arguments:
 
 
 class OutputHandlerProtocol(Protocol):
-    def name(self) -> str:
-        ...
+    def name(self) -> str: ...
 
-    def can_handle(self, response: str) -> bool:
-        ...
+    def can_handle(self, response: str) -> bool: ...
 
-    def prompt(self) -> str:
-        ...
+    def prompt(self) -> str: ...
 
-    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
-        ...
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]: ...
 
 
 class ToolRegistry(OutputHandlerProtocol):
@@ -138,9 +134,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 try:
                     tools_prompt += "    <tool>\n"
                     tools_prompt += f"      <name>名称: {tool['name']}</name>\n"
-                    tools_prompt += (
-                        f"      <description>描述: {tool['description']}</description>\n"
-                    )
+                    tools_prompt += f"      <description>描述: {tool['description']}</description>\n"
                     tools_prompt += "      <parameters>\n"
                     tools_prompt += "        <yaml>|\n"
 
@@ -202,15 +196,15 @@ class ToolRegistry(OutputHandlerProtocol):
         """从数据目录获取工具调用统计"""
         from jarvis.jarvis_stats.stats import StatsManager
         from datetime import datetime, timedelta
-        
+
         # 获取所有工具的统计数据
         tool_stats = {}
         tools = self.get_all_tools()
-        
+
         # 获取所有历史数据（从很早的时间开始）
         end_time = datetime.now()
         start_time = datetime(2000, 1, 1)  # 使用一个足够早的时间
-        
+
         for tool in tools:
             tool_name = tool["name"]
             # 获取该工具的统计数据
@@ -218,22 +212,22 @@ class ToolRegistry(OutputHandlerProtocol):
                 metric_name=tool_name,
                 start_time=start_time,
                 end_time=end_time,
-                tags={"group": "tool"}
+                tags={"group": "tool"},
             )
-            
+
             # 计算总调用次数
             if stats_data and "records" in stats_data:
                 total_count = sum(record["value"] for record in stats_data["records"])
                 tool_stats[tool_name] = int(total_count)
             else:
                 tool_stats[tool_name] = 0
-                
+
         return tool_stats
 
     def _update_tool_stats(self, name: str) -> None:
         """更新工具调用统计"""
         from jarvis.jarvis_stats.stats import StatsManager
-        
+
         StatsManager.increment(name, group="tool")
 
     def use_tools(self, name: List[str]) -> None:
@@ -292,7 +286,9 @@ class ToolRegistry(OutputHandlerProtocol):
                 config = yaml.safe_load(open(file_path, "r", encoding="utf-8"))
                 self.register_mcp_tool_by_config(config)
             except Exception as e:
-                PrettyOutput.print(f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING)
+                PrettyOutput.print(
+                    f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING
+                )
 
     def _load_builtin_tools(self) -> None:
         """从内置工具目录加载工具"""
@@ -308,8 +304,33 @@ class ToolRegistry(OutputHandlerProtocol):
 
     def _load_external_tools(self) -> None:
         """从jarvis_data/tools和配置的目录加载外部工具"""
+        from jarvis.jarvis_utils.config import get_central_tool_repo
+
         tool_dirs = [str(Path(get_data_dir()) / "tools")] + get_tool_load_dirs()
 
+        # 如果配置了中心工具仓库，将其添加到加载路径
+        central_repo = get_central_tool_repo()
+        if central_repo:
+            # 中心工具仓库存储在数据目录下的特定位置
+            central_repo_path = os.path.join(get_data_dir(), "central_tool_repo")
+            tool_dirs.append(central_repo_path)
+
+            # 确保中心工具仓库被克隆/更新
+            if not os.path.exists(central_repo_path):
+                try:
+                    import subprocess
+
+                    PrettyOutput.print(
+                        f"正在克隆中心工具仓库: {central_repo}", OutputType.INFO
+                    )
+                    subprocess.run(
+                        ["git", "clone", central_repo, central_repo_path], check=True
+                    )
+                except Exception as e:
+                    PrettyOutput.print(
+                        f"克隆中心工具仓库失败: {str(e)}", OutputType.ERROR
+                    )
+
         # --- 全局每日更新检查 ---
         daily_check_git_updates(tool_dirs, "tools")
 
@@ -662,6 +683,10 @@ class ToolRegistry(OutputHandlerProtocol):
             parameters: 工具参数定义
             func: 工具执行函数
         """
+        if name in self.tools:
+            PrettyOutput.print(
+                f"警告: 工具 '{name}' 已存在，将被覆盖", OutputType.WARNING
+            )
         self.tools[name] = Tool(name, description, parameters, func)
 
     def get_tool(self, name: str) -> Optional[Tool]:
@@ -735,7 +760,9 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         if len(output.splitlines()) > 60:
             lines = output.splitlines()
-            return "\n".join(lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:])
+            return "\n".join(
+                lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:]
+            )
         return output
 
     def handle_tool_calls(self, tool_call: Dict[str, Any], agent: Any) -> str:

jarvis/jarvis_tools/retrieve_memory.py

@@ -22,6 +22,7 @@ class RetrieveMemoryTool:
     - all: 从所有类型中检索
     
     可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
+    注意：标签数量建议不要超过10个，以保证检索效率
     """
 
     parameters = {
@@ -149,35 +150,40 @@ class RetrieveMemoryTool:
             # 格式化为Markdown输出
             markdown_output = f"# 记忆检索结果\n\n"
             markdown_output += f"**检索到 {len(all_memories)} 条记忆**\n\n"
-            
+
             if tags:
                 markdown_output += f"**使用标签过滤**: {', '.join(tags)}\n\n"
-            
+
             markdown_output += f"**记忆类型**: {', '.join(types_to_search)}\n\n"
-            
+
             markdown_output += "---\n\n"
-            
+
             # 输出所有记忆
             for i, memory in enumerate(all_memories):
                 markdown_output += f"## {i+1}. {memory.get('id', '未知ID')}\n\n"
                 markdown_output += f"**类型**: {memory.get('type', '未知类型')}\n\n"
                 markdown_output += f"**标签**: {', '.join(memory.get('tags', []))}\n\n"
-                markdown_output += f"**创建时间**: {memory.get('created_at', '未知时间')}\n\n"
-                
+                markdown_output += (
+                    f"**创建时间**: {memory.get('created_at', '未知时间')}\n\n"
+                )
+
                 # 内容部分
-                content = memory.get('content', '')
+                content = memory.get("content", "")
                 if content:
                     markdown_output += f"**内容**:\n\n{content}\n\n"
-                
+
                 # 如果有额外的元数据
-                metadata = {k: v for k, v in memory.items() 
-                           if k not in ['id', 'type', 'tags', 'created_at', 'content']}
+                metadata = {
+                    k: v
+                    for k, v in memory.items()
+                    if k not in ["id", "type", "tags", "created_at", "content"]
+                }
                 if metadata:
                     markdown_output += f"**其他信息**:\n"
                     for key, value in metadata.items():
                         markdown_output += f"- {key}: {value}\n"
                     markdown_output += "\n"
-                
+
                 markdown_output += "---\n\n"
 
             # 如果记忆较多，在终端显示摘要