jarvis-ai-assistant 0.2.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

jarvis/jarvis_agent/memory_manager.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+"""
+记忆管理器模块
+负责处理Agent的记忆保存和检索功能
+"""
+from typing import Optional, Dict, List, Any
+
+from jarvis.jarvis_utils.globals import get_all_memory_tags
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class MemoryManager:
+    """记忆管理器，负责处理记忆相关的功能"""
+
+    def __init__(self, agent):
+        """
+        初始化记忆管理器
+
+        参数:
+            agent: Agent实例
+        """
+        self.agent = agent
+
+    def prepare_memory_tags_prompt(self) -> str:
+        """准备记忆标签提示"""
+        memory_tags = get_all_memory_tags()
+        memory_tags_prompt = ""
+
+        # 检查是否有save_memory工具
+        if self._has_save_memory_tool():
+            memory_tags_prompt = "\n\n💡 提示：在分析任务之前，建议使用 save_memory 工具将关键信息记录下来，便于后续检索和复用。"
+
+        # 构建记忆标签列表
+        if any(tags for tags in memory_tags.values()):
+            memory_tags_prompt += self._format_memory_tags(memory_tags)
+
+        return memory_tags_prompt
+
+    def _has_save_memory_tool(self) -> bool:
+        """检查是否有save_memory工具"""
+        tool_registry = self.agent.get_tool_registry()
+        if tool_registry:
+            tool_names = [tool.name for tool in tool_registry.tools.values()]
+            return "save_memory" in tool_names
+        return False
+
+    def _format_memory_tags(self, memory_tags: dict) -> str:
+        """格式化记忆标签"""
+        prompt = (
+            "\n\n系统中存在以下记忆标签，你可以使用 retrieve_memory 工具检索相关记忆："
+        )
+
+        type_names = {
+            "short_term": "短期记忆",
+            "project_long_term": "项目长期记忆",
+            "global_long_term": "全局长期记忆",
+        }
+
+        for memory_type, tags in memory_tags.items():
+            if tags:
+                type_name = type_names.get(memory_type, memory_type)
+                prompt += f"\n- {type_name}: {', '.join(tags)}"
+
+        return prompt
+
+    def prompt_memory_save(self):
+        """让大模型自动判断并保存值得记忆的信息"""
+        # 检查是否有记忆相关工具
+        tool_registry = self.agent.get_tool_registry()
+        if not tool_registry:
+            return
+
+        tool_names = [tool.name for tool in tool_registry.tools.values()]
+        if "save_memory" not in tool_names:
+            return
+
+        print("🔍 正在分析是否有值得记忆的信息...")
+
+        # 构建提示词，让大模型自己判断并保存记忆
+        prompt = """请回顾本次任务的整个过程，判断是否有值得长期记忆或项目记忆的信息。
+
+如果有以下类型的信息，请使用 save_memory 工具保存：
+1. 解决问题的新方法或技巧（适合保存为 global_long_term）
+2. 项目相关的重要发现或配置（适合保存为 project_long_term）
+3. 用户的偏好或习惯（适合保存为 global_long_term）
+4. 重要的技术知识或经验（适合保存为 global_long_term）
+5. 项目特定的实现细节或约定（适合保存为 project_long_term）
+
+请分析并保存有价值的信息，选择合适的记忆类型和标签。如果没有值得记忆的信息，请直接说明。"""
+
+        # 处理记忆保存
+        try:
+            response = self.agent.model.chat_until_success(prompt)  # type: ignore
+
+            # 执行工具调用（如果有）
+            need_return, result = self.agent._call_tools(response)
+
+            # 根据响应判断是否保存了记忆
+            if "save_memory" in response:
+                print("✅ 已自动保存有价值的信息到记忆系统")
+            else:
+                print("📝 本次任务没有特别需要记忆的信息")
+
+        except Exception as e:
+            print(f"❌ 记忆分析失败: {str(e)}")
+
+    def add_memory_prompts_to_addon(self, addon_prompt: str, tool_registry) -> str:
+        """在附加提示中添加记忆相关提示"""
+        memory_prompts = ""
+
+        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工具检索相关记忆"
+
+        return memory_prompts

