jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_agent/main.py

@@ -1,13 +1,17 @@
 # -*- coding: utf-8 -*-
-import argparse
 import os
+from typing import Optional
 
-import yaml
+import typer
+import yaml  # type: ignore[import-untyped]
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.config import set_config
+
+app = typer.Typer(help="Jarvis AI 助手")
 
 
 def load_config(config_path: str) -> dict:
@@ -20,7 +24,9 @@ def load_config(config_path: str) -> dict:
         dict: 配置字典
     """
     if not os.path.exists(config_path):
-        PrettyOutput.print(f"配置文件 {config_path} 不存在，使用默认配置", OutputType.WARNING)
+        PrettyOutput.print(
+            f"配置文件 {config_path} 不存在，使用默认配置", OutputType.WARNING
+        )
         return {}
 
     with open(config_path, "r", encoding="utf-8", errors="ignore") as f:
@@ -32,63 +38,101 @@ def load_config(config_path: str) -> dict:
             return {}
 
 
-def main():
+@app.command()
+def cli(
+    config_file: Optional[str] = typer.Option(
+        None, "-f", "--config", help="代理配置文件路径"
+    ),
+    agent_definition: Optional[str] = typer.Option(
+        None, "-c", "--agent-definition", help="代理定义文件路径"
+    ),
+    task: Optional[str] = typer.Option(None, "-T", "--task", help="初始任务内容"),
+    
+    model_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
+    non_interactive: bool = typer.Option(
+        False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
+    ),
+):
     """Main entry point for Jarvis agent"""
-    # Set up argument parser
-    parser = argparse.ArgumentParser(description="Jarvis AI assistant")
-    parser.add_argument(
-        "-f", "--config", type=str, required=False, help="Path to agent config file"
-    )
-    parser.add_argument(
-        "-c", "--agent_definition", type=str, help="Path to agent definition file"
-    )
-    parser.add_argument("-t", "--task", type=str, help="Initial task to execute")
-    parser.add_argument(
-        "--llm_type",
-        type=str,
-        default="normal",
-        choices=["normal", "thinking"],
-        help="LLM type to use, overriding config",
+    # CLI 标志：非交互模式（不依赖配置文件）
+    if non_interactive:
+        try:
+            os.environ["JARVIS_NON_INTERACTIVE"] = "true"
+        except Exception:
+            pass
+        try:
+            set_config("JARVIS_NON_INTERACTIVE", True)
+        except Exception:
+            pass
+    # 非交互模式要求从命令行传入任务
+    if non_interactive and not (task and str(task).strip()):
+        PrettyOutput.print(
+            "非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。",
+            OutputType.ERROR,
+        )
+        raise typer.Exit(code=2)
+    # Initialize环境
+    init_env(
+        "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file
     )
-    args = parser.parse_args()
-
-    # Initialize environment
-    init_env("欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=args.config)
+    # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
+    try:
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
+        if non_interactive:
+            set_config("JARVIS_NON_INTERACTIVE", True)
+    except Exception:
+        # 静默忽略同步异常，不影响主流程
+        pass
 
     # Load configuration
-    config = load_config(args.agent_definition) if args.agent_definition else {}
+    config = load_config(agent_definition) if agent_definition else {}
 
     # Override config with command-line arguments if provided
-    if args.llm_type:
-        config["llm_type"] = args.llm_type
+
+    if model_group:
+        config["model_group"] = model_group
 
     # Create and run agent
     try:
         agent = Agent(**config)
 
         # Run agent with initial task if specified
-        if args.task:
-            PrettyOutput.print(f"执行初始任务: {args.task}", OutputType.INFO)
-            agent.run(args.task)
-            return 0
+        if task:
+            PrettyOutput.print(f"执行初始任务: {task}", OutputType.INFO)
+            agent.run(task)
+            return
 
         try:
             user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
             if not user_input:
-                return 0
+                return
             agent.set_addon_prompt(
                 "如果有必要，请先指定出行动计划，然后根据计划一步步执行，如果任务过于复杂，可以拆分子Agent进行执行，拆的子Agent需要掌握所有必要的任务信息，否则无法执行"
             )
             agent.run(user_input)
+        except KeyboardInterrupt:
+            # 用户主动取消输入，正常退出
+            return
+        except typer.Exit:
+            # 来自输入流程的正常退出
+            return
         except Exception as e:
             PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
 
+    except typer.Exit:
+        return
     except Exception as e:
         PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
-        return 1
+        raise typer.Exit(code=1)
+
 
-    return 0
+def main() -> None:
+    """Application entry point."""
+    app()
 
 
 if __name__ == "__main__":
-    exit(main())
+    main()

jarvis/jarvis_agent/memory_manager.py

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+"""
+记忆管理器模块
+负责处理Agent的记忆保存和检索功能
+"""
+
+from jarvis.jarvis_utils.globals import get_all_memory_tags
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_agent.events import TASK_STARTED, BEFORE_HISTORY_CLEAR, TASK_COMPLETED
+
+
+class MemoryManager:
+    """记忆管理器，负责处理记忆相关的功能"""
+
+    def __init__(self, agent):
+        """
+        初始化记忆管理器
+
+        参数:
+            agent: Agent实例
+        """
+        self.agent = agent
+        # 本轮任务是否已进行过记忆保存提示/处理的标记，用于事件去重
+        self._memory_prompted = False
+        # 订阅 Agent 事件（旁路集成，失败不影响主流程）
+        try:
+            self._subscribe_events()
+        except Exception:
+            pass
+
+    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
+
+        # 构建提示词，让大模型自己判断并保存记忆
+        prompt = """请回顾本次任务的整个过程，判断是否有值得长期记忆或项目记忆的信息。
+
+如果有以下类型的信息，请使用 save_memory 工具保存：
+1. 解决问题的新方法或技巧（适合保存为 global_long_term）
+2. 项目相关的重要发现或配置（适合保存为 project_long_term）
+3. 用户的偏好或习惯（适合保存为 global_long_term）
+4. 重要的技术知识或经验（适合保存为 global_long_term）
+5. 项目特定的实现细节或约定（适合保存为 project_long_term）
+
+请分析并保存有价值的信息，选择合适的记忆类型和标签。如果没有值得记忆的信息，请直接说明。"""
+
+        # 处理记忆保存
+        try:
+            # 清空本轮执行标记，便于准确判断是否调用了 save_memory
+            try:
+                self.agent.set_user_data("__last_executed_tool__", "")
+                self.agent.set_user_data("__executed_tools__", [])
+            except Exception:
+                pass
+
+            response = self.agent.model.chat_until_success(prompt)  # type: ignore
+
+            # 执行工具调用（如果有）
+            need_return, result = self.agent._call_tools(response)
+
+            # 根据实际执行的工具判断是否保存了记忆
+            saved = False
+            try:
+                last_tool = self.agent.get_user_data("__last_executed_tool__")
+                saved = last_tool == "save_memory"
+            except Exception:
+                saved = False
+
+            if saved:
+                PrettyOutput.print(
+                    "已自动保存有价值的信息到记忆系统", OutputType.SUCCESS
+                )
+            else:
+                PrettyOutput.print("本次任务没有特别需要记忆的信息", OutputType.INFO)
+
+        except Exception as e:
+            PrettyOutput.print(f"记忆分析失败: {str(e)}", OutputType.ERROR)
+        finally:
+            # 设置记忆提示完成标记，避免事件触发造成重复处理
+            self._memory_prompted = True
+            try:
+                self.agent.set_user_data("__memory_save_prompted__", True)
+            except Exception:
+                pass
+
+    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
+
+    # -----------------------
+    # 事件订阅与处理（旁路）
+    # -----------------------
+    def _subscribe_events(self) -> None:
+        bus = self.agent.get_event_bus()  # type: ignore[attr-defined]
+        # 任务开始时重置去重标记
+        bus.subscribe(TASK_STARTED, self._on_task_started)
+        # 在清理历史前尝试保存记忆（若开启强制保存且尚未处理）
+        bus.subscribe(BEFORE_HISTORY_CLEAR, self._ensure_memory_prompt)
+        # 任务完成时作为兜底再尝试一次
+        bus.subscribe(TASK_COMPLETED, self._ensure_memory_prompt)
+
+    def _on_task_started(self, **payload) -> None:
+        self._memory_prompted = False
+        try:
+            self.agent.set_user_data("__memory_save_prompted__", False)
+        except Exception:
+            pass
+
+    def _ensure_memory_prompt(self, **payload) -> None:
+        # 仅在开启强制保存记忆时启用
+        if not getattr(self.agent, "force_save_memory", False):
+            return
+        # 避免在同一任务内重复提示/处理
+        if self._memory_prompted:
+            return
+        try:
+            already = bool(self.agent.get_user_data("__memory_save_prompted__"))
+            if already:
+                self._memory_prompted = True
+                return
+        except Exception:
+            pass
+        # 静默执行保存逻辑，失败不影响主流程
+        try:
+            self.prompt_memory_save()
+        except Exception:
+            # 忽略异常，保持主流程稳定
+            self._memory_prompted = True

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,
+                )
+                return
+
+            # 选择要分享的资源
+            selected_resources = self.select_resources(local_resources)
+            if not selected_resources:
+                return
+
+            # 分享资源
+            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/prompt_manager.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+PromptManager: 统一管理 Agent 的系统提示词与附加提示词的构建逻辑。
+
+设计目标（阶段一，最小变更）：
+- 提供独立的提示构建类，不改变现有行为
+- 先行落地构建逻辑，后续在 Agent 中逐步委派使用
+- 保持与现有工具/记忆系统兼容
+"""
+from typing import TYPE_CHECKING
+
+from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_utils.tag import ot
+
+if TYPE_CHECKING:
+    # 避免运行时循环依赖，仅用于类型标注
+    from . import Agent  # noqa: F401
+
+
+
+class PromptManager:
+    """
+    提示管理器：负责构建系统提示与默认附加提示。
+    注意：该类不直接访问模型，只负责拼装字符串。
+    """
+
+    def __init__(self, agent: "Agent"):
+        self.agent = agent
+
+    # ----------------------------
+    # 系统提示词构建
+    # ----------------------------
+    def build_system_prompt(self) -> str:
+        """
+        构建系统提示词，复用现有的工具使用提示生成逻辑，保持行为一致。
+        """
+        action_prompt = self.agent.get_tool_usage_prompt()
+        return f"""
+{self.agent.system_prompt}
+
+{action_prompt}
+"""
+
+    # ----------------------------
+    # 附加提示词构建
+    # ----------------------------
+    def build_default_addon_prompt(self, need_complete: bool) -> str:
+        """
+        构建默认附加提示词（与 Agent.make_default_addon_prompt 行为保持一致）。
+        仅进行字符串拼装，不操作会话状态。
+        """
+        # 结构化系统指令
+        action_handlers = ", ".join([handler.name() for handler in self.agent.output_handler])
+
+        # 任务完成提示
+        complete_prompt = (
+            f"- 输出{ot('!!!COMPLETE!!!')}"
+            if need_complete and self.agent.auto_complete
+            else ""
+        )
+
+        # 工具与记忆相关提示
+        tool_registry = self.agent.get_tool_registry()
+        memory_prompts = self.agent.memory_manager.add_memory_prompts_to_addon(
+            "", tool_registry if isinstance(tool_registry, ToolRegistry) else None
+        )
+
+        addon_prompt = f"""
+<system_prompt>
+    请判断是否已经完成任务，如果已经完成：
+    - 直接输出完成原因，不需要再有新的操作，不要输出{ot("TOOL_CALL")}标签
+    {complete_prompt}
+    如果没有完成，请进行下一步操作：
+    - 仅包含一个操作
+    - 如果信息不明确，请请求用户补充
+    - 如果执行过程中连续失败5次，请使用ask_user询问用户操作
+    - 操作列表：{action_handlers}{memory_prompts}
+</system_prompt>
+
+请继续。
+"""
+        return addon_prompt