jarvis-ai-assistant 0.7.16__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_agent/main.py

@@ -3,12 +3,13 @@ import os
 from typing import Optional
 
 import typer
-import yaml  # type: ignore[import-untyped]
+import yaml
 
 from jarvis.jarvis_agent import Agent
+from jarvis.jarvis_utils.config import set_config
 from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.output import PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
-from jarvis.jarvis_utils.config import set_config
 
 app = typer.Typer(help="Jarvis AI 助手")
 
@@ -23,7 +24,7 @@ def load_config(config_path: str) -> dict:
         dict: 配置字典
     """
     if not os.path.exists(config_path):
-        print(f"⚠️ 配置文件 {config_path} 不存在，使用默认配置")
+        PrettyOutput.auto_print(f"⚠️ 配置文件 {config_path} 不存在，使用默认配置")
         return {}
 
     with open(config_path, "r", encoding="utf-8", errors="ignore") as f:
@@ -31,7 +32,7 @@ def load_config(config_path: str) -> dict:
             config = yaml.safe_load(f)
             return config if config else {}
         except yaml.YAMLError as e:
-            print(f"❌ 配置文件解析失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 配置文件解析失败: {str(e)}")
             return {}
 
 
@@ -44,28 +45,22 @@ def cli(
         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分钟"
+        False,
+        "-n",
+        "--non-interactive",
+        help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟",
     ),
 ):
     """Main entry point for Jarvis agent"""
-    # 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()):
-        print("❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。")
+        PrettyOutput.auto_print(
+            "❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。"
+        )
         raise typer.Exit(code=2)
     # Initialize环境
     init_env(
@@ -74,9 +69,7 @@ def cli(
     # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
     try:
         if model_group:
-            set_config("JARVIS_LLM_GROUP", str(model_group))
-        if non_interactive:
-            set_config("JARVIS_NON_INTERACTIVE", True)
+            set_config("llm_group", str(model_group))
     except Exception:
         # 静默忽略同步异常，不影响主流程
         pass
@@ -91,11 +84,14 @@ def cli(
 
     # Create and run agent
     try:
+        # 将 non_interactive 标志传递给 Agent，确保仅在该 Agent 实例内生效
+        if non_interactive:
+            config["non_interactive"] = True
         agent = Agent(**config)
 
         # Run agent with initial task if specified
         if task:
-            print(f"ℹ️ 执行初始任务: {task}")
+            PrettyOutput.auto_print(f"ℹ️ 执行初始任务: {task}")
             agent.run(task)
             return
 
@@ -114,12 +110,12 @@ def cli(
             # 来自输入流程的正常退出
             return
         except Exception as e:
-            print(f"❌ 错误: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 错误: {str(e)}")
 
     except typer.Exit:
         return
     except Exception as e:
-        print(f"❌ 初始化错误: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 初始化错误: {str(e)}")
         raise typer.Exit(code=1)
 
 

jarvis/jarvis_agent/memory_manager.py

@@ -4,8 +4,11 @@
 负责处理Agent的记忆保存和检索功能
 """
 
+from jarvis.jarvis_agent.events import BEFORE_HISTORY_CLEAR
+from jarvis.jarvis_agent.events import TASK_COMPLETED
+from jarvis.jarvis_agent.events import TASK_STARTED
 from jarvis.jarvis_utils.globals import get_all_memory_tags
-from jarvis.jarvis_agent.events import TASK_STARTED, BEFORE_HISTORY_CLEAR, TASK_COMPLETED
+from jarvis.jarvis_utils.output import PrettyOutput
 
 
 class MemoryManager:
@@ -95,7 +98,7 @@ class MemoryManager:
             except Exception:
                 pass
 
-            response = self.agent.model.chat_until_success(prompt)  # type: ignore
+            response = self.agent.model.chat_until_success(prompt)
 
             # 执行工具调用（如果有）
             need_return, result = self.agent._call_tools(response)
@@ -109,12 +112,12 @@ class MemoryManager:
                 saved = False
 
             if saved:
-                print("✅ 已自动保存有价值的信息到记忆系统")
+                PrettyOutput.auto_print("✅ 已自动保存有价值的信息到记忆系统")
             else:
-                print("ℹ️ 本次任务没有特别需要记忆的信息")
+                PrettyOutput.auto_print("ℹ️ 本次任务没有特别需要记忆的信息")
 
         except Exception as e:
