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

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

jarvis/jarvis_agent/task_manager.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+"""任务管理模块，负责加载和选择预定义任务"""
+import os
+from typing import Dict
+
+import yaml
+from prompt_toolkit import prompt
+
+from jarvis.jarvis_agent import (
+    OutputType,
+    PrettyOutput,
+    get_multiline_input,
+    user_confirm,
+)
+from jarvis.jarvis_utils.config import get_data_dir
+
+
+class TaskManager:
+    """任务管理器，负责预定义任务的加载和选择"""
+
+    @staticmethod
+    def load_tasks() -> Dict[str, str]:
+        """Load tasks from .jarvis files in user home and current directory."""
+        tasks: Dict[str, str] = {}
+
+        # Check pre-command in data directory
+        data_dir = get_data_dir()
+        pre_command_path = os.path.join(data_dir, "pre-command")
+        if os.path.exists(pre_command_path):
+            print(f"🔍 从{pre_command_path}加载预定义任务...")
+            try:
+                with open(
+                    pre_command_path, "r", encoding="utf-8", errors="ignore"
+                ) as f:
+                    user_tasks = yaml.safe_load(f)
+                if isinstance(user_tasks, dict):
+                    for name, desc in user_tasks.items():
+                        if desc:
+                            tasks[str(name)] = str(desc)
+                print(f"✅ 预定义任务加载完成 {pre_command_path}")
+            except (yaml.YAMLError, OSError):
+                print(f"❌ 预定义任务加载失败 {pre_command_path}")
+
+        # Check .jarvis/pre-command in current directory
+        pre_command_path = ".jarvis/pre-command"
+        if os.path.exists(pre_command_path):
+            abs_path = os.path.abspath(pre_command_path)
+            print(f"🔍 从{abs_path}加载预定义任务...")
+            try:
+                with open(
+                    pre_command_path, "r", encoding="utf-8", errors="ignore"
+                ) as f:
+                    local_tasks = yaml.safe_load(f)
+                if isinstance(local_tasks, dict):
+                    for name, desc in local_tasks.items():
+                        if desc:
+                            tasks[str(name)] = str(desc)
+                print(f"✅ 预定义任务加载完成 {pre_command_path}")
+            except (yaml.YAMLError, OSError):
+                print(f"❌ 预定义任务加载失败 {pre_command_path}")
+
+        return tasks
+
+    @staticmethod
+    def select_task(tasks: Dict[str, str]) -> str:
+        """Let user select a task from the list or skip. Returns task description if selected."""
+        if not tasks:
+            return ""
+
+        task_names = list(tasks.keys())
+        task_list = ["可用任务:"]
+        for i, name in enumerate(task_names, 1):
+            task_list.append(f"[{i}] {name}")
+        task_list.append("[0] 跳过预定义任务")
+        PrettyOutput.print("\n".join(task_list), OutputType.INFO)
+
+        while True:
+            try:
+                choice_str = prompt(
+                    "\n请选择一个任务编号（0 跳过预定义任务）："
+                ).strip()
+                if not choice_str:
+                    return ""
+
+                choice = int(choice_str)
+                if choice == 0:
+                    return ""
+                if 1 <= choice <= len(task_names):
+                    selected_task = tasks[task_names[choice - 1]]
+                    PrettyOutput.print(
+                        f"将要执行任务:\n {selected_task}", OutputType.INFO
+                    )
+                    # 询问是否需要补充信息
+                    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}"
+                            )
+                    return selected_task
+                PrettyOutput.print(
+                    "无效的选择。请选择列表中的一个号码。", OutputType.WARNING
+                )
+
+            except (KeyboardInterrupt, EOFError):
+                return ""
+            except ValueError as val_err:
+                PrettyOutput.print(f"选择任务失败: {str(val_err)}", OutputType.ERROR)