jarvis-ai-assistant 0.2.5__tar.gz → 0.2.6__tar.gz

{jarvis_ai_assistant-0.2.5/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.2.6}/PKG-INFO

@@ -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 → jarvis_ai_assistant-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.2.5"
+version = "0.2.6"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "skyfire", email = "skyfireitdiy@hotmail.com" }]

{jarvis_ai_assistant-0.2.5 → jarvis_ai_assistant-0.2.6}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages  # type: ignore
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.2.5",
+    version="0.2.6",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",

{jarvis_ai_assistant-0.2.5 → jarvis_ai_assistant-0.2.6}/src/jarvis/__init__.py

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

{jarvis_ai_assistant-0.2.5 → jarvis_ai_assistant-0.2.6}/src/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_ai_assistant-0.2.5 → jarvis_ai_assistant-0.2.6}/src/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_ai_assistant-0.2.5 → jarvis_ai_assistant-0.2.6}/src/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_ai_assistant-0.2.5 → jarvis_ai_assistant-0.2.6}/src/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_ai_assistant-0.2.6/src/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_ai_assistant-0.2.6/src/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}