jarvis-ai-assistant 0.3.26__py3-none-any.whl → 0.3.28__py3-none-any.whl

jarvis/jarvis_agent/agent_manager.py

@@ -25,10 +25,14 @@ class AgentManager:
         model_group: Optional[str] = None,
         tool_group: Optional[str] = None,
         restore_session: bool = False,
+        use_methodology: Optional[bool] = None,
+        use_analysis: Optional[bool] = None,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
         self.restore_session = restore_session
+        self.use_methodology = use_methodology
+        self.use_analysis = use_analysis
         self.agent: Optional[Agent] = None
 
     def initialize(self) -> Agent:
@@ -45,6 +49,8 @@ class AgentManager:
             input_handler=[shell_input_handler, builtin_input_handler],
             output_handler=[ToolRegistry()],  # type: ignore
             need_summary=False,
+            use_methodology=self.use_methodology,
+            use_analysis=self.use_analysis,
         )
 
         # 尝试恢复会话

jarvis/jarvis_agent/config.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""
+AgentConfig: 聚合 Agent 的初始化配置并提供默认值解析。
+
+目标（阶段一，最小变更）：
+- 提供独立的配置承载类，封装 __init__ 中的配置项
+- 支持从全局配置与上下文推导默认值
+- 暂不强制替换 Agent 的现有参数与流程，后续逐步接入
+"""
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from jarvis.jarvis_agent.prompts import DEFAULT_SUMMARY_PROMPT
+from jarvis.jarvis_utils.config import (
+    get_max_token_count,
+    is_execute_tool_confirm,
+    is_force_save_memory,
+    is_use_analysis,
+    is_use_methodology,
+)
+
+
+@dataclass
+class AgentConfig:
+    # 核心身份与系统参数
+    system_prompt: str
+    name: str = "Jarvis"
+    description: str = ""
+    model_group: Optional[str] = None
+
+    # 运行行为
+    auto_complete: bool = False
+    need_summary: bool = True
+
+    # 可选配置（None 表示使用默认策略解析）
+    summary_prompt: Optional[str] = None
+    execute_tool_confirm: Optional[bool] = None
+    use_methodology: Optional[bool] = None
+    use_analysis: Optional[bool] = None
+    force_save_memory: Optional[bool] = None
+    files: Optional[List[str]] = field(default_factory=list)
+    max_token_count: Optional[int] = None
+
+    def resolve_defaults(self) -> "AgentConfig":
+        """
+        解析并填充默认值，返回新的 AgentConfig 实例，不修改原对象。
+        策略与 Agent._init_config 中的逻辑保持一致，确保兼容。
+        """
+        # 复制当前实例的浅拷贝数据
+        cfg = AgentConfig(
+            system_prompt=self.system_prompt,
+            name=self.name,
+            description=self.description,
+            model_group=self.model_group,
+            auto_complete=self.auto_complete,
+            need_summary=self.need_summary,
+            summary_prompt=self.summary_prompt,
+            execute_tool_confirm=self.execute_tool_confirm,
+            use_methodology=self.use_methodology,
+            use_analysis=self.use_analysis,
+            force_save_memory=self.force_save_memory,
+            files=list(self.files or []),
+            max_token_count=self.max_token_count,
+        )
+
+        # use_methodology: 若存在上传文件则禁用；否则按照外部传入或全局默认
+        if cfg.files:
+            cfg.use_methodology = False
+        elif cfg.use_methodology is None:
+            cfg.use_methodology = is_use_methodology()
+
+        # use_analysis
+        if cfg.use_analysis is None:
+            cfg.use_analysis = is_use_analysis()
+
+        # execute_tool_confirm
+        if cfg.execute_tool_confirm is None:
+            cfg.execute_tool_confirm = is_execute_tool_confirm()
+
+        # summary_prompt
+        if cfg.summary_prompt is None:
+            cfg.summary_prompt = DEFAULT_SUMMARY_PROMPT
+
+        # max_token_count
+        if cfg.max_token_count is None:
+            cfg.max_token_count = get_max_token_count(cfg.model_group)
+
+        # force_save_memory
+        if cfg.force_save_memory is None:
+            cfg.force_save_memory = is_force_save_memory()
+
+        return cfg

jarvis/jarvis_agent/config_editor.py

@@ -51,7 +51,7 @@ class ConfigEditor:
                 raise typer.Exit(code=1)
         else:
             PrettyOutput.print(
-                f"No suitable editor found. Please install one of: vim, nano, emacs, code",
+                "No suitable editor found. Please install one of: vim, nano, emacs, code",
                 OutputType.ERROR,
             )
             raise typer.Exit(code=1)

jarvis/jarvis_agent/event_bus.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+"""
+事件总线（EventBus）
+
+目标（阶段一，最小变更）：
+- 提供简单可靠的发布/订阅机制
+- 回调异常隔离，避免影响主流程
+- 不引入额外依赖，便于在 Agent 中渐进集成
+"""
+from collections import defaultdict
+from typing import Callable, DefaultDict, Dict, List
+
+
+
+class EventBus:
+    """
+    简单的同步事件总线。
+    - subscribe(event, callback): 订阅事件
+    - emit(event, **kwargs): 广播事件
+    - unsubscribe(event, callback): 取消订阅
+    """
+
+    def __init__(self) -> None:
+        self._listeners: DefaultDict[str, List[Callable[..., None]]] = defaultdict(list)
+
+    def subscribe(self, event: str, callback: Callable[..., None]) -> None:
+        if not callable(callback):
+            raise TypeError("callback must be callable")
+        self._listeners[event].append(callback)
+
+    def unsubscribe(self, event: str, callback: Callable[..., None]) -> None:
+        if event not in self._listeners:
+            return
+        try:
+            self._listeners[event].remove(callback)
+        except ValueError:
+            pass
+
+    def emit(self, event: str, **payload: Dict) -> None:
+        """
+        广播事件。回调中的异常将被捕获并忽略，以保证主流程稳定。
+        """
+        for cb in list(self._listeners.get(event, [])):
+            try:
+                cb(**payload)
+            except Exception:
+                # 避免回调异常中断主流程
+                continue

jarvis/jarvis_agent/file_methodology_manager.py

@@ -5,7 +5,6 @@
 """
 import os
 import tempfile