-            print(f"❌ 记忆分析失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 记忆分析失败: {str(e)}")
         finally:
             # 设置记忆提示完成标记，避免事件触发造成重复处理
             self._memory_prompted = True
@@ -149,7 +152,7 @@ class MemoryManager:
     # 事件订阅与处理（旁路）
     # -----------------------
     def _subscribe_events(self) -> None:
-        bus = self.agent.get_event_bus()  # type: ignore[attr-defined]
+        bus = self.agent.get_event_bus()
         # 任务开始时重置去重标记
         bus.subscribe(TASK_STARTED, self._on_task_started)
         # 在清理历史前尝试保存记忆（若开启强制保存且尚未处理）

jarvis/jarvis_agent/methodology_share_manager.py

@@ -1,19 +1,21 @@
 # -*- coding: utf-8 -*-
 """方法论分享管理模块"""
-import os
+
 import glob
 import json
+import os
 import shutil
-from typing import List, Dict, Any
+from typing import Any
+from typing import Dict
+from typing import List
 
 import typer
 
 from jarvis.jarvis_agent import user_confirm
 from jarvis.jarvis_agent.share_manager import ShareManager
-from jarvis.jarvis_utils.config import (
-    get_central_methodology_repo,
-    get_methodology_dirs,
-)
+from jarvis.jarvis_utils.config import get_central_methodology_repo
+from jarvis.jarvis_utils.config import get_methodology_dirs
+from jarvis.jarvis_utils.output import PrettyOutput
 
 
 class MethodologyShareManager(ShareManager):
@@ -22,8 +24,10 @@ class MethodologyShareManager(ShareManager):
     def __init__(self):
         central_repo = get_central_methodology_repo()
         if not central_repo:
-            print("❌ 错误：未配置中心方法论仓库（JARVIS_CENTRAL_METHODOLOGY_REPO）")
-            print("ℹ️ 请在配置文件中设置中心方法论仓库的Git地址")
+            PrettyOutput.auto_print(
+                "❌ 错误：未配置中心方法论仓库（central_methodology_repo）"
+            )
+            PrettyOutput.auto_print("ℹ️ 请在配置文件中设置中心方法论仓库的Git地址")
             raise typer.Exit(code=1)
 
         super().__init__(central_repo, "central_methodology_repo")
@@ -118,8 +122,8 @@ class MethodologyShareManager(ShareManager):
         share_list = ["\n将要分享以下方法论到中心仓库："]
         for meth in resources:
             share_list.append(f"- {meth['problem_type']}")
-        joined_list = '\n'.join(share_list)
-        print(f"ℹ️ {joined_list}")
+        joined_list = "\n".join(share_list)
+        PrettyOutput.auto_print(f"ℹ️ {joined_list}")
 
         if not user_confirm("确认分享这些方法论吗？"):
             return []
@@ -143,7 +147,9 @@ class MethodologyShareManager(ShareManager):
             # 获取本地资源
             local_resources = self.get_local_resources()
             if not local_resources:
-                print("⚠️ 没有找到新的方法论文件（所有方法论可能已存在于中心仓库）")
+                PrettyOutput.auto_print(
+                    "⚠️ 没有找到新的方法论文件（所有方法论可能已存在于中心仓库）"
+                )
                 return
 
             # 选择要分享的资源
@@ -155,14 +161,14 @@ class MethodologyShareManager(ShareManager):
             copied_list = self.share_resources(selected_resources)
             if copied_list:
                 # 一次性显示所有复制结果
-                joined_copied = '\n'.join(copied_list)
-                print(f"✅ {joined_copied}")
+                joined_copied = "\n".join(copied_list)
+                PrettyOutput.auto_print(f"✅ {joined_copied}")
 
                 # 提交并推送
                 self.commit_and_push(len(selected_resources))
 
-                print("✅ 方法论已成功分享到中心仓库！")
+                PrettyOutput.auto_print("✅ 方法论已成功分享到中心仓库！")
 
         except Exception as e:
-            print(f"❌ 分享方法论时出错: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 分享方法论时出错: {str(e)}")
             raise typer.Exit(code=1)

jarvis/jarvis_agent/output_handler.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
-from abc import ABC, abstractmethod
-from typing import Any, Tuple
+from abc import ABC
+from abc import abstractmethod
+from typing import Any
+from typing import Tuple
 
 
 class OutputHandler(ABC):

jarvis/jarvis_agent/prompt_builder.py

@@ -45,12 +45,13 @@ def build_action_prompt(output_handlers: List[OutputHandlerProtocol]) -> str:
 </details>
 
 <rules>
