jarvis-ai-assistant 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent.py

@@ -56,9 +56,11 @@ class CodeAgent:
         need_summary: bool = True,
         append_tools: Optional[str] = None,
         tool_group: Optional[str] = None,
+        non_interactive: Optional[bool] = None,
     ):
         self.root_dir = os.getcwd()
         self.tool_group = tool_group
+        self.non_interactive = non_interactive
 
         # 检测 git username 和 email 是否已设置
         self._check_git_config()
@@ -68,7 +70,6 @@ class CodeAgent:
             "search_web",
             "ask_user",
             "read_code",
-            "rewrite_file",
             "save_memory",
             "retrieve_memory",
             "clear_memory",
@@ -89,11 +90,11 @@ class CodeAgent:
             system_prompt=code_system_prompt,
             name="CodeAgent",
             auto_complete=False,
-            output_handler=[tool_registry, EditFileHandler()],  # type: ignore
             model_group=model_group,
             need_summary=need_summary,
             use_methodology=False,  # 禁用方法论
             use_analysis=False,  # 禁用分析
+            non_interactive=self.non_interactive,
         )
 
         self.agent.event_bus.subscribe(AFTER_TOOL_CALL, self._on_after_tool_call)
@@ -137,7 +138,7 @@ class CodeAgent:
 
 ## 文件编辑工具使用规范
 - 对于部分文件内容修改，使用edit_file工具
-- 对于需要重写整个文件内容，使用rewrite_file工具
+- 对于需要重写整个文件内容，使用 REWRITE 操作
 - 对于简单的修改，可以使用execute_script工具执行shell命令完成
 
 ## 子任务与子CodeAgent
@@ -567,8 +568,8 @@ class CodeAgent:
             1. 每次响应仅执行一步操作，先分析再修改，避免一步多改。
             2. 充分利用工具理解用户需求和现有代码，禁止凭空假设。
             3. 如果不清楚要修改的文件，必须先分析并找出需要修改的文件，明确目标后再进行编辑。
-            4. 代码编辑任务优先使用 edit_file 工具，确保搜索文本在目标文件中有且仅有一次精确匹配，保证修改的准确性和安全性。
-            5. 如需大范围重写，才可使用 rewrite_file 工具。
+            4. 代码编辑任务优先使用 PATCH 操作，确保搜索文本在目标文件中有且仅有一次精确匹配，保证修改的准确性和安全性。
+            5. 如需大范围重写，才可使用 REWRITE 操作。
             6. 如遇信息不明，优先调用工具补充分析，不要主观臆断。
             """
 
@@ -851,9 +852,10 @@ def cli(
         PrettyOutput.print(
             f"警告：当前目录 '{curr_dir_path}' 不是一个git仓库。", OutputType.WARNING
         )
-        if user_confirm(
+        init_git = True if non_interactive else user_confirm(
             f"是否要在 '{curr_dir_path}' 中初始化一个新的git仓库？", default=True
-        ):
+        )
+        if init_git:
             try:
                 subprocess.run(
                     ["git", "init"],
@@ -881,6 +883,7 @@ def cli(
             need_summary=False,
             append_tools=append_tools,
             tool_group=tool_group,
+            non_interactive=non_interactive,
         )
 
         # 尝试恢复会话

jarvis/jarvis_code_analysis/code_review.py

@@ -689,7 +689,6 @@ class CodeReviewTool:
 {ot("REPORT")}
 [在此处插入完整MARKDOWN格式的审查报告]
 {ct("REPORT")}""",
-                    output_handler=[tool_registry],  # type: ignore
                     auto_complete=False,
                 )
 

jarvis/jarvis_data/config_schema.json

@@ -193,6 +193,11 @@
       "description": "脚本执行的超时时间（秒），仅在非交互模式下生效。",
       "default": 300
     },
+    "JARVIS_AUTO_SUMMARY_ROUNDS": {
+      "type": "number",
+      "description": "基于对话轮次的自动总结阈值（达到该轮次后自动总结并清理历史）",
+      "default": 20
+    },
     "JARVIS_CONFIRM_BEFORE_APPLY_PATCH": {
       "type": "boolean",
       "description": "应用补丁前是否需要确认",
@@ -322,6 +327,11 @@
       "description": "是否保存会话记录",
       "default": false
     },