jarvis/jarvis_agent/methodology_share_manager.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+"""方法论分享管理模块"""
+import os
+import glob
+import json
+import shutil
+from typing import List, Dict, Any
+
+import typer
+
+from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_agent.share_manager import ShareManager
+from jarvis.jarvis_utils.config import (
+    get_central_methodology_repo,
+    get_methodology_dirs,
+)
+
+
+class MethodologyShareManager(ShareManager):
+    """方法论分享管理器"""
+
+    def __init__(self):
+        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)
+
+        super().__init__(central_repo, "central_methodology_repo")
+
+    def get_resource_type(self) -> str:
+        """获取资源类型名称"""
+        return "方法论"
+
+    def format_resource_display(self, resource: Dict[str, Any]) -> str:
+        """格式化资源显示"""
+        dir_name = os.path.basename(resource["directory"])
+        return f"{resource['problem_type']} (来自: {dir_name})"
+
+    def get_existing_resources(self) -> Dict[str, str]:
+        """获取中心仓库中已有的方法论"""
+        existing_methodologies = {}  # 存储 problem_type -> content 的映射
+        for filepath in glob.glob(os.path.join(self.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
+        return existing_methodologies
+
+    def get_local_resources(self) -> List[Dict[str, Any]]:
+        """获取本地方法论"""
+        # 获取中心仓库中已有的方法论
+        existing_methodologies = self.get_existing_resources()
+
+        # 获取所有方法论目录
+        from jarvis.jarvis_utils.methodology import _get_methodology_directory
+
+        methodology_dirs = [_get_methodology_directory()] + get_methodology_dirs()
+
+        # 收集所有方法论文件（排除中心仓库目录和已存在的方法论）
+        methodology_files = []
+        seen_problem_types = set()  # 用于去重
+
+        for directory in set(methodology_dirs):
+            # 跳过中心仓库目录
+            if os.path.abspath(directory) == os.path.abspath(self.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,
+                                    "methodology": methodology,
+                                }
+                            )
+                            seen_problem_types.add(problem_type)
+                except Exception:
+                    pass
+
+        return methodology_files
+
+    def share_resources(self, resources: List[Dict[str, Any]]) -> List[str]:
+        """分享方法论到中心仓库"""
+        # 确认操作
+        share_list = ["\n将要分享以下方法论到中心仓库："]
+        for meth in resources:
+            share_list.append(f"- {meth['problem_type']}")
+        PrettyOutput.print("\n".join(share_list), OutputType.INFO)
+
+        if not user_confirm("确认分享这些方法论吗？"):
+            return []
+
+        # 复制选中的方法论到中心仓库
+        copied_list = []
+        for meth in resources:
+            src_file = meth["path"]
+            dst_file = os.path.join(self.repo_path, os.path.basename(src_file))
+            shutil.copy2(src_file, dst_file)
+            copied_list.append(f"已复制: {meth['problem_type']}")
+
+        return copied_list
+
+    def run(self) -> None:
+        """执行方法论分享流程"""
+        try:
+            # 更新中心仓库
+            self.update_central_repo()
+
+            # 获取本地资源
+            local_resources = self.get_local_resources()
+            if not local_resources:
+                PrettyOutput.print(
+                    "没有找到新的方法论文件（所有方法论可能已存在于中心仓库）",
+                    OutputType.WARNING,
+                )
+                raise typer.Exit(code=0)
+
+            # 选择要分享的资源
+            selected_resources = self.select_resources(local_resources)
+            if not selected_resources:
+                raise typer.Exit(code=0)
+
+            # 分享资源
+            copied_list = self.share_resources(selected_resources)
+            if copied_list:
+                # 一次性显示所有复制结果
+                PrettyOutput.print("\n".join(copied_list), OutputType.SUCCESS)
+
+                # 提交并推送
+                self.commit_and_push(len(selected_resources))
+
+                PrettyOutput.print("\n方法论已成功分享到中心仓库！", OutputType.SUCCESS)
+
+        except Exception as e:
+            PrettyOutput.print(f"分享方法论时出错: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)

jarvis/jarvis_agent/prompts.py

@@ -43,13 +43,28 @@ SUMMARY_REQUEST_PROMPT = """<summary_request>
 
 TASK_ANALYSIS_PROMPT = f"""<task_analysis>
 <request>
-当前任务已结束，请分析该任务的解决方案：
-1. 首先检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
+当前任务已结束，请按以下步骤分析该任务：
+
+第一步：记忆值得保存的信息
+1. 识别任务中的关键信息和知识点
+2. 评估是否有值得保存的项目长期记忆或全局长期记忆
+3. 使用 save_memory 工具保存有价值的信息：
+   - project_long_term: 保存与当前项目相关的长期信息（如项目配置、架构决策、开发规范等）
+   - global_long_term: 保存通用的信息、用户偏好、知识或方法（如技术知识、最佳实践、用户习惯等）
+
+第二步：分析任务解决方案
+1. 检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
 2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
 3. 如果可以通过工具解决，请设计并提供工具代码
 4. 如果无法通过编写通用工具完成，评估当前的执行流程是否可以总结为通用方法论
 5. 如果以上都不可行，给出详细理由
-请根据分析结果采取相应行动：说明现有工具/方法论、创建新工具、生成新方法论或说明原因。
+
+请根据分析结果采取相应行动。
+
+重要提示：每次只能执行一个操作！
+- 如果有记忆需要保存，可以调用一次 save_memory 批量保存多条记忆
+- 保存完所有记忆后，再进行工具/方法论的创建或说明
+- 不要在一次响应中同时调用多个工具（如同时保存记忆和创建工具/方法论）
 </request>
 <evaluation_criteria>
 现有资源评估:

jarvis/jarvis_agent/share_manager.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+"""分享管理模块，负责工具和方法论的分享功能"""
+import os
+import subprocess
+from typing import List, Dict, Any
+from abc import ABC, abstractmethod
+
+from prompt_toolkit import prompt
+
+from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_utils.config import get_data_dir
+
+
+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))
+
+
+class ShareManager(ABC):
+    """分享管理器基类"""
+
+    def __init__(self, central_repo_url: str, repo_name: str):
+        self.central_repo_url = central_repo_url
+        self.repo_name = repo_name
+        self.repo_path = os.path.join(get_data_dir(), repo_name)
+
+    def update_central_repo(self) -> None:
+        """克隆或更新中心仓库"""
+        if not os.path.exists(self.repo_path):
+            PrettyOutput.print(
+                f"正在克隆中心{self.get_resource_type()}仓库...", OutputType.INFO
+            )
+            subprocess.run(
+                ["git", "clone", self.central_repo_url, self.repo_path], check=True
+            )
+        else:
+            PrettyOutput.print(
+                f"正在更新中心{self.get_resource_type()}仓库...", OutputType.INFO
+            )
+            # 检查是否是空仓库
+            try:
+                # 先尝试获取远程分支信息
+                result = subprocess.run(
+                    ["git", "ls-remote", "--heads", "origin"],
+                    cwd=self.repo_path,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                # 如果有远程分支，执行pull
+                if result.stdout.strip():
+                    subprocess.run(["git", "pull"], cwd=self.repo_path, check=True)
+                else:
+                    PrettyOutput.print(
+                        f"中心{self.get_resource_type()}仓库是空的，将初始化为新仓库",
+                        OutputType.INFO,
+                    )
+            except subprocess.CalledProcessError:
+                # 如果命令失败，可能是网络问题或其他错误
+                PrettyOutput.print("无法连接到远程仓库，将跳过更新", OutputType.WARNING)
+
+    def commit_and_push(self, count: int) -> None:
+        """提交并推送更改"""
+        PrettyOutput.print("\n正在提交更改...", OutputType.INFO)
+        subprocess.run(["git", "add", "."], cwd=self.repo_path, check=True)
+
+        commit_msg = f"Add {count} {self.get_resource_type()}(s) from local collection"
+        subprocess.run(
+            ["git", "commit", "-m", commit_msg], cwd=self.repo_path, check=True
+        )
+
+        PrettyOutput.print("正在推送到远程仓库...", OutputType.INFO)
+        # 检查是否需要设置上游分支（空仓库的情况）
+        try:
+            # 先尝试普通推送
+            subprocess.run(["git", "push"], cwd=self.repo_path, check=True)
+        except subprocess.CalledProcessError:
+            # 如果失败，可能是空仓库，尝试设置上游分支
+            try:
+                subprocess.run(
+                    ["git", "push", "-u", "origin", "main"],
+                    cwd=self.repo_path,
+                    check=True,
+                )
+            except subprocess.CalledProcessError:
+                # 如果main分支不存在，尝试master分支
+                subprocess.run(
+                    ["git", "push", "-u", "origin", "master"],
+                    cwd=self.repo_path,
+                    check=True,
+                )
+
+    def select_resources(self, resources: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """让用户选择要分享的资源"""
+        # 显示可选的资源
+        resource_list = [
+            f"\n可分享的{self.get_resource_type()}（已排除中心仓库中已有的）："
+        ]
+        for i, resource in enumerate(resources, 1):
+            resource_list.append(f"[{i}] {self.format_resource_display(resource)}")
+
+        # 一次性打印所有资源
+        PrettyOutput.print("\n".join(resource_list), OutputType.INFO)
+
+        # 让用户选择
+        while True:
+            try:
+                choice_str = prompt(
+                    f"\n请选择要分享的{self.get_resource_type()}编号（支持格式: 1,2,3,4-9,20 或 all）："
+                ).strip()
+                if choice_str == "0":
+                    return []
+
+                if choice_str.lower() == "all":
+                    return resources
+                else:
+                    selected_indices = parse_selection(choice_str, len(resources))
+                    if not selected_indices:
+                        PrettyOutput.print("无效的选择", OutputType.WARNING)
+                        continue
+                    return [resources[i - 1] for i in selected_indices]
+
+            except ValueError:
+                PrettyOutput.print("请输入有效的数字", OutputType.WARNING)
+
+    @abstractmethod
+    def get_resource_type(self) -> str:
+        """获取资源类型名称"""
+        pass
+
+    @abstractmethod
+    def format_resource_display(self, resource: Dict[str, Any]) -> str:
+        """格式化资源显示"""
+        pass
+
+    @abstractmethod
+    def get_existing_resources(self) -> Any:
+        """获取中心仓库中已有的资源"""
+        pass
+
+    @abstractmethod
+    def get_local_resources(self) -> List[Dict[str, Any]]:
+        """获取本地资源"""
+        pass
+
+    @abstractmethod
+    def share_resources(self, resources: List[Dict[str, Any]]) -> List[str]:
+        """分享资源到中心仓库"""
+        pass

jarvis/jarvis_agent/task_analyzer.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+"""
+任务分析器模块
+负责处理任务分析和方法论生成功能
+"""
+from typing import Optional
+
+from jarvis.jarvis_utils.globals import get_interrupt, set_interrupt
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_agent.prompts import TASK_ANALYSIS_PROMPT
+
+
+class TaskAnalyzer:
+    """任务分析器，负责任务分析和满意度反馈处理"""
+
+    def __init__(self, agent):
+        """
+        初始化任务分析器
+
+        参数:
+            agent: Agent实例
+        """
+        self.agent = agent
+
+    def analysis_task(self, satisfaction_feedback: str = ""):
+        """分析任务并生成方法论"""
+        print("🔍 正在分析任务...")
+        try:
+            # 准备分析提示
+            self.agent.session.prompt = self._prepare_analysis_prompt(
+                satisfaction_feedback
+            )
+
+            if not self.agent.model:
+                raise RuntimeError("Model not initialized")
+
+            # 循环处理工具调用，直到没有工具调用为止
+            self._process_analysis_loop()
+
+            print("✅ 分析完成")
+        except Exception as e:
+            print("❌ 分析失败")
+
+    def _prepare_analysis_prompt(self, satisfaction_feedback: str) -> str:
+        """准备分析提示"""
+        analysis_prompt = TASK_ANALYSIS_PROMPT
+        if satisfaction_feedback:
+            analysis_prompt += satisfaction_feedback
+        return analysis_prompt
+
+    def _process_analysis_loop(self):
+        """处理分析循环"""
+        while True:
+            response = self.agent.model.chat_until_success(self.agent.session.prompt)  # type: ignore
+            self.agent.session.prompt = ""
+
+            # 处理用户中断
+            if get_interrupt():
+                if not self._handle_analysis_interrupt(response):
+                    break
+
+            # 执行工具调用
+            need_return, self.agent.session.prompt = self.agent._call_tools(response)
+
+            # 如果没有工具调用或者没有新的提示，退出循环
+            if not self.agent.session.prompt:
+                break
+
+    def _handle_analysis_interrupt(self, response: str) -> bool:
+        """处理分析过程中的用户中断
+
+        返回:
+            bool: True 继续分析，False 退出分析
+        """
+        set_interrupt(False)
+        user_input = self.agent.multiline_inputer(
+            f"分析任务期间被中断，请输入用户干预信息："
+        )
+
+        if not user_input:
+            # 用户输入为空，退出分析
+            return False
+
+        if self._has_tool_calls(response):
+            self.agent.session.prompt = self._handle_interrupt_with_tool_calls(
+                user_input
+            )
+        else:
+            self.agent.session.prompt = f"被用户中断，用户补充信息为：{user_input}"
+
+        return True
+
+    def _has_tool_calls(self, response: str) -> bool:
+        """检查响应中是否有工具调用"""
+        return any(
+            handler.can_handle(response) for handler in self.agent.output_handler
+        )
+
+    def _handle_interrupt_with_tool_calls(self, user_input: str) -> str:
+        """处理有工具调用时的中断"""
+        if user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
+            return f"被用户中断，用户补充信息为：{user_input}\n\n用户同意继续工具调用。"
+        else:
+            return f"被用户中断，用户补充信息为：{user_input}\n\n检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。"
+
+    def collect_satisfaction_feedback(self, auto_completed: bool) -> str:
+        """收集满意度反馈"""
+        satisfaction_feedback = ""
+
+        if not auto_completed and self.agent.use_analysis:
+            if user_confirm("您对本次任务的完成是否满意？", True):
+                satisfaction_feedback = "\n\n用户对本次任务的完成表示满意。"
+            else:
+                feedback = self.agent.multiline_inputer(
+                    "请提供您的反馈意见（可留空直接回车）:"
+                )
+                if feedback:
+                    satisfaction_feedback = (
+                        f"\n\n用户对本次任务的完成不满意，反馈意见如下：\n{feedback}"
+                    )
+                else:
+                    satisfaction_feedback = (
+                        "\n\n用户对本次任务的完成不满意，未提供具体反馈意见。"
+                    )
+
+        return satisfaction_feedback