-# ❗ 重要操作使用规则
-1. 一次对话只能使用一个操作，否则会出错
-2. 严格按照每个操作的格式执行
-3. 等待操作结果后再进行下一个操作
-4. 处理完结果后再调用新的操作
-5. 如果对操作使用不清楚，请请求帮助
+# ❗ 重要操作使用规则（必须严格遵守，违反将导致错误）
+1. **一次对话只能使用一个操作**：每个响应必须包含且仅包含一个工具调用（任务完成时除外）。同时调用多个工具会导致系统错误。
+2. **禁止虚构结果**：所有操作必须基于实际执行结果，禁止推测、假设或虚构任何执行结果。必须等待工具执行完成并获得实际结果后再进行下一步。
+3. **等待操作结果**：在继续下一步之前，必须等待当前工具的执行结果，不能假设工具执行的结果。
+4. **处理完结果后再调用新的操作**：必须完整处理当前工具的执行结果，包括错误信息、输出内容等，然后再决定下一步操作。
+5. **严格按照每个操作的格式执行**：必须遵循每个工具调用的格式要求，包括参数类型、必需字段等。
+6. 如果对操作使用不清楚，请请求帮助
 </rules>
 </actions>
 """

jarvis/jarvis_agent/prompt_manager.py

@@ -7,6 +7,8 @@ PromptManager: 统一管理 Agent 的系统提示词与附加提示词的构建
 - 先行落地构建逻辑，后续在 Agent 中逐步委派使用
 - 保持与现有工具/记忆系统兼容
 """
+
+import shutil
 from typing import TYPE_CHECKING
 
 from jarvis.jarvis_tools.registry import ToolRegistry
@@ -14,8 +16,7 @@ from jarvis.jarvis_utils.tag import ot
 
 if TYPE_CHECKING:
     # 避免运行时循环依赖，仅用于类型标注
-    from . import Agent  # noqa: F401
-
+    from . import Agent
 
 
 class PromptManager:
@@ -35,26 +36,127 @@ class PromptManager:
         构建系统提示词，复用现有的工具使用提示生成逻辑，保持行为一致。
         """
         action_prompt = self.agent.get_tool_usage_prompt()
+
+        # 检查 task_list_manager 工具是否可用
+        task_list_manager_note = ""
+        tool_registry = self.agent.get_tool_registry()
+        if isinstance(tool_registry, ToolRegistry):
+            task_list_tool = tool_registry.get_tool("task_list_manager")
+            if task_list_tool:
+                task_list_manager_note = """
+
+<task_list_manager_guide>
+# 任务列表管理工具使用指南
+
+**重要：在开始处理任务的第一步，先判断是否需要创建任务列表**
+
+在开始执行任务之前，首先评估任务复杂度。**强烈建议：对于任何需要2个或以上步骤的任务，都应该使用 `task_list_manager` 创建任务列表**。即使任务看似简单，使用任务列表也有助于跟踪进度、记录结果和便于调试。
+
+**适合提前规划的任务类型（符合任一情况即应使用）：**
+- **多步骤任务**：需要2个或以上步骤才能完成的任务（如：实现完整功能模块、重构大型代码库、修改多个文件）
+- **有依赖关系的任务**：任务之间存在依赖，需要按顺序执行（如：先设计数据库表，再实现API接口）
+- **需要并行执行的任务**：可以同时进行的独立任务（如：同时开发多个功能模块）
+- **需要跟踪进度的长期任务**：需要分阶段完成、跟踪进度的长期项目
+- **需要不同Agent类型的任务**：部分任务需要代码Agent，部分需要通用Agent（如：代码实现 + 文档编写）
+- **需要分阶段验证的任务**：每个阶段完成后需要验证，再继续下一步（如：先实现基础功能，测试通过后再添加高级特性）
+
+**🚨 强制使用流程：**
+1. **第一步：识别是否需要拆分** - 如果任务符合上述类型，立即使用 `add_tasks` 创建任务列表
+2. **同时拆分任务** - 在 `add_tasks` 时同时提供 `main_goal` 和 `tasks_info`，一次性创建并添加所有子任务
+3. **强制准备additional_info** - 每次使用 `execute_task` 前必须准备详细的 additional_info 参数
+4. **执行任务** - 使用 `execute_task` 逐个执行任务，系统会自动创建子 Agent
+
+**核心功能：**
+- 创建任务列表并添加任务：使用 `add_tasks` 操作，可同时提供 `tasks_info` 一次性创建并添加所有任务
+- 管理任务执行：通过 `execute_task` 自动创建子 Agent 执行任务
+- 跟踪任务状态：查看任务执行进度和结果
+
+**使用建议：**
+- **关键原则**：在开始执行任务的第一步就判断是否需要拆分，如果需要则立即创建任务列表，避免先执行部分步骤再意识到需要拆分
+- **简单任务无需拆分**：如果任务可以在1-3步内完成、只涉及单个文件修改、或只需要单次工具调用，绝对不要创建任务列表，直接由主Agent执行
+- **避免过度拆分**：任务拆分应该保持合理粒度，避免将简单任务拆分成过多过细的子任务，这会增加信息传递负担并可能降低执行效率
+- **评估拆分必要性**：对于可以在1-2步内完成的任务，优先考虑由主Agent直接执行，而不是创建子Agent
+- 推荐在 `add_tasks` 时同时提供 `tasks_info`，一次性创建任务列表并添加所有任务
+- 任务之间的依赖关系可以使用任务名称引用（系统会自动匹配）
+- 通过任务列表可以更好地组织和管理任务执行流程，确保任务按正确顺序执行
+</task_list_manager_guide>
+"""
+
+        system_tools_info = self._get_system_tools_info()
+
         return f"""
 {self.agent.system_prompt}
 
