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

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.2.5"
+__version__ = "0.2.6"

jarvis/jarvis_agent/__init__.py

@@ -396,7 +396,7 @@ class Agent:
         """
         return execute_tool_call(response, self)
 
-    def _complete_task(self) -> str:
+    def _complete_task(self, auto_completed: bool = False) -> str:
         """完成任务并生成总结(如果需要)
 
         返回:
@@ -407,8 +407,26 @@ class Agent:
             2. 对于子Agent: 可能会生成总结(如果启用)
             3. 使用spinner显示生成状态
         """
+        satisfaction_feedback = ""
+
+        if not auto_completed and self.use_analysis:
+            if user_confirm("您对本次任务的完成是否满意？", True):
+                satisfaction_feedback = "\n\n用户对本次任务的完成表示满意。"
+            else:
+                feedback = self.multiline_inputer(
+                    "请提供您的反馈意见（可留空直接回车）:"
+                )
+                if feedback:
+                    satisfaction_feedback = (
+                        f"\n\n用户对本次任务的完成不满意，反馈意见如下：\n{feedback}"
+                    )
+                else:
+                    satisfaction_feedback = (
+                        "\n\n用户对本次任务的完成不满意，未提供具体反馈意见。"
+                    )
+
         if self.use_analysis:
-            self._analysis_task()
+            self._analysis_task(satisfaction_feedback)
         if self.need_summary:
             print("📄 正在生成总结...")
             self.session.prompt = self.summary_prompt
@@ -420,11 +438,13 @@ class Agent:
 
         return "任务完成"
 
-    def _analysis_task(self):
+    def _analysis_task(self, satisfaction_feedback: str = ""):
         print("🔍 正在分析任务...")
         try:
             # 让模型判断是否需要生成方法论
             analysis_prompt = TASK_ANALYSIS_PROMPT
+            if satisfaction_feedback:
+                analysis_prompt += satisfaction_feedback
 
             self.session.prompt = analysis_prompt
             if not self.model:
@@ -452,6 +472,23 @@ class Agent:
             else ""
         )
 
+        # 检查工具列表并添加记忆工具相关提示
+        memory_prompts = ""
+        tool_registry = self.get_tool_registry()
+        if tool_registry:
+            tool_names = [tool.name for tool in tool_registry.tools.values()]
+            
+            # 如果有save_memory工具，添加相关提示
+            if "save_memory" in tool_names:
+                memory_prompts += "\n    - 如果有关键信息需要记忆，请调用save_memory工具进行记忆："
+                memory_prompts += "\n      * project_long_term: 保存与当前项目相关的长期信息"
+                memory_prompts += "\n      * global_long_term: 保存通用的信息、用户喜好、知识、方法等"
+                memory_prompts += "\n      * short_term: 保存当前任务相关的临时信息"
+            
+            # 如果有retrieve_memory工具，添加相关提示
+            if "retrieve_memory" in tool_names:
+                memory_prompts += "\n    - 如果需要检索相关记忆信息，请调用retrieve_memory工具"
+
         addon_prompt = f"""
 <system_prompt>
     请判断是否已经完成任务，如果已经完成：
@@ -461,7 +498,7 @@ class Agent:
     - 仅包含一个操作
     - 如果信息不明确，请请求用户补充
     - 如果执行过程中连续失败5次，请使用ask_user询问用户操作
-    - 操作列表：{action_handlers}
+    - 操作列表：{action_handlers}{memory_prompts}
 </system_prompt>
 
 请继续。
@@ -547,7 +584,7 @@ class Agent:
                         continue
 
                     if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:
-                        return self._complete_task()
+                        return self._complete_task(auto_completed=True)
 
                     # 获取用户输入
                     user_input = self.multiline_inputer(
@@ -560,7 +597,7 @@ class Agent:
                         continue
 
                     if not user_input:
-                        return self._complete_task()
+                        return self._complete_task(auto_completed=False)
 
                 except Exception as e:
                     PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
@@ -571,6 +608,23 @@ class Agent:
             return f"Task failed: {str(e)}"
 
     def _first_run(self):
+        # 获取所有记忆标签并添加到提示中
+        from jarvis.jarvis_utils.globals import get_all_memory_tags
+        
+        memory_tags = get_all_memory_tags()
+        memory_tags_prompt = ""
+        
+        if any(tags for tags in memory_tags.values()):
+            memory_tags_prompt = "\n\n系统中存在以下记忆标签，你可以使用 retrieve_memory 工具检索相关记忆："
+            for memory_type, tags in memory_tags.items():
+                if tags:
+                    type_name = {
+                        "short_term": "短期记忆",
+                        "project_long_term": "项目长期记忆", 
+                        "global_long_term": "全局长期记忆"
+                    }.get(memory_type, memory_type)
+                    memory_tags_prompt += f"\n- {type_name}: {', '.join(tags)}"
+        
         # 如果有上传文件，先上传文件
         if self.model and self.model.support_upload_files():
             if self.use_methodology:
@@ -583,12 +637,12 @@ class Agent:
                     msg = self.session.prompt
                     for handler in self.input_handler:
                         msg, _ = handler(msg, self)
-                    self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
+                    self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}{memory_tags_prompt}"
                 else:
                     if self.files:
-                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。"
+                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。{memory_tags_prompt}"
                     else:
-                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
+                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。{memory_tags_prompt}"
             elif self.files:
                 if not self.model.upload_files(self.files):
                     PrettyOutput.print(
@@ -604,6 +658,10 @@ class Agent:
                 for handler in self.input_handler:
                     msg, _ = handler(msg, self)
                 self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
+        
+        # 添加记忆标签提示
+        if memory_tags_prompt:
+            self.session.prompt = f"{self.session.prompt}{memory_tags_prompt}"
 
         self.first = False
 

jarvis/jarvis_agent/edit_file_handler.py

@@ -204,9 +204,9 @@ class EditFileHandler(OutputHandler):
                 found = False
 
                 if exact_search in modified_content:
-                    # 直接执行替换（保留所有原始格式）
+                    # 直接执行替换（保留所有原始格式），只替换第一个匹配
                     modified_content = modified_content.replace(
-                        exact_search, replace_text
+                        exact_search, replace_text, 1
                     )
                     print(f"✅ 补丁 #{patch_count} 应用成功")
                     found = True
@@ -222,7 +222,7 @@ class EditFileHandler(OutputHandler):
                         stripped_replace = replace_text[1:-1]
                         if stripped_search in modified_content:
                             modified_content = modified_content.replace(
-                                stripped_search, stripped_replace
+                                stripped_search, stripped_replace, 1
                             )
                             print(f"✅ 补丁 #{patch_count} 应用成功 (自动去除首尾换行)")
                             found = True
@@ -251,7 +251,7 @@ class EditFileHandler(OutputHandler):
                             )
                             if indented_search in modified_content:
                                 modified_content = modified_content.replace(
-                                    indented_search, indented_replace
+                                    indented_search, indented_replace, 1
                                 )
                                 print(
                                     f"✅ 补丁 #{patch_count} 应用成功 (自动增加 {space_count} 个空格缩进)"

jarvis/jarvis_code_agent/code_agent.py

@@ -65,6 +65,8 @@ class CodeAgent:
                 "ask_user",
                 "read_code",
                 "rewrite_file",
+                "save_memory",
+                "retrieve_memory",
             ]
         )
         code_system_prompt = """
@@ -269,7 +271,7 @@ class CodeAgent:
             return
 
         PrettyOutput.print(
-            "⚠️ 即将修改git换行符敏感设置，这会影响所有文件的换行符处理方式",
+            "⚠️ 正在修改git换行符敏感设置，这会影响所有文件的换行符处理方式",
             OutputType.WARNING,
         )
         print("将进行以下设置：")
@@ -277,18 +279,15 @@ class CodeAgent:
             current = current_settings.get(key, "未设置")
             print(f"  {key}: {current} -> {value}")
 
-        if user_confirm("是否继续修改git换行符敏感设置？", True):
-            for key, value in target_settings.items():
-                subprocess.run(["git", "config", key, value], check=True)
+        # 直接执行设置，不需要用户确认
+        for key, value in target_settings.items():
+            subprocess.run(["git", "config", key, value], check=True)
 
-            # 对于Windows系统，提示用户可以创建.gitattributes文件
-            if sys.platform.startswith("win"):
-                self._handle_windows_line_endings()
+        # 对于Windows系统，提示用户可以创建.gitattributes文件
+        if sys.platform.startswith("win"):
+            self._handle_windows_line_endings()
 
-            print("✅ git换行符敏感设置已更新")
-        else:
-            print("❌ 用户取消修改git换行符敏感设置")
-            sys.exit(0)
+        print("✅ git换行符敏感设置已更新")
 
     def _handle_windows_line_endings(self) -> None:
         """在Windows系统上处理换行符问题，提供建议而非强制修改"""

jarvis/jarvis_multi_agent/main.py

@@ -7,6 +7,7 @@ import yaml
 from jarvis.jarvis_multi_agent import MultiAgent
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 app = typer.Typer(help="多智能体系统启动器")
 

jarvis/jarvis_tools/retrieve_memory.py

@@ -0,0 +1,206 @@
+# -*- 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: 从所有类型中检索
+    
+    可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
+    """
+
+    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,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/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/utils.py

