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

jarvis/__init__.py

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

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,34 @@ 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 = ""
+        
+        # 检查是否有save_memory工具
+        tool_registry = self.get_tool_registry()
+        has_save_memory = False
+        if tool_registry:
+            tool_names = [tool.name for tool in tool_registry.tools.values()]
+            has_save_memory = "save_memory" in tool_names
+        
+        # 如果有save_memory工具，添加记录关键信息的提示
+        if has_save_memory:
+            memory_tags_prompt = "\n\n💡 提示：在分析任务之前，建议使用 save_memory 工具将关键信息记录下来，便于后续检索和复用。"
+        
+        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 +648,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 +669,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_agent/jarvis.py

@@ -4,7 +4,7 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 
 import typer
 import yaml  # type: ignore
@@ -91,13 +91,19 @@ def _select_task(tasks: Dict[str, str]) -> str:
                 selected_task = tasks[task_names[choice - 1]]
                 PrettyOutput.print(f"将要执行任务:\n {selected_task}", OutputType.INFO)
                 # 询问是否需要补充信息
-                need_additional = user_confirm("需要为此任务添加补充信息吗？", default=False)
+                need_additional = user_confirm(
+                    "需要为此任务添加补充信息吗？", default=False
+                )
                 if need_additional:
                     additional_input = get_multiline_input("请输入补充信息：")
                     if additional_input:
-                        selected_task = f"{selected_task}\n\n补充信息:\n{additional_input}"
+                        selected_task = (
+                            f"{selected_task}\n\n补充信息:\n{additional_input}"
+                        )
                 return selected_task
-            PrettyOutput.print("无效的选择。请选择列表中的一个号码。", OutputType.WARNING)
+            PrettyOutput.print(
+                "无效的选择。请选择列表中的一个号码。", OutputType.WARNING
+            )
 
         except (KeyboardInterrupt, EOFError):
             return ""
@@ -183,6 +189,217 @@ def _get_and_run_task(agent: Agent, task_content: Optional[str] = None) -> None:
     raise typer.Exit(code=0)
 
 