-from typing import List, Optional
 
 from jarvis.jarvis_utils.methodology import load_methodology, upload_methodology
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
@@ -46,7 +45,6 @@ class FileMethodologyManager:
             self._load_local_methodology()
         else:
             # 上传成功
-            from jarvis.jarvis_agent.memory_manager import MemoryManager
 
             if self.agent.files:
                 self.agent.session.prompt = f"{self.agent.session.prompt}\n\n上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。"
@@ -75,7 +73,7 @@ class FileMethodologyManager:
 
         from jarvis.jarvis_agent.memory_manager import MemoryManager
 
-        memory_manager = MemoryManager(self.agent)
+        MemoryManager(self.agent)
         methodology = load_methodology(
             msg,
             self.agent.get_tool_registry(),

jarvis/jarvis_agent/jarvis.py

@@ -19,8 +19,8 @@ from jarvis.jarvis_utils.config import (
 )
 import jarvis.jarvis_utils.utils as jutils
 from jarvis.jarvis_utils.input import user_confirm, get_single_line_input
+from jarvis.jarvis_utils.fzf import fzf_select
 import os
-import sys
 import subprocess
 from pathlib import Path
 import yaml  # type: ignore
@@ -403,47 +403,80 @@ def handle_builtin_config_selector(
 
                 Console().print(table)
 
-                choice = get_single_line_input(
-                    "选择要启动的配置编号，直接回车使用默认通用代理(jvs): ", default=""
+                # Try to use fzf for selection if available (include No. to support number-based filtering)
+                fzf_options = [
+                    f"{idx:>3} | {opt['category']:<12} | {opt['name']:<30} | {opt.get('desc', '')}"
+                    for idx, opt in enumerate(options, 1)
+                ]
+                selected_str = fzf_select(
+                    fzf_options, prompt="选择要启动的配置编号 (ESC跳过) > "
                 )
 
-                if choice.strip():
+                choice_index = -1
+                if selected_str:
+                    # Try to parse leading number before first '|'
                     try:
-                        index = int(choice.strip())
-                        if 1 <= index <= len(options):
-                            sel = options[index - 1]
-                            args: list[str] = []
-
-                            if sel["category"] == "agent":
-                                # jarvis-agent 支持 -f/--config（全局配置）与 -c/--agent-definition
-                                args = [str(sel["cmd"]), "-c", str(sel["file"])]
-                                if model_group:
-                                    args += ["-g", str(model_group)]
-                                if config_file:
-                                    args += ["-f", str(config_file)]
-                                if task:
-                                    args += ["--task", str(task)]
-
-                            elif sel["category"] == "multi_agent":
-                                # jarvis-multi-agent 需要 -c/--config，用户输入通过 -i/--input 传递
-                                args = [str(sel["cmd"]), "-c", str(sel["file"])]
-                                if task:
-                                    args += ["-i", str(task)]
-
-                            elif sel["category"] == "roles":
-                                # jarvis-platform-manager role 子命令，支持 -c/-t/-g
-                                args = [str(sel["cmd"]), "role", "-c", str(sel["file"])]
-                                if model_group:
-                                    args += ["-g", str(model_group)]
-
-                            if args:
-                                PrettyOutput.print(
-                                    f"正在启动: {' '.join(args)}", OutputType.INFO
-                                )
-                                os.execvp(args[0], args)
+                        num_part = selected_str.split("|", 1)[0].strip()
+                        selected_index = int(num_part)
+                        if 1 <= selected_index <= len(options):
+                            choice_index = selected_index - 1
+                    except Exception:
+                        # Fallback to equality matching if parsing fails
+                        for i, fzf_opt in enumerate(fzf_options):
+                            if fzf_opt == selected_str:
+                                choice_index = i
+                                break
+                else:
+                    # Fallback to manual input if fzf is not used or available
+                    choice = get_single_line_input(
+                        "选择要启动的配置编号，直接回车使用默认通用代理(jvs): ", default=""
+                    )
+                    if choice.strip():
+                        try:
+                            selected_index = int(choice.strip())
+                            if 1 <= selected_index <= len(options):
+                                choice_index = selected_index - 1
+                        except ValueError:
+                            pass  # Invalid input
+
+                if choice_index != -1:
+                    try:
+                        sel = options[choice_index]
+                        args: list[str] = []
+
+                        if sel["category"] == "agent":
+                            # jarvis-agent 支持 -f/--config（全局配置）与 -c/--agent-definition
+                            args = [str(sel["cmd"]), "-c", str(sel["file"])]
+                            if model_group:
+                                args += ["-g", str(model_group)]
+                            if config_file:
+                                args += ["-f", str(config_file)]
+                            if task:
+                                args += ["--task", str(task)]
+
+                        elif sel["category"] == "multi_agent":
+                            # jarvis-multi-agent 需要 -c/--config，用户输入通过 -i/--input 传递
+                            args = [str(sel["cmd"]), "-c", str(sel["file"])]
+                            if task:
+                                args += ["-i", str(task)]
+
+                        elif sel["category"] == "roles":
+                            # jarvis-platform-manager role 子命令，支持 -c/-t/-g
+                            args = [str(sel["cmd"]), "role", "-c", str(sel["file"])]
+                            if model_group:
+                                args += ["-g", str(model_group)]
+
+                        if args:
+                            PrettyOutput.print(
+                                f"正在启动: {' '.join(args)}", OutputType.INFO
+                            )
+                            os.execvp(args[0], args)
                     except Exception:
                         # 任何异常都不影响默认流程
                         pass
+                else:
+                    # User pressed Enter or provided invalid input
+                    pass
         except Exception:
             # 静默忽略内置配置扫描错误，不影响主流程
             pass
@@ -482,6 +515,12 @@ def run_cli(
         "--interactive-config",
         help="启动交互式配置向导（基于当前配置补充设置）",
     ),
+    disable_methodology_analysis: bool = typer.Option(
+        False,
+        "-D",
+        "--disable-methodology-analysis",
+        help="禁用方法论和任务分析（覆盖配置文件设置）",
+    ),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -528,6 +567,8 @@ def run_cli(
             model_group=model_group,
             tool_group=tool_group,
             restore_session=restore_session,
+            use_methodology=False if disable_methodology_analysis else None,
+            use_analysis=False if disable_methodology_analysis else None,
         )
         agent_manager.initialize()
         agent_manager.run_task(task)

jarvis/jarvis_agent/memory_manager.py

@@ -3,7 +3,6 @@
 记忆管理器模块
 负责处理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
@@ -20,6 +19,13 @@ class MemoryManager:
             agent: Agent实例
         """
         self.agent = agent
+        # 本轮任务是否已进行过记忆保存提示/处理的标记，用于事件去重
+        self._memory_prompted = False
+        # 订阅 Agent 事件（旁路集成，失败不影响主流程）
+        try:
+            self._subscribe_events()
+        except Exception:
+            pass
 
     def prepare_memory_tags_prompt(self) -> str:
         """准备记忆标签提示"""
@@ -88,13 +94,27 @@ class MemoryManager:
 
         # 处理记忆保存
         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)
 
-            # 根据响应判断是否保存了记忆
-            if "save_memory" in 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
                 )
@@ -103,6 +123,13 @@ class MemoryManager:
 
         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:
         """在附加提示中添加记忆相关提示"""
@@ -125,3 +152,43 @@ class MemoryManager:
                 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/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

jarvis/jarvis_agent/run_loop.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+"""
+AgentRunLoop: 承载 Agent 的主运行循环逻辑。
+
+阶段一目标（最小变更）：
+- 复制现有 _main_loop 逻辑到独立类，使用传入的 agent 实例进行委派调用
+- 暂不变更外部调用入口，后续在 Agent._main_loop 中委派到该类
+- 保持与现有异常处理、工具调用、用户交互完全一致
+"""
+from enum import Enum
+from typing import Any, TYPE_CHECKING
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ot
+
+if TYPE_CHECKING:
+    # 仅用于类型标注，避免运行时循环依赖
+    from . import Agent  # noqa: F401
+
+
+class AgentRunLoop:
+    def __init__(self, agent: "Agent") -> None:
+        self.agent = agent
+
+    def run(self) -> Any:
+        """主运行循环（委派到传入的 agent 实例的方法与属性）"""
+        run_input_handlers = True
+
+        while True:
+            try:
+                ag = self.agent
+
+                # 更新输入处理器标志
+                if ag.run_input_handlers_next_turn:
+                    run_input_handlers = True
+                    ag.run_input_handlers_next_turn = False
+
+                # 首次运行初始化
+                if ag.first:
+                    ag._first_run()
+
+                # 调用模型获取响应
+                current_response = ag._call_model(
+                    ag.session.prompt, True, run_input_handlers
+                )
+
+                ag.session.prompt = ""
+                run_input_handlers = False
+
+                # 处理中断
+                interrupt_result = ag._handle_run_interrupt(current_response)
+                if (
+                    isinstance(interrupt_result, Enum)
+                    and getattr(interrupt_result, "value", None) == "skip_turn"
+                ):
+                    # 中断处理器请求跳过本轮剩余部分，直接开始下一次循环
+                    continue
+                elif interrupt_result is not None and not isinstance(interrupt_result, Enum):
+                    # 中断处理器返回了最终结果，任务结束
+                    return interrupt_result
+
+                # 处理工具调用
+                # 广播工具调用前事件（不影响主流程）
+                try:
+                    ag.event_bus.emit(
+                        "before_tool_call",
+                        agent=ag,
+                        current_response=current_response,
+                    )
+                except Exception:
+                    pass
+                need_return, tool_prompt = ag._call_tools(current_response)
+
+                # 将上一个提示和工具提示安全地拼接起来
+                prompt_parts = []
+                if ag.session.prompt:
+                    prompt_parts.append(ag.session.prompt)
+                if tool_prompt:
+                    prompt_parts.append(tool_prompt)
+                ag.session.prompt = "\n\n".join(prompt_parts)
+
+                if need_return:
+                    return ag.session.prompt
+
+                # 执行回调
+                if ag.after_tool_call_cb:
+                    ag.after_tool_call_cb(ag)
+                # 广播工具调用后的事件（不影响主流程）
+                try:
+                    ag.event_bus.emit(
+                        "after_tool_call",
+                        agent=ag,
+                        current_response=current_response,
+                        need_return=need_return,
+                        tool_prompt=tool_prompt,
+                    )
+                except Exception:
+                    pass
+
+                # 检查是否需要继续
+                if ag.session.prompt or ag.session.addon_prompt:
+                    continue
+
+                # 检查自动完成
+                if ag.auto_complete and ot("!!!COMPLETE!!!") in current_response:
+                    return ag._complete_task(auto_completed=True)
+
+                # 获取下一步用户输入
+                next_action = ag._get_next_user_action()
+                if (
+                    next_action == "continue"
+                    or (
+                        isinstance(next_action, Enum)
+                        and getattr(next_action, "value", None) == "continue"
+                    )
+                ):
+                    run_input_handlers = True
+                    continue
+                elif (
+                    next_action == "complete"
+                    or (
+                        isinstance(next_action, Enum)
+                        and getattr(next_action, "value", None) == "complete"
+                    )
+                ):
+                    return ag._complete_task(auto_completed=False)
+
+            except Exception as e:
+                PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+                return f"Task failed: {str(e)}"

jarvis/jarvis_agent/shell_input_handler.py

@@ -28,7 +28,7 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
         # If any line contains the no-confirm marker, skip the pre-execution confirmation
         no_confirm = any(marker in c for c in cmdline)
 
-        if no_confirm or user_confirm(f"是否要执行以上shell脚本？", default=True):
+        if no_confirm or user_confirm("是否要执行以上shell脚本？", default=True):
             from jarvis.jarvis_tools.registry import ToolRegistry
 
             output = ToolRegistry().handle_tool_calls(