-{action_prompt}
+{action_prompt}{task_list_manager_note}{system_tools_info}
 """
 
+    # ----------------------------
+    # 系统工具信息
+    # ----------------------------
+    def _get_system_tools_info(self) -> str:
+        """
+        检测并返回rg和fd命令的安装状态信息。
+
+        返回:
+            str: 格式化的系统工具信息字符串，供AI助手了解可用工具
+        """
+        tools = []
+
+        # 检测rg命令
+        rg_installed = shutil.which("rg") is not None
+        tools.append(f"rg_available: {rg_installed}")
+
+        # 检测fd命令
+        fd_installed = shutil.which("fd") is not None
+        tools.append(f"fd_available: {fd_installed}")
+
+        return (
+            """
+<system_info>
+可用工具:
+"""
+            + "\n".join(f"- {tool}" for tool in tools)
+            + """
+- rg: 递归快速搜索文件内容（ripgrep）
+- fd: 快速查找文件（fd-find）
+</system_info>"""
+        )
+
     # ----------------------------
     # 附加提示词构建
     # ----------------------------
+    def _format_token_metadata(self) -> str:
+        """
+        格式化token元数据信息，包括已用token和剩余token。
+
+        返回:
+            str: 格式化的token元数据字符串，如果无法获取则返回空字符串
+        """
+        try:
+            used_tokens = self.agent.session.conversation_length
+            remaining_tokens = self.agent.get_remaining_token_count()
+
+            # 如果无法获取有效数据，返回空字符串
+            if used_tokens == 0 and remaining_tokens == 0:
+                return ""
+
+            return f"[Agent元数据] 已用token: {used_tokens} | 剩余token: {remaining_tokens}"
+        except Exception:
+            return ""
+
     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])
+        action_handlers = ", ".join(
+            [handler.name() for handler in self.agent.output_handler]
+        )
 
         # 任务完成提示
         complete_prompt = (
-            f"- 输出{ot('!!!COMPLETE!!!')}"
+            f"- 如果任务已完成，只输出 {ot('!!!COMPLETE!!!')}，不要输出其他任何内容。任务总结将会在后面的交互中被询问。"
             if need_complete and self.agent.auto_complete
             else ""
         )
@@ -65,11 +167,14 @@ class PromptManager:
             "", tool_registry if isinstance(tool_registry, ToolRegistry) else None
         )
 
+        # 获取token元数据
+        token_metadata = self._format_token_metadata()
+        token_metadata_prompt = f"{token_metadata}\n" if token_metadata else ""
+
         addon_prompt = f"""
 <system_prompt>
-    请判断是否已经完成任务，如果已经完成：
-    - 直接输出完成原因，不需要再有新的操作，不要输出{ot("TOOL_CALL")}标签
-    {complete_prompt}
+{token_metadata_prompt}    请判断是否已经完成任务，如果已经完成：
+    {complete_prompt if complete_prompt else f"- 直接输出完成原因，不需要再有新的操作，不要输出{ot('TOOL_CALL')}标签"}
     如果没有完成，请进行下一步操作：
     - 仅包含一个操作
     - 如果信息不明确，请请求用户补充