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

jarvis/jarvis_agent/jarvis.py

@@ -1,405 +1,19 @@
 # -*- coding: utf-8 -*-
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from typing import Dict, Optional, List
+"""Jarvis AI 助手主入口模块"""
+from typing import Optional
 
 import typer
-import yaml  # type: ignore
-from prompt_toolkit import prompt  # type: ignore
 
-from jarvis.jarvis_agent import (
-    Agent,
-    OutputType,
-    PrettyOutput,
-    get_multiline_input,
-    origin_agent_system_prompt,
-    user_confirm,
-)
-from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
-from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
-from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_agent import OutputType, PrettyOutput
+from jarvis.jarvis_agent.agent_manager import AgentManager
+from jarvis.jarvis_agent.config_editor import ConfigEditor
+from jarvis.jarvis_agent.methodology_share_manager import MethodologyShareManager
+from jarvis.jarvis_agent.tool_share_manager import ToolShareManager
 from jarvis.jarvis_utils.utils import init_env
 
 app = typer.Typer(help="Jarvis AI 助手")
 
 
-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
-
-
-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)
-
-
-def _handle_edit_mode(edit: bool, config_file: Optional[str]) -> None:
-    """If edit flag is set, open config file in editor and exit."""
-    if not edit:
-        return
-
-    config_file_path = (
-        Path(config_file)
-        if config_file
-        else Path(os.path.expanduser("~/.jarvis/config.yaml"))
-    )
-    # 根据操作系统选择合适的编辑器
-    import platform
-
-    if platform.system() == "Windows":
-        # 优先级：终端工具 -> 代码编辑器 -> 通用文本编辑器
-        editors = ["nvim", "vim", "nano", "code", "notepad++", "notepad"]
-    else:
-        # 优先级：终端工具 -> 代码编辑器 -> 通用文本编辑器
-        editors = ["nvim", "vim", "vi", "nano", "emacs", "code", "gedit", "kate"]
-
-    editor = next((e for e in editors if shutil.which(e)), None)
-
-    if editor:
-        try:
-            subprocess.run([editor, str(config_file_path)], check=True)
-            raise typer.Exit(code=0)
-        except (subprocess.CalledProcessError, FileNotFoundError) as e:
-            PrettyOutput.print(f"Failed to open editor: {e}", OutputType.ERROR)
-            raise typer.Exit(code=1)
-    else:
-        PrettyOutput.print(
-            f"No suitable editor found. Tried: {', '.join(editors)}", OutputType.ERROR
-        )
-        raise typer.Exit(code=1)
-
-
-def _initialize_agent(
-    llm_type: str, model_group: Optional[str], restore_session: bool
-) -> Agent:
-    """Initialize the agent and restore session if requested."""
-    agent = Agent(
-        system_prompt=origin_agent_system_prompt,
-        llm_type=llm_type,
-        model_group=model_group,
-        input_handler=[shell_input_handler, builtin_input_handler],
-        output_handler=[ToolRegistry()],  # type: ignore
-        need_summary=False,
-    )
-
-    # 尝试恢复会话
-    if restore_session:
-        if agent.restore_session():
-            PrettyOutput.print("会话已成功恢复。", OutputType.SUCCESS)
-        else:
-            PrettyOutput.print("无法恢复会话。", OutputType.WARNING)
-    return agent
-
-
-def _get_and_run_task(agent: Agent, task_content: Optional[str] = None) -> None:
-    """Get task from various sources and run it."""
-    # 优先处理命令行直接传入的任务
-    if task_content:
-        agent.run(task_content)
-        raise typer.Exit(code=0)
-
-    if agent.first:
-        tasks = _load_tasks()
-        if tasks and (selected_task := _select_task(tasks)):
-            PrettyOutput.print(f"开始执行任务: \n{selected_task}", OutputType.INFO)
-            agent.run(selected_task)
-            raise typer.Exit(code=0)
-
-    user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
-    if user_input:
-        agent.run(user_input)
-    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,
@@ -414,6 +28,9 @@ def run_cli(
     model_group: Optional[str] = typer.Option(
         None, "--llm_group", help="使用的模型组，覆盖配置文件中的设置"
     ),
+    tool_group: Optional[str] = typer.Option(
+        None, "--tool_group", help="使用的工具组，覆盖配置文件中的设置"
+    ),
     config_file: Optional[str] = typer.Option(
         None, "-f", "--config", help="自定义配置文件路径"
     ),
@@ -426,26 +43,48 @@ def run_cli(
     share_methodology: bool = typer.Option(
         False, "--share-methodology", help="分享本地方法论到中心方法论仓库"
     ),
+    share_tool: bool = typer.Option(
+        False, "--share-tool", help="分享本地工具到中心工具仓库"
+    ),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
         return
 
-    _handle_edit_mode(edit, config_file)
+    # 处理配置文件编辑
+    if edit:
+        ConfigEditor.edit_config(config_file)
+        return
 
     # 处理方法论分享
     if share_methodology:
         init_env("", config_file=config_file)  # 初始化配置但不显示欢迎信息
-        _handle_share_methodology(config_file)
-        raise typer.Exit(code=0)
+        manager = MethodologyShareManager()
+        manager.run()
+        return
 
+    # 处理工具分享
+    if share_tool:
+        init_env("", config_file=config_file)  # 初始化配置但不显示欢迎信息
+        manager = ToolShareManager()
+        manager.run()
+        return
+
+    # 初始化环境
     init_env(
         "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file
     )
 
+    # 运行主流程
     try:
-        agent = _initialize_agent(llm_type, model_group, restore_session)
-        _get_and_run_task(agent, task)
+        agent_manager = AgentManager(
+            llm_type=llm_type,
+            model_group=model_group,
+            tool_group=tool_group,
+            restore_session=restore_session,
+        )
+        agent_manager.initialize()
+        agent_manager.run_task(task)
     except typer.Exit:
         raise
     except Exception as err:  # pylint: disable=broad-except

jarvis/jarvis_agent/memory_manager.py

@@ -0,0 +1,133 @@
+# -*- 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