@@ -30,6 +30,35 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 g_config_file = None
 
+COMMAND_MAPPING = {
+    # jarvis主命令
+    "jvs": "jarvis",
+    # 代码代理
+    "jca": "jarvis-code-agent",
+    # 智能shell
+    "jss": "jarvis-smart-shell",
+    # 平台管理
+    "jpm": "jarvis-platform-manager",
+    # Git提交
+    "jgc": "jarvis-git-commit",
+    # 代码审查
+    "jcr": "jarvis-code-review",
+    # Git压缩
+    "jgs": "jarvis-git-squash",
+    # 多代理
+    "jma": "jarvis-multi-agent",
+    # 代理
+    "ja": "jarvis-agent",
+    # 工具
+    "jt": "jarvis-tool",
+    # 方法论
+    "jm": "jarvis-methodology",
+    # RAG
+    "jrg": "jarvis-rag",
+    # 统计
+    "jst": "jarvis-stats",
+}
+
 
 def _setup_signal_handler() -> None:
     """设置SIGINT信号处理函数"""
@@ -149,6 +178,15 @@ def _show_usage_stats() -> None:
                         elif group == "command":
                             categorized_stats["command"]["metrics"][metric] = int(total)
 
+        # 合并长短命令的历史统计数据
+        command_stats = categorized_stats["command"]["metrics"]
+        if command_stats:
+            merged_stats: Dict[str, int] = {}
+            for metric, count in command_stats.items():
+                long_command = COMMAND_MAPPING.get(metric, metric)
+                merged_stats[long_command] = merged_stats.get(long_command, 0) + count
+            categorized_stats["command"]["metrics"] = merged_stats
+
         # 计算采纳率并添加到统计中
         commit_stats = categorized_stats["commit"]["metrics"]
         # 尝试多种可能的指标名称
@@ -348,7 +386,7 @@ def _show_usage_stats() -> None:
                 remaining_days_after_months = remaining_days_after_years % 20
                 work_days = remaining_days_after_months
                 remaining_hours = int(hours % 8)  # 剩余不足一个工作日的小时数
-                
+
                 # 构建时间描述
                 time_parts = []
                 if work_years > 0:
@@ -359,17 +397,25 @@ def _show_usage_stats() -> None:
                     time_parts.append(f"{work_days} 个工作日")
                 if remaining_hours > 0:
                     time_parts.append(f"{remaining_hours} 小时")
-                
+
                 if time_parts:
                     time_description = "、".join(time_parts)
                     if work_years >= 1:
-                        encouragement = f"🎉 相当于节省了 {time_description} 的工作时间！"
+                        encouragement = (
+                            f"🎉 相当于节省了 {time_description} 的工作时间！"
+                        )
                     elif work_months >= 1:
-                        encouragement = f"🚀 相当于节省了 {time_description} 的工作时间！"
+                        encouragement = (
+                            f"🚀 相当于节省了 {time_description} 的工作时间！"
+                        )
                     elif work_days >= 1:
-                        encouragement = f"💪 相当于节省了 {time_description} 的工作时间！"
+                        encouragement = (
+                            f"💪 相当于节省了 {time_description} 的工作时间！"
+                        )
                     else:
-                        encouragement = f"✨ 相当于节省了 {time_description} 的工作时间！"
+                        encouragement = (
+                            f"✨ 相当于节省了 {time_description} 的工作时间！"
+                        )
                 elif hours >= 1:
                     encouragement = f"⭐ 相当于节省了 {int(hours)} 小时的工作时间，积少成多，继续保持！"
                 if encouragement:
@@ -459,7 +505,9 @@ def load_config():
             if schema_path.exists():
                 try:
                     config_file_path.parent.mkdir(parents=True, exist_ok=True)
-                    generate_default_config(str(schema_path), str(config_file_path))
+                    generate_default_config(
+                        str(schema_path.absolute()), str(config_file_path)
+                    )
                     PrettyOutput.print(
                         f"已生成默认配置文件: {config_file_path}", OutputType.INFO
                     )
@@ -576,7 +624,7 @@ def generate_default_config(schema_path: str, output_path: str) -> None:
 
     default_config = _generate_from_schema(schema)
 
-    content = f"# yaml-language-server: $schema={schema}\n"
+    content = f"# yaml-language-server: $schema={schema_path}\n"
     content += yaml.dump(default_config, allow_unicode=True, sort_keys=False)
 
     with open(output_path, "w", encoding="utf-8") as f:
@@ -718,43 +766,13 @@ def count_cmd_usage() -> None:
     import os
     from jarvis.jarvis_stats.stats import StatsManager
 
-    # 命令映射关系：将短命令映射到长命令
-    command_mapping = {
-        # jarvis主命令
-        "jvs": "jarvis",
-        # 代码代理
-        "jca": "jarvis-code-agent",
-        # 智能shell
-        "jss": "jarvis-smart-shell",
-        # 平台管理
-        "jpm": "jarvis-platform-manager",
-        # Git提交
-        "jgc": "jarvis-git-commit",
-        # 代码审查
-        "jcr": "jarvis-code-review",
-        # Git压缩
-        "jgs": "jarvis-git-squash",
-        # 多代理
-        "jma": "jarvis-multi-agent",
-        # 代理
-        "ja": "jarvis-agent",
-        # 工具
-        "jt": "jarvis-tool",
-        # 方法论
-        "jm": "jarvis-methodology",
-        # RAG
-        "jrg": "jarvis-rag",
-        # 统计
-        "jst": "jarvis-stats",
-    }
-
     # 从完整路径中提取命令名称
     cmd_path = sys.argv[0]
     cmd_name = os.path.basename(cmd_path)
-    
+
     # 如果是短命令，映射到长命令
-    if cmd_name in command_mapping:
-        metric_name = command_mapping[cmd_name]
+    if cmd_name in COMMAND_MAPPING:
+        metric_name = COMMAND_MAPPING[cmd_name]
     else:
         metric_name = cmd_name
 

