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

jarvis/jarvis_tools/save_memory.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+import json
+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": {
+            "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"],
+    }
+
+    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"""
+        return datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行保存记忆操作"""
+        try:
+            memory_type = args["memory_type"]
+            tags = args.get("tags", [])
+            content = args.get("content", "")
+
+            # 生成记忆ID
+            memory_id = self._generate_memory_id()
+
+            # 创建记忆对象
+            memory_data = {
+                "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_data)
+
+                # 打印成功信息
+                PrettyOutput.print(
+                    f"短期记忆已保存\n"
+                    f"ID: {memory_id}\n"
+                    f"类型: {memory_type}\n"
+                    f"标签: {', '.join(tags)}\n"
+                    f"存储位置: 内存（非持久化）",
+                    OutputType.SUCCESS,
+                )
+
+                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_data, f, ensure_ascii=False, indent=2)
+
+                # 打印成功信息
+                PrettyOutput.print(
+                    f"记忆已保存\n"
+                    f"ID: {memory_id}\n"
+                    f"类型: {memory_type}\n"
+                    f"标签: {', '.join(tags)}\n"
+                    f"位置: {memory_file}",
+                    OutputType.SUCCESS,
+                )
+
+                result = {
+                    "memory_id": memory_id,
+                    "memory_type": memory_type,
+                    "tags": tags,
+                    "file_path": str(memory_file),
+                    "message": f"记忆已成功保存，ID: {memory_id}",
+                }
+
+            return {
+                "success": True,
+                "stdout": json.dumps(result, 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

@@ -81,10 +81,10 @@ def get_max_token_count(model_group_override: Optional[str] = None) -> int:
     获取模型允许的最大token数量。
 
     返回:
-        int: 模型能处理的最大token数量。
+        int: 模型能处理的最大token数量，为最大输入token数量的100倍。
     """
-    config = _get_resolved_model_config(model_group_override)
-    return int(config.get("JARVIS_MAX_TOKEN_COUNT", "960000"))
+    max_input_tokens = get_max_input_token_count(model_group_override)
+    return max_input_tokens * 100
 
 
 def get_max_input_token_count(model_group_override: Optional[str] = None) -> int:
@@ -151,9 +151,7 @@ def _get_resolved_model_config(
         "JARVIS_MODEL",
         "JARVIS_THINKING_PLATFORM",
         "JARVIS_THINKING_MODEL",
-        "JARVIS_MAX_TOKEN_COUNT",
         "JARVIS_MAX_INPUT_TOKEN_COUNT",
-        "JARVIS_MAX_BIG_CONTENT_SIZE",
     ]:
         if key in GLOBAL_CONFIG_DATA:
             resolved_config[key] = GLOBAL_CONFIG_DATA[key]
@@ -249,10 +247,10 @@ def get_max_big_content_size(model_group_override: Optional[str] = None) -> int:
     获取最大大内容大小。
 
     返回：
-        int: 最大大内容大小
+        int: 最大大内容大小，为最大输入token数量的5倍
     """
-    config = _get_resolved_model_config(model_group_override)
-    return int(config.get("JARVIS_MAX_BIG_CONTENT_SIZE", "160000"))
+    max_input_tokens = get_max_input_token_count(model_group_override)
+    return max_input_tokens * 5
 
 
 def get_pretty_output() -> bool:

jarvis/jarvis_utils/globals.py

@@ -10,11 +10,16 @@
 import os
 
 # 全局变量：保存消息历史
-from typing import Any, Dict, Set, List
+from typing import Any, Dict, Set, List, Optional
+from datetime import datetime
 
 message_history: List[str] = []
 MAX_HISTORY_SIZE = 50
 
+# 短期记忆存储
+short_term_memories: List[Dict[str, Any]] = []
+MAX_SHORT_TERM_MEMORIES = 100
+
 import colorama
 from rich.console import Console
 from rich.theme import Theme
@@ -207,3 +212,117 @@ def get_message_history() -> List[str]:
     """
     global message_history
     return message_history
+
+
+def add_short_term_memory(memory_data: Dict[str, Any]) -> None:
+    """
+    添加短期记忆到全局存储。
+
+    参数:
+        memory_data: 包含记忆信息的字典
+    """
+    global short_term_memories
+    short_term_memories.append(memory_data)
+    # 如果超过最大数量，删除最旧的记忆
+    if len(short_term_memories) > MAX_SHORT_TERM_MEMORIES:
+        short_term_memories.pop(0)
+
+
+def get_short_term_memories(tags: Optional[List[str]] = None) -> List[Dict[str, Any]]:
+    """
+    获取短期记忆，可选择按标签过滤。
+
+    参数:
+        tags: 用于过滤的标签列表（可选）
+
+    返回:
+        List[Dict[str, Any]]: 符合条件的短期记忆列表
+    """
+    global short_term_memories
+    if not tags:
+        return short_term_memories.copy()
+
+    # 按标签过滤
+    filtered_memories = []
+    for memory in short_term_memories:
+        memory_tags = memory.get("tags", [])
+        if any(tag in memory_tags for tag in tags):
+            filtered_memories.append(memory)
+
+    return filtered_memories
+
+
+def clear_short_term_memories() -> None:
+    """
+    清空所有短期记忆。
+    """
+    global short_term_memories
+    short_term_memories.clear()
+
+
+def get_all_memory_tags() -> Dict[str, List[str]]:
+    """
+    获取所有记忆类型中的标签集合。
+    每个类型最多返回200个标签，超过时随机提取。
+    
+    返回:
+        Dict[str, List[str]]: 按记忆类型分组的标签列表
+    """
+    from pathlib import Path
+    import json
+    import random
+    from jarvis.jarvis_utils.config import get_data_dir
+    
+    tags_by_type = {
+        "short_term": [],
+        "project_long_term": [],
+        "global_long_term": []
+    }
+    
+    MAX_TAGS_PER_TYPE = 200
+    
+    # 获取短期记忆标签
+    short_term_tags = set()
+    for memory in short_term_memories:
+        short_term_tags.update(memory.get("tags", []))
+    short_term_tags_list = sorted(list(short_term_tags))
+    if len(short_term_tags_list) > MAX_TAGS_PER_TYPE:
+        tags_by_type["short_term"] = sorted(random.sample(short_term_tags_list, MAX_TAGS_PER_TYPE))
+    else:
+        tags_by_type["short_term"] = short_term_tags_list
+    
+    # 获取项目长期记忆标签
+    project_memory_dir = Path(".jarvis/memory")
+    if project_memory_dir.exists():
+        project_tags = set()
+        for memory_file in project_memory_dir.glob("*.json"):
+            try:
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+                    project_tags.update(memory_data.get("tags", []))
+            except Exception:
+                pass
+        project_tags_list = sorted(list(project_tags))
+        if len(project_tags_list) > MAX_TAGS_PER_TYPE:
+            tags_by_type["project_long_term"] = sorted(random.sample(project_tags_list, MAX_TAGS_PER_TYPE))
+        else:
+            tags_by_type["project_long_term"] = project_tags_list
+    
+    # 获取全局长期记忆标签
+    global_memory_dir = Path(get_data_dir()) / "memory" / "global_long_term"
+    if global_memory_dir.exists():
+        global_tags = set()
+        for memory_file in global_memory_dir.glob("*.json"):
+            try:
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+                    global_tags.update(memory_data.get("tags", []))
+            except Exception:
+                pass
+        global_tags_list = sorted(list(global_tags))
+        if len(global_tags_list) > MAX_TAGS_PER_TYPE:
+            tags_by_type["global_long_term"] = sorted(random.sample(global_tags_list, MAX_TAGS_PER_TYPE))
+        else:
+            tags_by_type["global_long_term"] = global_tags_list
+    
+    return tags_by_type

jarvis/jarvis_utils/methodology.py

@@ -149,6 +149,7 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 
     参数：
         user_input: 用户输入文本，用于提示大模型
+        tool_registery: 工具注册表，用于获取工具列表
 
     返回：
         str: 相关的方法论提示，如果未找到方法论则返回空字符串
@@ -170,70 +171,87 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
             return ""
         print(f"✅ 加载方法论文件完成 (共 {len(methodologies)} 个)")
 
-        # 获取当前平台
-        agent = get_agent(current_agent_name)
-        if agent:
-            platform = agent.model
-            model_group = agent.model.model_group
-        else:
-            platform = PlatformRegistry().get_normal_platform()
-            model_group = None
-        platform.set_suppress_output(False)
-        if not platform:
-            return ""
+        platform = PlatformRegistry().get_normal_platform()
+        platform.set_suppress_output(True)
+
+        # 步骤1：获取所有方法论的标题
+        methodology_titles = list(methodologies.keys())
 
-        # 构建基础提示信息
-        base_prompt = f"""以下是所有可用的方法论内容：
+        # 步骤2：让大模型选择相关性高的方法论
+        selection_prompt = f"""以下是所有可用的方法论标题：
 
 """
-        # 构建完整内容
-        full_content = base_prompt
-        for problem_type, content in methodologies.items():
-            full_content += f"## {problem_type}\n\n{content}\n\n---\n\n"
+        for i, title in enumerate(methodology_titles, 1):
+            selection_prompt += f"{i}. {title}\n"
 
-        full_content += f"以下是所有可用的工具内容：\n\n"
-        full_content += prompt
+        selection_prompt += f"""
+以下是可用的工具列表：
+{prompt}
 
-        # 添加用户输入和输出要求
-        full_content += f"""
-请根据以上方法论和可调用的工具内容，规划/总结出以下用户需求的执行步骤: {user_input}
+用户需求：{user_input}
 
-请按以下格式回复：
-### 与该任务/需求相关的方法论
-1. [方法论名字]
-2. [方法论名字]
-### 根据以上方法论，规划/总结出执行步骤
-1. [步骤1]
-2. [步骤2]
-3. [步骤3]
+请分析用户需求，从上述方法论中选择出与需求相关性较高的方法论（可以选择多个）。
 
-如果没有匹配的方法论，请输出：没有历史方法论可参考
-除以上要求外，不要输出任何内容
+请严格按照以下格式返回序号：
+<NUM>序号1,序号2,序号3</NUM>
+
+例如：<NUM>1,3,5</NUM>
+
+如果没有相关的方法论，请返回：<NUM>none</NUM>
+
+注意：只返回<NUM>标签内的内容，不要有其他任何输出。
 """
 
-        # 检查内容是否过大
-        is_large_content = is_context_overflow(full_content, model_group)
-        temp_file_path = None
+        # 获取大模型选择的方法论序号
+        response = platform.chat_until_success(selection_prompt).strip()
+
+        # 重置平台，恢复输出
+        platform.reset()
+        platform.set_suppress_output(False)
+
+        # 从响应中提取<NUM>标签内的内容
+        import re
+        num_match = re.search(r'<NUM>(.*?)</NUM>', response, re.DOTALL)
+        
+        if not num_match:
+            # 如果没有找到<NUM>标签，尝试直接解析响应
+            selected_indices_str = response
+        else:
+            selected_indices_str = num_match.group(1).strip()
+
+        if selected_indices_str.lower() == "none":
+            return "没有历史方法论可参考"
 
+        # 解析选择的序号
+        selected_methodologies = {}
         try:
-            if is_large_content:
-                # 创建临时文件
-                print(f"📝 创建方法论临时文件...")
-                temp_file_path = _create_methodology_temp_file(methodologies)
-                if not temp_file_path:
-                    print(f"❌ 创建方法论临时文件失败")
-                    return ""
-                print(f"✅ 创建方法论临时文件完成")
-
-                # 尝试上传文件
-                upload_success = platform.upload_files([temp_file_path])
-
-                if upload_success:
-                    # 使用上传的文件生成摘要
-                    return platform.chat_until_success(
-                        base_prompt
-                        + f"""
-请根据已上传的方法论和可调用的工具文件内容，规划/总结出以下用户需求的执行步骤: {user_input}
+            if selected_indices_str:
+                indices = [int(idx.strip()) for idx in selected_indices_str.split(",") if idx.strip().isdigit()]
+                for idx in indices:
+                    if 1 <= idx <= len(methodology_titles):
+                        title = methodology_titles[idx - 1]
+                        selected_methodologies[title] = methodologies[title]
+        except Exception:
+            # 如果解析失败，返回空结果
+            return "没有历史方法论可参考"
+
+        if not selected_methodologies:
+            return "没有历史方法论可参考"
+
+        # 步骤3：将选择出来的方法论内容提供给大模型生成步骤
+        final_prompt = f"""以下是与用户需求相关的方法论内容：
+
+"""
+        for problem_type, content in selected_methodologies.items():
+            final_prompt += f"## {problem_type}\n\n{content}\n\n---\n\n"
+
+        final_prompt += f"""以下是所有可用的工具内容：
+
+{prompt}
+
+用户需求：{user_input}
+
+请根据以上方法论和可调用的工具内容，规划/总结出执行步骤。
 
 请按以下格式回复：
 ### 与该任务/需求相关的方法论
@@ -244,22 +262,11 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 2. [步骤2]
 3. [步骤3]
 
-如果没有匹配的方法论，请输出：没有历史方法论可参考
 除以上要求外，不要输出任何内容
 """
-                    )
-                else:
-                    return "没有历史方法论可参考"
-            # 如果内容不大或上传失败，直接使用chat_until_success
-            return platform.chat_until_success(full_content)
-
-        finally:
-            # 清理临时文件
-            if temp_file_path and os.path.exists(temp_file_path):
-                try:
-                    os.remove(temp_file_path)
-                except Exception:
-                    pass
+
+        # 如果内容不大，直接使用chat_until_success
+        return platform.chat_until_success(final_prompt)
 
     except Exception as e:
         PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)