+    "JARVIS_SKIP_PREDEFINED_TASKS": {
+      "type": "boolean",
+      "description": "是否跳过预定义任务加载（不读取 pre-command 列表）",
+      "default": false
+    },
     "JARVIS_GIT_CHECK_MODE": {
       "type": "string",
       "enum": ["strict", "warn"],

jarvis/jarvis_multi_agent/__init__.py

@@ -7,17 +7,20 @@ import yaml
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
+from jarvis.jarvis_agent.rewrite_file_handler import RewriteFileHandler
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 
 
 class MultiAgent(OutputHandler):
-    def __init__(self, agents_config: List[Dict], main_agent_name: str):
+    def __init__(self, agents_config: List[Dict], main_agent_name: str, common_system_prompt: str = ""):
         self.agents_config = agents_config
         self.agents_config_map = {c["name"]: c for c in agents_config}
         self.agents: Dict[str, Agent] = {}
         self.main_agent_name = main_agent_name
         self.original_question: Optional[str] = None
+        self.common_system_prompt: str = common_system_prompt
 
     def prompt(self) -> str:
         return f"""
@@ -66,18 +69,168 @@ content: |2
 """
 
     def can_handle(self, response: str) -> bool:
-        return len(self._extract_send_msg(response)) > 0
+        # 只要检测到 SEND_MESSAGE 起始标签即认为可处理，
+        # 即便内容有误也由 handle 返回明确错误与修复指导
+        return ot("SEND_MESSAGE") in response
 
     def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
-        send_messages = self._extract_send_msg(response)
-        if len(send_messages) > 1:
+        """
+        处理 SEND_MESSAGE。若存在格式/解析/字段/目标等问题，返回明确错误原因与修复指导。
+        """
+        # 优先使用解析器获取“正确路径”结果
+        parsed = self._extract_send_msg(response)
+        if len(parsed) == 1:
+            msg = parsed[0]
+            # 字段校验
+            to_val = msg.get("to")
+            content_val = msg.get("content")
+            missing = []
+            if not to_val:
+                missing.append("to")
+            if content_val is None or (isinstance(content_val, str) and content_val.strip() == ""):
+                # 允许空格/空行被视为缺失
+                missing.append("content")
+            if missing:
+                guidance = (
+                    "SEND_MESSAGE 字段缺失或为空："
+                    + ", ".join(missing)
+                    + "\n修复建议：\n"
+                    "- 必须包含 to 和 content 字段\n"
+                    "- to: 目标智能体名称（字符串）\n"
+                    "- content: 发送内容，建议使用多行块 |2 保持格式\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+                return False, guidance
+            # 类型校验
+            if not isinstance(to_val, str):
+                return False, "SEND_MESSAGE 字段类型错误：to 必须为字符串。修复建议：将 to 改为字符串，如 to: ChapterPolisher"
+            if not isinstance(content_val, str):
+                return False, "SEND_MESSAGE 字段类型错误：content 必须为字符串。修复建议：将 content 改为字符串或使用多行块 content: |2"
+            # 目标校验
+            if to_val not in self.agents_config_map:
+                available = ", ".join(self.agents_config_map.keys())
+                return (
+                    False,
+                    f"目标智能体不存在：'{to_val}' 不在可用列表中。\n"
+                    f"可用智能体：[{available}]\n"
+                    "修复建议：\n"
+                    "- 将 to 修改为上述可用智能体之一\n"
+                    "- 或检查配置中是否遗漏了该智能体的定义"
+                )
+            # 通过校验，交给上层发送
+            return True, {"to": to_val, "content": content_val}
+        elif len(parsed) > 1:
+            return (
+                False,
+                "检测到多个 SEND_MESSAGE 块。一次只能发送一个消息。\n修复建议：合并消息或分多轮发送，每轮仅保留一个 SEND_MESSAGE 块。"
+            )
+        # 未成功解析，进行诊断并返回可操作指导
+        try:
+            normalized = response.replace("\r\n", "\n").replace("\r", "\n")
+        except Exception:
+            normalized = response
+        ot_tag = ot("SEND_MESSAGE")
+        ct_tag = ct("SEND_MESSAGE")
+        has_open = ot_tag in normalized
+        has_close = ct_tag in normalized
+        if has_open and not has_close:
+            return (
+                False,
+                f"检测到 {ot_tag} 但缺少结束标签 {ct_tag}。\n"
+                "修复建议：在消息末尾补充结束标签，并确认标签各自独占一行。\n"
+                "示例：\n"
+                f"{ot_tag}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct_tag}"
+            )
+        # 尝试提取原始块并指出 YAML 问题
+        import re as _re
+        pattern = _re.compile(
+            rf"{_re.escape(ot_tag)}[ \t]*\n(.*?)(?:\n)?[ \t]*{_re.escape(ct_tag)}",
+            _re.DOTALL,
+        )
+        blocks = pattern.findall(normalized)
+        if not blocks:
+            alt_pattern = _re.compile(
+                rf"{_re.escape(ot_tag)}[ \t]*(.*?)[ \t]*{_re.escape(ct_tag)}",
+                _re.DOTALL,
+            )
+            blocks = alt_pattern.findall(normalized)
+        if not blocks:
             return (
                 False,
-                "Send multiple messages, please only send one message at a time.",
+                "SEND_MESSAGE 格式错误：未能识别完整的消息块。\n"
+                "修复建议：确保起止标签在单独行上，且中间内容为合法的 YAML，包含 to 与 content 字段。"
+            )
+        raw = blocks[0]
+        try:
+            msg_obj = yaml.safe_load(raw)
+            if not isinstance(msg_obj, dict):
+                return (
+                    False,
+                    "SEND_MESSAGE 内容必须为 YAML 对象（键值对）。\n"
+                    "修复建议：使用 to 与 content 字段构成的对象。\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+            missing_keys = [k for k in ("to", "content") if k not in msg_obj]
+            if missing_keys:
+                return (
+                    False,
+                    "SEND_MESSAGE 缺少必要字段：" + ", ".join(missing_keys) + "\n"
+                    "修复建议：补充缺失字段。\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+            # 针对值类型的提示（更细）
+            if not isinstance(msg_obj.get("to"), str):
+                return False, "SEND_MESSAGE 字段类型错误：to 必须为字符串。"
+            if not isinstance(msg_obj.get("content"), str):
+                return False, "SEND_MESSAGE 字段类型错误：content 必须为字符串，建议使用多行块 |2。"
+            # 若到此仍未返回，说明结构基本正确，但 _extract_send_msg 未命中，给出泛化建议
+            return (
+                False,
+                "SEND_MESSAGE 格式可能存在缩进或空白字符问题，导致未被系统识别。\n"
+                "修复建议：\n"
+                "- 确保起止标签各占一行\n"
+                "- 标签与内容之间保留换行\n"
+                "- 使用 content: |2 并保证 YAML 缩进一致\n"
+                "示例：\n"
+                f"{ot('SEND_MESSAGE')}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct('SEND_MESSAGE')}"
+            )
+        except Exception as e:
+            return (
+                False,
+                f"SEND_MESSAGE YAML 解析失败：{str(e)}\n"
+                "修复建议：\n"
+                "- 检查冒号、缩进与引号是否正确\n"
+                "- 使用 content: |2 多行块以避免缩进歧义\n"
+                "示例：\n"
+                f"{ot('SEND_MESSAGE')}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct('SEND_MESSAGE')}"
             )
-        if len(send_messages) == 0:
-            return False, ""
-        return True, send_messages[0]
 
     def name(self) -> str:
         return "SEND_MESSAGE"
@@ -89,16 +242,38 @@ content: |2
         Args:
             content: The content containing send message
         """
-        if ot("SEND_MESSAGE") in content and ct("SEND_MESSAGE") not in content:
-            content += "\n" + ct("SEND_MESSAGE")
-        data = re.findall(
-            ot("SEND_MESSAGE") + r"\n(.*?)\n" + ct("SEND_MESSAGE"), content, re.DOTALL
+        # Normalize line endings to handle CRLF/CR cases to ensure robust matching
+        try:
+            normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+        except Exception:
+            normalized = content
+
+        ot_tag = ot("SEND_MESSAGE")
+        ct_tag = ct("SEND_MESSAGE")
+
+        # Auto-append closing tag if missing
+        if ot_tag in normalized and ct_tag not in normalized:
+            normalized += "\n" + ct_tag
+
+        # Use robust regex with DOTALL; escape tags to avoid regex meta issues
+        pattern = re.compile(
+            rf"{re.escape(ot_tag)}[ \t]*\n(.*?)(?:\n)?[ \t]*{re.escape(ct_tag)}",
+            re.DOTALL,
         )
+        data = pattern.findall(normalized)
+        # Fallback: handle cases without explicit newlines around closing tag
+        if not data:
+            alt_pattern = re.compile(
+                rf"{re.escape(ot_tag)}[ \t]*(.*?)[ \t]*{re.escape(ct_tag)}",
+                re.DOTALL,
+            )
+            data = alt_pattern.findall(normalized)
+
         ret = []
         for item in data:
             try:
                 msg = yaml.safe_load(item)
-                if "to" in msg and "content" in msg:
+                if isinstance(msg, dict) and "to" in msg and "content" in msg:
                     ret.append(msg)
             except Exception:
                 continue
@@ -112,6 +287,20 @@ content: |2
             return None
 
         config = self.agents_config_map[name].copy()
+        # 标记为多智能体运行，避免在非交互模式下自动开启 auto_complete
+        config.setdefault("in_multi_agent", True)
+        # 非主智能体统一禁用自动补全，防止多智能体并行时误触发自动交互
+        if name != self.main_agent_name:
+            config["auto_complete"] = False
+
+        # Prepend common system prompt if configured
+        common_sp = getattr(self, "common_system_prompt", "")
+        if common_sp:
+            existing_sp = config.get("system_prompt", "")
+            if existing_sp:
+                config["system_prompt"] = f"{common_sp}\n\n{existing_sp}"
+            else:
+                config["system_prompt"] = common_sp
 
         if name != self.main_agent_name and self.original_question:
             system_prompt = config.get("system_prompt", "")
@@ -119,18 +308,7 @@ content: |2
                 f"{system_prompt}\n\n# 原始问题\n{self.original_question}"
             )
 
-        output_handler = config.get("output_handler", [])
-        if len(output_handler) == 0:
-            output_handler = [
-                ToolRegistry(),
-                self,
-            ]
-        else:
-            if not any(isinstance(h, MultiAgent) for h in output_handler):
-                output_handler.append(self)
-        config["output_handler"] = output_handler
-
-        agent = Agent(**config)
+        agent = Agent(output_handler=[ToolRegistry(),  EditFileHandler(), RewriteFileHandler(), self],**config)
         self.agents[name] = agent
         return agent
 
@@ -155,9 +333,14 @@ content: |2
                 break
 
             # Generate a brief summary via direct model call to avoid run-loop recursion
-            try:
-                # 参照 Agent.generate_summary 的实现思路：基于当前 session.prompt 追加请求提示，直接调用底层模型
-                multi_agent_summary_prompt = """
+            # 如果在配置中显式设置了 summary_on_send=False，则不生成摘要
+            sender_config = self.agents_config_map.get(last_agent_name, {}) if hasattr(self, "agents_config_map") else {}
+            summary_on_send = sender_config.get("summary_on_send", True)
+            summary_text = ""
+            if summary_on_send:
+                try:
+                    # 参照 Agent.generate_summary 的实现思路：基于当前 session.prompt 追加请求提示，直接调用底层模型
+                    multi_agent_summary_prompt = """
 请基于当前会话，为即将发送给其他智能体的协作交接写一段摘要，包含：
 - 已完成的主要工作与产出
 - 关键决策及其理由
@@ -168,12 +351,12 @@ content: |2
 - 仅输出纯文本，不包含任何指令或工具调用
 - 使用简洁的要点式表述
 """.strip()
-                summary_any: Any = agent.model.chat_until_success(  # type: ignore[attr-defined]
-                    f"{agent.session.prompt}\n{multi_agent_summary_prompt}"
-                )
-                summary_text = summary_any.strip() if isinstance(summary_any, str) else ""
-            except Exception:
-                summary_text = ""
+                    summary_any: Any = agent.model.chat_until_success(  # type: ignore[attr-defined]
+                        f"{agent.session.prompt}\n{multi_agent_summary_prompt}"
+                    )
+                    summary_text = summary_any.strip() if isinstance(summary_any, str) else ""
+                except Exception:
+                    summary_text = ""
             prompt = f"""
 Please handle this message:
 from: {last_agent_name}
@@ -200,10 +383,20 @@ content: {msg['content']}
                 f"{last_agent_name} 正在向 {to_agent_name} 发送消息...", OutputType.INFO
             )
 
+            # Keep a reference to the sender before switching to the receiver
+            sender_agent = agent
+
             agent = self._get_agent(to_agent_name)
             if not agent:
                 return f"智能体 {to_agent_name} 未找到"
 
+            # Check if the sending agent should be cleared
+            sender_config = self.agents_config_map.get(last_agent_name, {})
+            if sender_config.get("clear_after_send_message"):
+                if sender_agent:
+                    PrettyOutput.print(f"清除智能体 {last_agent_name} 在发送消息后的历史记录...", OutputType.INFO)
+                    sender_agent.clear_history()
+
             last_agent_name = agent.name
             msg = agent.run(prompt)
         return ""

jarvis/jarvis_multi_agent/main.py

@@ -20,6 +20,9 @@ def cli(
     user_input: Optional[str] = typer.Option(
         None, "--input", "-i", help="用户输入（可选）"
     ),
+    model_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
     non_interactive: bool = typer.Option(
         False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
     ),
@@ -45,6 +48,8 @@ def cli(
     try:
         if non_interactive:
             set_config("JARVIS_NON_INTERACTIVE", True)
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
     except Exception:
         # 静默忽略同步异常，不影响主流程
         pass
@@ -61,7 +66,11 @@ def cli(
             raise ValueError("必须指定main_agent作为主智能体")
 
         # 创建并运行多智能体系统
-        multi_agent = MultiAgent(agents_config, main_agent_name)
+        multi_agent = MultiAgent(
+            agents_config,
+            main_agent_name,
+            common_system_prompt=str(config_data.get("common_system_prompt", "") or "")
+        )
         final_input = (
             user_input
             if user_input is not None

jarvis/jarvis_platform/base.py

@@ -24,6 +24,7 @@ from jarvis.jarvis_utils.config import (
 )
 from jarvis.jarvis_utils.embedding import split_text_into_chunks
 from jarvis.jarvis_utils.globals import set_in_chat, get_interrupt, console
+import jarvis.jarvis_utils.globals as G
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import get_context_token_count, while_success, while_true
@@ -83,6 +84,11 @@ class BasePlatform(ABC):
 
         start_time = time.time()
 
+        # 当输入为空白字符串时，打印警告并直接返回空字符串
+        if message.strip() == "":
+            PrettyOutput.print("输入为空白字符串，已忽略本次请求", OutputType.WARNING)
+            return ""
+
         input_token_count = get_context_token_count(message)
 
         if input_token_count > get_max_input_token_count(self.model_group):
@@ -133,7 +139,9 @@ class BasePlatform(ABC):
                     first_chunk = None
 
                     with Status(
-                        f"🤔 {self.name()} 正在思考中...", spinner="dots", console=console
+                        f"🤔 {(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()} 正在思考中...",
+                        spinner="dots",
+                        console=console,
                     ):
                         try:
                             while True:
@@ -147,7 +155,7 @@ class BasePlatform(ABC):
                     text_content = Text(overflow="fold")
                     panel = Panel(
                         text_content,
-                        title=f"[bold cyan]{self.name()}[/bold cyan]",
+                        title=f"[bold cyan]{(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()}[/bold cyan]",
                         subtitle="[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]",
                         border_style="bright_blue",
                         box=box.ROUNDED,
@@ -227,7 +235,7 @@ class BasePlatform(ABC):
                 else:
                     # Print a clear prefix line before streaming model output (non-pretty mode)
                     console.print(
-                        f"🤖 模型输出 - {self.name()}  (按 Ctrl+C 中断)",
+                        f"🤖 模型输出 - {(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()}  (按 Ctrl+C 中断)",
                         soft_wrap=False,
                     )
                     for s in self.chat(message):
@@ -369,9 +377,10 @@ class BasePlatform(ABC):
                 return
 
             if self._session_history_file is None:
-                # Ensure data directory exists
+                # Ensure session history directory exists under data directory
                 data_dir = get_data_dir()
-                os.makedirs(data_dir, exist_ok=True)
+                session_dir = os.path.join(data_dir, "session_history")
+                os.makedirs(session_dir, exist_ok=True)
 
                 # Build a safe filename including platform, model and timestamp
                 try:
@@ -389,7 +398,7 @@ class BasePlatform(ABC):
                 ts = datetime.now().strftime("%Y%m%d_%H%M%S")
 
                 self._session_history_file = os.path.join(
-                    data_dir, f"session_history_{safe_platform}_{safe_model}_{ts}.log"
+                    session_dir, f"session_history_{safe_platform}_{safe_model}_{ts}.log"
                 )
 
             # Append record

jarvis/jarvis_tools/registry.py

@@ -633,6 +633,12 @@ class ToolRegistry(OutputHandlerProtocol):
         异常:
             Exception: 如果工具调用缺少必要字段
         """
+        # 如果</TOOL_CALL>出现在响应的末尾，但是前面没有换行符，自动插入一个换行符进行修复
+        if content.rstrip().endswith(ct("TOOL_CALL")):
+            pos = content.rfind(ct("TOOL_CALL"))
+            if pos > 0 and content[pos - 1] not in ("\n", "\r"):
+                content = content[:pos] + "\n" + content[pos:]
+
         # 将内容拆分为行
         pattern = rf'(?ms){re.escape(ot("TOOL_CALL"))}(.*?)^{re.escape(ct("TOOL_CALL"))}'
         data = re.findall(pattern, content)