+def _parse_selection(selection_str: str, max_value: int) -> List[int]:
+    """解析用户输入的选择字符串，支持逗号分隔和范围选择
+
+    例如: "1,2,3,4-9,20" -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 20]
+    """
+    selected: set[int] = set()
+    parts = selection_str.split(",")
+
+    for part in parts:
+        part = part.strip()
+        if "-" in part:
+            # 处理范围选择
+            try:
+                start_str, end_str = part.split("-")
+                start_num = int(start_str.strip())
+                end_num = int(end_str.strip())
+                if 1 <= start_num <= max_value and 1 <= end_num <= max_value:
+                    selected.update(range(start_num, end_num + 1))
+            except ValueError:
+                continue
+        else:
+            # 处理单个数字
+            try:
+                num = int(part)
+                if 1 <= num <= max_value:
+                    selected.add(num)
+            except ValueError:
+                continue
+
+    return sorted(list(selected))
+
+
+def _handle_share_methodology(config_file: Optional[str] = None) -> None:
+    """处理方法论分享功能"""
+    from jarvis.jarvis_utils.config import (
+        get_central_methodology_repo,
+        get_methodology_dirs,
+        get_data_dir,
+    )
+    import glob
+    import json
+    import shutil
+
+    # 获取中心方法论仓库配置
+    central_repo = get_central_methodology_repo()
+    if not central_repo:
+        PrettyOutput.print(
+            "错误：未配置中心方法论仓库（JARVIS_CENTRAL_METHODOLOGY_REPO）",
+            OutputType.ERROR,
+        )
+        PrettyOutput.print("请在配置文件中设置中心方法论仓库的Git地址", OutputType.INFO)
+        raise typer.Exit(code=1)
+
+    # 克隆或更新中心方法论仓库
+    central_repo_path = os.path.join(get_data_dir(), "central_methodology_repo")
+    if not os.path.exists(central_repo_path):
+        PrettyOutput.print(f"正在克隆中心方法论仓库...", OutputType.INFO)
+        subprocess.run(["git", "clone", central_repo, central_repo_path], check=True)
+    else:
+        PrettyOutput.print(f"正在更新中心方法论仓库...", OutputType.INFO)
+        subprocess.run(["git", "pull"], cwd=central_repo_path, check=True)
+
+    # 获取中心仓库中已有的方法论
+    existing_methodologies = {}  # 改为字典，存储 problem_type -> content 的映射
+    for filepath in glob.glob(os.path.join(central_repo_path, "*.json")):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                methodology = json.load(f)
+                problem_type = methodology.get("problem_type", "")
+                content = methodology.get("content", "")
+                if problem_type and content:
+                    existing_methodologies[problem_type] = content
+        except Exception:
+            pass
+
+    # 获取所有方法论目录
+    from jarvis.jarvis_utils.methodology import _get_methodology_directory
+
+    methodology_dirs = [_get_methodology_directory()] + get_methodology_dirs()
+
+    # 收集所有方法论文件（排除中心仓库目录和已存在的方法论）
+    all_methodologies = {}
+    methodology_files = []
+    seen_problem_types = set()  # 用于去重
+
+    for directory in set(methodology_dirs):
+        # 跳过中心仓库目录
+        if os.path.abspath(directory) == os.path.abspath(central_repo_path):
+            continue
+
+        if not os.path.isdir(directory):
+            continue
+
+        for filepath in glob.glob(os.path.join(directory, "*.json")):
+            try:
+                with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                    methodology = json.load(f)
+                    problem_type = methodology.get("problem_type", "")
+                    content = methodology.get("content", "")
+                    # 基于内容判断是否已存在于中心仓库
+                    is_duplicate = False
+                    if problem_type in existing_methodologies:
+                        # 如果problem_type相同，比较内容
+                        if (
+                            content.strip()
+                            == existing_methodologies[problem_type].strip()
+                        ):
+                            is_duplicate = True
+
+                    # 排除已存在于中心仓库的方法论（基于内容），以及本地重复的方法论
+                    if (
+                        problem_type
+                        and content
+                        and not is_duplicate
+                        and problem_type not in seen_problem_types
+                    ):
+                        methodology_files.append(
+                            {
+                                "path": filepath,
+                                "problem_type": problem_type,
+                                "directory": directory,
+                            }
+                        )
+                        all_methodologies[problem_type] = methodology
+                        seen_problem_types.add(problem_type)
+            except Exception:
+                pass
+
+    if not methodology_files:
+        PrettyOutput.print(
+            "没有找到新的方法论文件（所有方法论可能已存在于中心仓库）",
+            OutputType.WARNING,
+        )
+        raise typer.Exit(code=0)
+
+    # 显示可选的方法论
+    methodology_list = ["\n可分享的方法论（已排除中心仓库中已有的）："]
+    for i, meth in enumerate(methodology_files, 1):
+        dir_name = os.path.basename(meth["directory"])
+        methodology_list.append(f"[{i}] {meth['problem_type']} (来自: {dir_name})")
+
+    # 一次性打印所有方法论
+    PrettyOutput.print("\n".join(methodology_list), OutputType.INFO)
+
+    # 让用户选择要分享的方法论
+    while True:
+        try:
+            choice_str = prompt(
+                "\n请选择要分享的方法论编号（支持格式: 1,2,3,4-9,20 或 all）："
+            ).strip()
+            if choice_str == "0":
+                raise typer.Exit(code=0)
+
+            selected_methodologies = []
+            if choice_str.lower() == "all":
+                selected_methodologies = methodology_files
+            else:
+                selected_indices = _parse_selection(choice_str, len(methodology_files))
+                if not selected_indices:
+                    PrettyOutput.print("无效的选择", OutputType.WARNING)
+                    continue
+                selected_methodologies = [
+                    methodology_files[i - 1] for i in selected_indices
+                ]
+
+            # 确认操作
+            share_list = ["\n将要分享以下方法论到中心仓库："]
+            for meth in selected_methodologies:
+                share_list.append(f"- {meth['problem_type']}")
+            PrettyOutput.print("\n".join(share_list), OutputType.INFO)
+
+            if not user_confirm("确认分享这些方法论吗？"):
+                continue
+
+            # 复制选中的方法论到中心仓库
+            copied_list = []
+            for meth in selected_methodologies:
+                src_file = meth["path"]
+                dst_file = os.path.join(central_repo_path, os.path.basename(src_file))
+                shutil.copy2(src_file, dst_file)
+                copied_list.append(f"已复制: {meth['problem_type']}")
+
+            # 一次性显示所有复制结果
+            if copied_list:
+                PrettyOutput.print("\n".join(copied_list), OutputType.SUCCESS)
+
+            # 提交并推送更改
+            PrettyOutput.print("\n正在提交更改...", OutputType.INFO)
+            subprocess.run(["git", "add", "."], cwd=central_repo_path, check=True)
+
+            commit_msg = f"Add {len(selected_methodologies)} methodology(ies) from local collection"
+            subprocess.run(
+                ["git", "commit", "-m", commit_msg], cwd=central_repo_path, check=True
+            )
+
+            PrettyOutput.print("正在推送到远程仓库...", OutputType.INFO)
+            subprocess.run(["git", "push"], cwd=central_repo_path, check=True)
+
+            PrettyOutput.print("\n方法论已成功分享到中心仓库！", OutputType.SUCCESS)
+            break
+
+        except ValueError:
+            PrettyOutput.print("请输入有效的数字", OutputType.WARNING)
+        except subprocess.CalledProcessError as e:
+            PrettyOutput.print(f"Git操作失败: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+        except Exception as e:
+            PrettyOutput.print(f"分享方法论时出错: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+
+
 @app.callback(invoke_without_command=True)
 def run_cli(
     ctx: typer.Context,
@@ -191,17 +408,24 @@ def run_cli(
         "--llm_type",
         help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式）",
     ),
-    task: Optional[str] = typer.Option(None, "-t", "--task", help="从命令行直接输入任务内容"),
+    task: Optional[str] = typer.Option(
+        None, "-t", "--task", help="从命令行直接输入任务内容"
+    ),
     model_group: Optional[str] = typer.Option(
         None, "--llm_group", help="使用的模型组，覆盖配置文件中的设置"
     ),
-    config_file: Optional[str] = typer.Option(None, "-f", "--config", help="自定义配置文件路径"),
+    config_file: Optional[str] = typer.Option(
+        None, "-f", "--config", help="自定义配置文件路径"
+    ),
     restore_session: bool = typer.Option(
         False,
         "--restore-session",
         help="从 .jarvis/saved_session.json 恢复会话",
     ),
     edit: bool = typer.Option(False, "-e", "--edit", help="编辑配置文件"),
+    share_methodology: bool = typer.Option(
+        False, "--share-methodology", help="分享本地方法论到中心方法论仓库"
+    ),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -209,7 +433,15 @@ def run_cli(
 
     _handle_edit_mode(edit, config_file)
 
-    init_env("欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file)
+    # 处理方法论分享
+    if share_methodology:
+        init_env("", config_file=config_file)  # 初始化配置但不显示欢迎信息
+        _handle_share_methodology(config_file)
+        raise typer.Exit(code=0)
+
+    init_env(
+        "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file
+    )
 
     try:
         agent = _initialize_agent(llm_type, model_group, restore_session)

jarvis/jarvis_code_agent/code_agent.py

@@ -65,6 +65,9 @@ class CodeAgent:
                 "ask_user",
                 "read_code",
                 "rewrite_file",
+                "save_memory",
+                "retrieve_memory",
+                "clear_memory",
             ]
         )
         code_system_prompt = """
@@ -269,7 +272,7 @@ class CodeAgent:
             return
 
         PrettyOutput.print(
-            "⚠️ 即将修改git换行符敏感设置，这会影响所有文件的换行符处理方式",
+            "⚠️ 正在修改git换行符敏感设置，这会影响所有文件的换行符处理方式",
             OutputType.WARNING,
         )
         print("将进行以下设置：")
@@ -277,18 +280,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_data/config_schema.json

@@ -225,6 +225,11 @@
       },
       "default": []
     },
+    "JARVIS_CENTRAL_METHODOLOGY_REPO": {
+      "type": "string",
+      "description": "中心方法论Git仓库地址，该仓库会自动添加到方法论加载路径中",
+      "default": ""
+    },
     "JARVIS_PRINT_PROMPT": {
       "type": "boolean",
       "description": "是否打印提示",

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_stats/storage.py

@@ -245,7 +245,7 @@ class StatsStorage:
         metrics_from_meta = set(meta.get("metrics", {}).keys())
         
         # 扫描所有数据文件获取实际存在的指标
-        metrics_from_data = set()
+        metrics_from_data: set[str] = set()
         for data_file in self.data_dir.glob("stats_*.json"):
             try:
                 data = self._load_json(data_file)
@@ -285,7 +285,7 @@ class StatsStorage:
             return {}
 
         # 聚合数据
-        aggregated = defaultdict(
+        aggregated: Dict[str, Dict[str, Any]] = defaultdict(
             lambda: {
                 "count": 0,
                 "sum": 0,