{jarvis_ai_assistant-0.2.5.dist-info → jarvis_ai_assistant-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.2.5
+Version: 0.2.6
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

{jarvis_ai_assistant-0.2.5.dist-info → jarvis_ai_assistant-0.2.6.dist-info}/RECORD

@@ -1,7 +1,7 @@
-jarvis/__init__.py,sha256=aS_w22vow2WExj_McIPVjDx3AihnwV9M6DLoPEXvmzk,73
-jarvis/jarvis_agent/__init__.py,sha256=tClK_8jgNti_A-o4SecZAeMYRz_JWjf01sdWt1ho420,23190
+jarvis/__init__.py,sha256=LeVLn20oHpcp1TpDsXJ8P6m_z_MKXTzTQvPUv3CRNK4,73
+jarvis/jarvis_agent/__init__.py,sha256=nhJ9QOdFQJHpdLsFO0_JNH0XJHvXxMDHDTP4b7-OSnA,26370
 jarvis/jarvis_agent/builtin_input_handler.py,sha256=Qs4LAr4xdKLBJpQE81YP4CkucAop86ms0iVoKa1nnso,2468
-jarvis/jarvis_agent/edit_file_handler.py,sha256=zZAhv5zYQQNNhpu6bOjL3exC9le4DSQnefzotBB-jPY,11818
+jarvis/jarvis_agent/edit_file_handler.py,sha256=w-byNJ4TN_SlV3djjfFC7OksySOFGrM8ku49w662dzc,11854
 jarvis/jarvis_agent/jarvis.py,sha256=L2sI-Y7gxqH6M4E4F2GlNoZcxxvz_f72rxvjh7bxuZE,8443
 jarvis/jarvis_agent/main.py,sha256=56pLVy6v-3ZdyPCcWXdRkgbjmYsoIfC7zrA6B7sYivU,3334
 jarvis/jarvis_agent/output_handler.py,sha256=P7oWpXBGFfOsWq7cIhS_z9crkQ19ES7qU5pM92KKjAs,1172
@@ -12,7 +12,7 @@ jarvis/jarvis_agent/session_manager.py,sha256=DnvI9rWkVmkyO1XfKZyo9lTn4ajg4ccwzE
 jarvis/jarvis_agent/shell_input_handler.py,sha256=1IboqdxcJuoIqRpmDU10GugR9fWXUHyCEbVF4nIWbyo,1328
 jarvis/jarvis_agent/tool_executor.py,sha256=nIq-sPNgrtimtM-IHpN09cWmId8jDzWRdCFoRzXnnoo,1721
 jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/code_agent.py,sha256=M3eEMMnIb7ndIIe4Hg8XZ1rnEbtYIUdDi9IS9pzWC2U,29191
+jarvis/jarvis_code_agent/code_agent.py,sha256=C761NUsz3W_SLJLEj6Y_HB9ox-joOlnJQ9CsfE88IFk,29100
 jarvis/jarvis_code_agent/lint.py,sha256=LZPsfyZPMo7Wm7LN4osZocuNJwZx1ojacO3MlF870x8,4009
 jarvis/jarvis_code_analysis/code_review.py,sha256=TMov1pqDe1bg0vM1ndnYeW9ejHrRN_jMroo3T4L9yag,32368
 jarvis/jarvis_code_analysis/checklists/__init__.py,sha256=LIXAYa1sW3l7foP6kohLWnE98I_EQ0T7z5bYKHq6rJA,78
@@ -46,7 +46,7 @@ jarvis/jarvis_mcp/stdio_mcp_client.py,sha256=APYUksYKlMx7AVNODKOLrTkKZPnp4kqTQIY
 jarvis/jarvis_mcp/streamable_mcp_client.py,sha256=sP0KEsxVcXGht0eA7a_m-ECtZAk39s4PL9OUdm35x2Y,14467
 jarvis/jarvis_methodology/main.py,sha256=6QF8hH3vB6rfxim0fPR34uVPf41zVpb4ZLqrFN2qONg,10983
 jarvis/jarvis_multi_agent/__init__.py,sha256=kCgtAX7VvliyEOQxIj2DvNjRAuh6bpNaOtDn60nzph4,6089
-jarvis/jarvis_multi_agent/main.py,sha256=EUJCLjiN6ZZkOTmRS13oeTquo3tXD-cdO_QvaEPCK_c,1715
+jarvis/jarvis_multi_agent/main.py,sha256=Wbarez48QxXexlKEOcRsoMbcQEOP5rv_DzGkNk0SfpY,1779
 jarvis/jarvis_platform/__init__.py,sha256=WLQHSiE87PPket2M50_hHzjdMIgPIBx2VF8JfB_NNRk,105
 jarvis/jarvis_platform/ai8.py,sha256=uiL1BkONteUB2aXg6kMGSXLLOhzGDl5_SNQYyQzmFNk,11412
 jarvis/jarvis_platform/base.py,sha256=cfeYB6ldfQH1tz1rroQpmJTLAw8KByKS74qun0pqE1c,9498
@@ -86,7 +86,9 @@ jarvis/jarvis_tools/methodology.py,sha256=_K4GIDUodGEma3SvNRo7Qs5rliijgNespVLyAP
 jarvis/jarvis_tools/read_code.py,sha256=EnI-R-5HyIQYhMD391nZWXHIuHHBF-OJIRE0QpLcPX4,6417
 jarvis/jarvis_tools/read_webpage.py,sha256=NmDUboVZd4CGHBPRFK6dp3uqVhuGopW1bOi3TcaLDF4,2092
 jarvis/jarvis_tools/registry.py,sha256=8qhZgmmGIXJsYwtpsp_Ls8woT0qmBrthF8lIuQqOu7c,28614
+jarvis/jarvis_tools/retrieve_memory.py,sha256=CKmNym5FxHjgdc0my4IlsJ3TB3E2m0aCNFSRWjH6fKs,8221
 jarvis/jarvis_tools/rewrite_file.py,sha256=eG_WKg6cVAXmuGwUqlWkcuyay5S8DOzEi8vZCmX3O8w,7255
+jarvis/jarvis_tools/save_memory.py,sha256=4KRJWiyeyaIfdjeCAflPrxJ5ZXA4gUL3tv9h6d6sFKc,5309
 jarvis/jarvis_tools/search_web.py,sha256=zh6EYLQPIQneoz27Hheh-fifMeMNhrTVldXKMSsMz2Y,5801
 jarvis/jarvis_tools/virtual_tty.py,sha256=LTsg1PlsPvgaLShUaxpAKwTpyjXRr0l0qSREI7Q-fBc,26349
 jarvis/jarvis_tools/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -97,16 +99,16 @@ jarvis/jarvis_utils/config.py,sha256=-ZgqIkzsp8VP5qsXke9XAGuwtAB9XlOAo_k4L6jhcrE
 jarvis/jarvis_utils/embedding.py,sha256=oEOEM2qf16DMYwPsQe6srET9BknyjOdY2ef0jsp3Or8,2714
 jarvis/jarvis_utils/file_processors.py,sha256=XiM248SHS7lLgQDCbORVFWqinbVDUawYxWDOsLXDxP8,3043
 jarvis/jarvis_utils/git_utils.py,sha256=dkC0HcUdm_rF5vXNoLByne3mGykZEviD3Lo_SYbwROU,21667
-jarvis/jarvis_utils/globals.py,sha256=INBGXbDkXOQa0AE7L6JhR5gr-TAZMsE5y4yK1sbB98U,4643
+jarvis/jarvis_utils/globals.py,sha256=lpS1lmWRnLgqOeoyhZlktdZK9SK8YMekc6XWamho0Jw,8561
 jarvis/jarvis_utils/http.py,sha256=eRhV3-GYuWmQ0ogq9di9WMlQkFcVb1zGCrySnOgT1x0,4392
 jarvis/jarvis_utils/input.py,sha256=g0Xa1TNZHxLaYduREV_Wc55iqHD6djN73YFJbR83gUg,9488
 jarvis/jarvis_utils/methodology.py,sha256=EqS9feS3HHgNcKYoGs-Dkhp4pGwylwXt96r2J61cxUo,9223
 jarvis/jarvis_utils/output.py,sha256=E_J_RYXtkOgRiDSHCRE9QPHY8WQmmhIotQtIQru8GZA,10888
 jarvis/jarvis_utils/tag.py,sha256=f211opbbbTcSyzCDwuIK_oCnKhXPNK-RknYyGzY1yD0,431
-jarvis/jarvis_utils/utils.py,sha256=6_KsDN2_L9CB0jJvfbGTpBPWaQf-qMIPwq3_s3qUYww,36512
-jarvis_ai_assistant-0.2.5.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.2.5.dist-info/METADATA,sha256=jaM72Jlpyd-UmR-6riUlssskcGTy9C69j7FGUKwZP4Q,16807
-jarvis_ai_assistant-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jarvis_ai_assistant-0.2.5.dist-info/entry_points.txt,sha256=8cwi1VxZGU5UeSZMFiH-jG6NK95Asjukj5SBLBrGiGo,1257
-jarvis_ai_assistant-0.2.5.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.2.5.dist-info/RECORD,,
+jarvis/jarvis_utils/utils.py,sha256=b7t2BsoPEU_3ZhippcQW9qwQD0PO-sGkjjtZ4DvwI2s,37056
+jarvis_ai_assistant-0.2.6.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.2.6.dist-info/METADATA,sha256=4XIqrWX0_tWmBC88XLFVlZGa2nzIbijiUxVW4g0y20I,16807
+jarvis_ai_assistant-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jarvis_ai_assistant-0.2.6.dist-info/entry_points.txt,sha256=8cwi1VxZGU5UeSZMFiH-jG6NK95Asjukj5SBLBrGiGo,1257
+jarvis_ai_assistant-0.2.6.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.2.6.dist-info/RECORD,,