jarvis-ai-assistant 0.2.5__py3-none-any.whl → 0.2.7__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/retrieve_memory.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+import json
+import random
+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 get_short_term_memories
+
+
+class RetrieveMemoryTool:
+    """检索记忆工具，用于从长短期记忆系统中检索信息"""
+
+    name = "retrieve_memory"
+    description = """从长短期记忆系统中检索信息。
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆（与当前项目相关的信息）
+    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
+    - short_term: 短期记忆（当前任务相关的信息）
+    - all: 从所有类型中检索
+    
+    可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
+    注意：标签数量建议不要超过10个，以保证检索效率
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memory_types": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "project_long_term",
+                        "global_long_term",
+                        "short_term",
+                        "all",
+                    ],
+                },
+                "description": "要检索的记忆类型列表，如果包含'all'则检索所有类型",
+            },
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "用于过滤的标签列表（可选）",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "返回结果的最大数量（可选，默认返回所有）",
+                "minimum": 1,
+            },
+        },
+        "required": ["memory_types"],
+    }
+
+    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 _retrieve_from_type(
+        self, memory_type: str, tags: Optional[List[str]] = None
+    ) -> List[Dict[str, Any]]:
+        """从指定类型中检索记忆"""
+        memories: List[Dict[str, Any]] = []
+
+        if memory_type == "short_term":
+            # 从全局变量获取短期记忆
+            memories = get_short_term_memories(tags)
+        else:
+            # 从文件系统获取长期记忆
+            memory_dir = self._get_memory_dir(memory_type)
+
+            if not memory_dir.exists():
+                return memories
+
+            # 遍历记忆文件
+            for memory_file in memory_dir.glob("*.json"):
+                try:
+                    with open(memory_file, "r", encoding="utf-8") as f:
+                        memory_data = json.load(f)
+
+                    # 如果指定了标签，检查是否匹配
+                    if tags:
+                        memory_tags = memory_data.get("tags", [])
+                        if not any(tag in memory_tags for tag in tags):
+                            continue
+
+                    memories.append(memory_data)
+                except Exception as e:
+                    PrettyOutput.print(
+                        f"读取记忆文件 {memory_file} 失败: {str(e)}", OutputType.WARNING
+                    )
+
+        return memories
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行检索记忆操作"""
+        try:
+            memory_types = args.get("memory_types", [])
+            tags = args.get("tags", [])
+            limit = args.get("limit", None)
+
+            # 确定要检索的记忆类型
+            if "all" in memory_types:
+                types_to_search = [
+                    "project_long_term",
+                    "global_long_term",
+                    "short_term",
+                ]
+            else:
+                types_to_search = memory_types
+
+            # 从各个类型中检索记忆
+            all_memories = []
+            for memory_type in types_to_search:
+                memories = self._retrieve_from_type(memory_type, tags)
+                all_memories.extend(memories)
+
+            # 按创建时间排序（最新的在前）
+            all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+
+            # 限制最多返回50条记忆，随机选取
+            if len(all_memories) > 50:
+                all_memories = random.sample(all_memories, 50)
+                # 重新排序，保持时间顺序
+                all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+
+            # 如果指定了限制，只返回前N个
+            if limit:
+                all_memories = all_memories[:limit]
+
+            # 打印结果摘要
+            PrettyOutput.print(f"检索到 {len(all_memories)} 条记忆", OutputType.INFO)
+
+            if tags:
+                PrettyOutput.print(f"使用标签过滤: {', '.join(tags)}", OutputType.INFO)
+
+            # 格式化为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"
+                )
+
+                # 内容部分
+                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"]
+                }
+                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"
+
+            # 如果记忆较多，在终端显示摘要
+            if len(all_memories) > 5:
+                PrettyOutput.print(f"记忆较多，仅显示前5条摘要：", OutputType.INFO)
+                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,
+                "stdout": markdown_output,
+                "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/save_memory.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+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
+
+
+class SaveMemoryTool:
+    """保存记忆工具，用于将信息保存到长短期记忆系统"""
+
+    name = "save_memory"
+    description = """保存信息到长短期记忆系统。
+    
+    支持批量保存多条记忆，可以同时保存不同类型的记忆。
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆（与当前项目相关的信息）
+    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
+    - short_term: 短期记忆（当前任务相关的信息）
+    
+    项目长期记忆存储在当前目录的 .jarvis/memory 下
+    全局长期记忆和短期记忆存储在数据目录的 memory 子目录下
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memories": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "memory_type": {
+                            "type": "string",
+                            "enum": [
+                                "project_long_term",
+                                "global_long_term",
+                                "short_term",
+                            ],
+                            "description": "记忆类型",
+                        },
+                        "tags": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "用于索引记忆的标签列表",
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "要保存的记忆内容",
+                        },
+                    },
+                    "required": ["memory_type", "tags", "content"],
+                },
+                "description": "要保存的记忆列表",
+            }
+        },
+        "required": ["memories"],
+    }
+
+    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 _generate_memory_id(self) -> str:
+        """生成唯一的记忆ID"""
+        # 添加微秒级时间戳确保唯一性
+        time.sleep(0.001)  # 确保不同记忆有不同的时间戳
+        return datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+    def _save_single_memory(self, memory_data: Dict[str, Any]) -> Dict[str, Any]:
+        """保存单条记忆"""
+        memory_type = memory_data["memory_type"]
+        tags = memory_data.get("tags", [])
+        content = memory_data.get("content", "")
+
+        # 生成记忆ID
+        memory_id = self._generate_memory_id()
+
+        # 创建记忆对象
+        memory_obj = {
+            "id": memory_id,
+            "type": memory_type,
+            "tags": tags,
+            "content": content,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+        }
+
+        if memory_type == "short_term":
+            # 短期记忆保存到全局变量
+            add_short_term_memory(memory_obj)
+
+            result = {
+                "memory_id": memory_id,
+                "memory_type": memory_type,
+                "tags": tags,
+                "storage": "memory",
+                "message": f"短期记忆已成功保存到内存，ID: {memory_id}",
+            }
+        else:
+            # 长期记忆保存到文件
+            # 获取存储目录并确保存在
+            memory_dir = self._get_memory_dir(memory_type)
+            memory_dir.mkdir(parents=True, exist_ok=True)
+
+            # 保存记忆文件
+            memory_file = memory_dir / f"{memory_id}.json"
+            with open(memory_file, "w", encoding="utf-8") as f:
+                json.dump(memory_obj, f, ensure_ascii=False, indent=2)
+
+            result = {
+                "memory_id": memory_id,
+                "memory_type": memory_type,
+                "tags": tags,
+                "file_path": str(memory_file),
+                "message": f"记忆已成功保存，ID: {memory_id}",
+            }
+
+        return result
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行保存记忆操作"""
+        try:
+            memories = args.get("memories", [])
+
+            if not memories:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "没有提供要保存的记忆",
+                }
+
+            results = []
+            success_count = 0
+            failed_count = 0
+
+            # 保存每条记忆
+            for i, memory_data in enumerate(memories):
+                try:
+                    result = self._save_single_memory(memory_data)
+                    results.append(result)
+                    success_count += 1
+
+                    # 打印单条记忆保存信息
+                    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)}"
+                    PrettyOutput.print(error_msg, OutputType.ERROR)
+                    results.append(
+                        {
+                            "error": error_msg,
+                            "memory_type": memory_data.get("memory_type", "unknown"),
+                            "tags": memory_data.get("tags", []),
+                        }
+                    )
+
+            # 生成总结报告
+            PrettyOutput.print(
+                f"\n批量保存完成：成功 {success_count} 条，失败 {failed_count} 条",
+                OutputType.INFO,
+            )
+
+            # 构建返回结果
+            output = {
+                "total": len(memories),
+                "success": success_count,
+                "failed": failed_count,
+                "results": results,
+            }
+
+            return {
+                "success": True,
+                "stdout": json.dumps(output, ensure_ascii=False, indent=2),
+                "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_utils/config.py

@@ -309,6 +309,16 @@ def get_methodology_dirs() -> List[str]:
     return GLOBAL_CONFIG_DATA.get("JARVIS_METHODOLOGY_DIRS", [])
 
 
+def get_central_methodology_repo() -> str:
+    """
+    获取中心方法论Git仓库地址。
+
+    返回:
+        str: 中心方法论Git仓库地址，如果未配置则返回空字符串
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_CENTRAL_METHODOLOGY_REPO", "")
+
+
 def is_print_prompt() -> bool:
     """
     获取是否打印提示。