jarvis-ai-assistant 0.1.128__py3-none-any.whl → 0.1.130__py3-none-any.whl

jarvis/jarvis_multi_agent/__init__.py

@@ -5,92 +5,78 @@ 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_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import init_env
 
 
-class AgentConfig:
-    def __init__(self, **config):
-        self.system_prompt = config.get('system_prompt', '')
-        self.name = config.get('name', 'Jarvis')
-        self.description = config.get('description', '')
-        self.is_sub_agent = config.get('is_sub_agent', False)
-        self.output_handler = config.get('output_handler', [])
-        self.platform = config.get('platform')
-        self.model_name = config.get('model_name')
-        self.summary_prompt = config.get('summary_prompt')
-        self.auto_complete = config.get('auto_complete', False)
-        self.input_handler = config.get('input_handler')
-        self.max_context_length = config.get('max_context_length')
-        self.execute_tool_confirm = config.get('execute_tool_confirm')
-
 class MultiAgent(OutputHandler):
-    def __init__(self, configs: List[AgentConfig], main_agent_name: str):
-        self.agents_config = configs
+    def __init__(self, agents_config: List[Dict], main_agent_name: str):
+        self.agents_config = agents_config
         self.agents = {}
         self.init_agents()
         self.main_agent_name = main_agent_name
 
     def prompt(self) -> str:
         return f"""
-# 🤖 多智能体消息处理系统
-您是多智能体系统的一部分，通过结构化消息进行通信。
-
-# 🎯 核心规则
-## 关键操作规则
-- 每轮只能执行一个操作：
-  - 要么使用一个工具（文件操作、询问用户等）
-  - 要么发送一条消息给其他智能体
-  - 切勿在同一轮中同时进行这两种操作
-
-## 消息流控制
-- 发送消息后等待响应
-- 处理响应后再进行下一步操作
-- 切勿同时发送多条消息
-- 切勿将消息与工具调用混合使用
-
-# 📝 消息格式
+# 多智能体协作系统
+
+## 身份与角色定位
+- **核心职责**：作为多智能体系统的协调者，通过结构化消息实现高效协作
+- **关键能力**：消息路由、任务分发、结果整合、流程协调
+- **工作范围**：在多个专业智能体之间建立有效沟通渠道
+
+## 交互原则与策略
+### 消息处理规范
+- **单一操作原则**：每轮只执行一个操作（工具调用或消息发送）
+- **完整性原则**：确保消息包含所有必要信息，避免歧义
+- **明确性原则**：清晰表达意图、需求和期望结果
+- **上下文保留**：在消息中包含足够的背景信息
+
+### 消息格式标准
 ```
 <SEND_MESSAGE>
 to: 智能体名称    # 目标智能体名称
 content: |
-    消息内容    # 消息内容
-    可使用多行    # 如果需要
-    保持正确的缩进
+    # 消息主题
+    
+    ## 背景信息
+    [提供必要的上下文和背景]
+    
+    ## 具体需求
+    [明确表达期望完成的任务]
+    
+    ## 相关资源
+    [列出相关文档、数据或工具]
+    
+    ## 期望结果
+    [描述期望的输出格式和内容]
 </SEND_MESSAGE>
 ```
 
-# 🔄 操作顺序
-1. 选择最重要的操作
-   - 评估优先级
-   - 选择一个操作
-   - 执行该操作
-
-2. 等待响应
-   - 处理结果/响应
-   - 计划下一步操作
-   - 等待下一轮
-
-3. 处理响应
-   - 处理收到的消息
-   - 需要时回复发送者
-   - 根据响应继续任务
-
-# 👥 可用智能体
-{chr(10).join([f"- {c.name}: {c.description}" for c in self.agents_config])}
-
-# ❗ 重要规则
-1. 每轮只能执行一个操作
-2. 等待响应
-3. 处理后再进行下一步
-4. 回复消息
-5. 需要时转发任务
-
-# 💡 提示
-- 第一个操作将被执行
-- 额外的操作将被忽略
-- 总是先处理响应
-- 需要时发送消息以继续任务
-- 处理并回复收到的消息
+## 协作流程规范
+### 任务分发流程
+1. **需求分析**：理解用户需求并确定最适合的智能体
+2. **任务分解**：将复杂任务分解为可管理的子任务
+3. **精准分发**：根据专长将任务分配给合适的智能体
+4. **结果整合**：收集各智能体的输出并整合为连贯结果
+
+### 消息流控制
+1. **单向流动**：发送消息后等待响应，避免消息风暴
+2. **优先级管理**：处理紧急消息优先，保持任务顺序
+3. **状态跟踪**：记录每个任务的当前状态和处理进度
+4. **异常处理**：优雅处理超时、错误和意外响应
+
+## 可用智能体资源
+{chr(10).join([f"- **{c['name']}**: {c.get('description', '')}" for c in self.agents_config])}
+
+## 最佳实践指南
+1. **任务明确化**：每个消息专注于单一、明确的任务
+2. **信息充分性**：提供足够信息让接收者能独立完成任务
+3. **反馈循环**：建立清晰的反馈机制，及时调整方向
+4. **知识共享**：确保关键信息在相关智能体间共享
+5. **协作效率**：避免不必要的消息传递，减少协调开销
 """
 
     def can_handle(self, response: str) -> bool:
@@ -128,29 +114,22 @@ content: |
         return ret
 
     def init_agents(self):
-        for agent_config in self.agents_config:
-            agent = Agent(system_prompt=agent_config.system_prompt,
-                          name=agent_config.name,
-                          description=agent_config.description,
-                          model_name=agent_config.model_name,
-                          platform=agent_config.platform,
-                          max_context_length=agent_config.max_context_length,
-                          execute_tool_confirm=agent_config.execute_tool_confirm,
-                          input_handler=agent_config.input_handler,
-                          use_methodology=False,
-                          record_methodology=False,
-                          need_summary=False,
-                          auto_complete=agent_config.auto_complete,
-                          summary_prompt=agent_config.summary_prompt,
-                          is_sub_agent=agent_config.is_sub_agent,
-                          output_handler=[*agent_config.output_handler, self],
-                          )
-            
-            self.agents[agent_config.name] = agent
-
-    def run(self, user_input: str, file_list: Optional[List[str]] = None) -> str:
+        for config in self.agents_config:
+            output_handler = config.get('output_handler', [])
+            if len(output_handler) == 0:
+                output_handler = [
+                    ToolRegistry(),
+                    self,
+                ]
+            else:
+                output_handler.append(self)
+            config['output_handler'] = output_handler
+            agent = Agent(**config)
+            self.agents[config['name']] = agent
+
+    def run(self, user_input: str) -> str:
         last_agent = self.main_agent_name
-        msg = self.agents[self.main_agent_name].run(user_input, file_list)
+        msg = self.agents[self.main_agent_name].run(user_input)
         while msg:
             if isinstance(msg, str):
                 return msg
@@ -167,4 +146,46 @@ content: {msg['content']}
                 PrettyOutput.print(f"{last_agent} 正在向 {msg['to']} 发送消息...", OutputType.INFO)
                 last_agent = self.agents[msg['to']].name
                 msg = self.agents[msg['to']].run(prompt)
-        return ""
+        return ""
+
+
+def main():
+    """从YAML配置文件初始化并运行多智能体系统
+    
+    Returns:
+        最终处理结果
+    """
+    init_env()
+    import argparse
+    parser = argparse.ArgumentParser(description="多智能体系统启动器")
+    parser.add_argument("--config", "-c", required=True, help="YAML配置文件路径")
+    parser.add_argument("--input", "-i", help="用户输入（可选）")
+    args = parser.parse_args()
+        
+    try:
+        with open(args.config, 'r') as f:
+            config_data = yaml.safe_load(f)
+            
+        # 获取agents配置
+        agents_config = config_data.get('agents', [])
+        
+        main_agent_name = config_data.get('main_agent', '')
+        if not main_agent_name:
+            raise ValueError("必须指定main_agent作为主智能体")
+            
+        # 创建并运行多智能体系统
+        multi_agent = MultiAgent(agents_config, main_agent_name)
+        user_input = args.input if args.input is not None else get_multiline_input("请输入内容（输入空行结束）：")
+        if user_input == "":
+            return
+        return multi_agent.run(user_input)
+        
+    except yaml.YAMLError as e:
+        raise ValueError(f"YAML配置文件解析错误: {str(e)}")
+    except Exception as e:
+        raise RuntimeError(f"多智能体系统初始化失败: {str(e)}")
+
+
+if __name__ == "__main__":
+    result = main()
+    

jarvis/jarvis_platform/registry.py

@@ -16,7 +16,6 @@ REQUIRED_METHODS = [
     ('set_model_name', ['model_name']),
     ('get_model_list', []),
     ('set_suppress_output', ['suppress']),
-    ('upload_files', ['file_list'])
 ]
 
 class PlatformRegistry:

jarvis/jarvis_tools/create_sub_agent.py

@@ -30,12 +30,6 @@ class SubAgentTool:
                 "description": "任务的完成目标",
                 "default": ""
             },
-            "files": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "相关文件路径列表，用于文件问答和处理",
-                "default": []
-            }
         },
         "required": ["agent_name", "task", "context", "goal"]
     }
@@ -48,7 +42,6 @@ class SubAgentTool:
             task = args["task"]
             context = args.get("context", "")
             goal = args.get("goal", "")
-            files = args.get("files", [])
 
             PrettyOutput.print(f"创建子代理: {agent_name}", OutputType.INFO)
 
@@ -69,7 +62,7 @@ class SubAgentTool:
 
             # Run sub-agent, pass file list
             PrettyOutput.print("子代理开始执行任务...", OutputType.INFO)
-            result = sub_agent.run(task_description, file_list=files)
+            result = sub_agent.run(task_description)
 
             return {
                 "success": True,

jarvis/jarvis_tools/git_commiter.py

@@ -9,7 +9,7 @@ from jarvis.jarvis_platform.registry import PlatformRegistry
 import sys
 import argparse
 
-from jarvis.jarvis_utils.git_utils import has_uncommitted_changes
+from jarvis.jarvis_utils.git_utils import find_git_root, has_uncommitted_changes
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 
@@ -51,6 +51,7 @@ class GitCommitTool:
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Execute automatic commit process with support for multi-line messages and special characters"""
         try:
+            find_git_root()
             if not has_uncommitted_changes():
                 PrettyOutput.print("没有未提交的更改", OutputType.SUCCESS)
                 return {"success": True, "stdout": "No changes to commit", "stderr": ""}

jarvis/jarvis_tools/read_code.py

@@ -0,0 +1,143 @@
+from typing import Dict, Any
+import os
+
+from yaspin import yaspin
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+class ReadCodeTool:
+    name = "read_code"
+    description = "用于读取代码文件并在每行前添加行号的工具"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "files": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string"},
+                        "start_line": {"type": "number", "default": 1},
+                        "end_line": {"type": "number", "default": -1}
+                    },
+                    "required": ["path"]
+                },
+                "description": "要读取的文件列表"
+            }
+        },
+        "required": ["files"]
+    }
+
+    def _handle_single_file(self, filepath: str, start_line: int = 1, end_line: int = -1) -> Dict[str, Any]:
+        try:
+            abs_path = os.path.abspath(filepath)
+            with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
+                # 文件存在性检查
+                if not os.path.exists(abs_path):
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": f"文件不存在: {abs_path}"
+                    }
+                
+                # 文件大小限制检查（10MB）
+                if os.path.getsize(abs_path) > 10 * 1024 * 1024:
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": "文件过大 (>10MB)"
+                    }
+                
+                # 读取文件内容
+                with open(abs_path, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+                
+                total_lines = len(lines)
+                
+                # 处理特殊值-1表示文件末尾
+                if end_line == -1:
+                    end_line = total_lines
+                else:
+                    end_line = max(1, min(end_line, total_lines)) if end_line >= 0 else total_lines + end_line + 1
+                
+                start_line = max(1, min(start_line, total_lines)) if start_line >= 0 else total_lines + start_line + 1
+                
+                if start_line > end_line:
+                    spinner.fail("❌")
+                    return {
+                        "success": False,
+                        "stdout": "",
+                        "stderr": f"无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})"
+                    }
+                
+                # 添加行号并构建输出内容
+                selected_lines = lines[start_line-1:end_line]
+                numbered_content = "".join(
+                    [f"{i:4d} | {line}" 
+                     for i, line in enumerate(selected_lines, start=start_line)]
+                )
+                
+                # 构建输出格式
+                output = (
+                    f"\n🔍 文件: {abs_path}\n"
+                    f"📄 原始行号: {start_line}-{end_line} (共{end_line - start_line + 1}行) | 显示行号: 1-{len(selected_lines)}\n\n"
+                    f"{numbered_content}\n"
+                    f"{'='*80}\n"
+                )
+                spinner.text = f"文件读取完成: {abs_path}"
+                spinner.ok("✅")
+                return {
+                    "success": True,
+                    "stdout": output,
+                    "stderr": ""
+                }
+                
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"文件读取失败: {str(e)}"
+            }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        try:
+            if "files" not in args or not isinstance(args["files"], list):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "参数中必须包含文件列表"
+                }
+            
+            all_outputs = []
+            overall_success = True
+            
+            for file_info in args["files"]:
+                if not isinstance(file_info, dict) or "path" not in file_info:
+                    continue
+                
+                result = self._handle_single_file(
+                    file_info["path"].strip(),
+                    file_info.get("start_line", 1),
+                    file_info.get("end_line", -1)
+                )
+                
+                if result["success"]:
+                    all_outputs.append(result["stdout"])
+                else:
+                    all_outputs.append(f"❌ {file_info['path']}: {result['stderr']}")
+                    overall_success = False
+                
+            return {
+                "success": overall_success,
+                "stdout": "\n".join(all_outputs),
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"代码读取失败: {str(e)}"
+            }

jarvis/jarvis_tools/registry.py

@@ -354,45 +354,41 @@ arguments:
             if result["success"]:
                 # If the output exceeds 4k characters, use a large model to summarize
                 if get_context_token_count(output) > self.max_token_count:
-                    with yaspin(text="正在总结输出...", color="yellow") as spinner:
-                        try:
-                            
-                            model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-                            
-                            # If the output exceeds the maximum context length, only take the last part
-                            max_count = self.max_token_count
-                            if get_context_token_count(output) > max_count:
-                                output_to_summarize = output[-max_count:]
-                                truncation_notice = f"\n(注意：由于输出过长，仅总结最后 {max_count} 个字符)"
-                            else:
-                                output_to_summarize = output
-                                truncation_notice = ""
-
-                            prompt = f"""请总结以下工具的执行结果，提取关键信息和重要结果。注意：
-    1. 保留所有重要的数值、路径、错误信息等
-    2. 保持结果的准确性
-    3. 用简洁的语言描述主要内容
-    4. 如果有错误信息，确保包含在总结中
-
-    工具名称: {name}
-    执行结果:
-    {output_to_summarize}
-
-    请提供总结:"""
-
-                            summary = model.chat_until_success(prompt)
-                            output = f"""--- 原始输出过长，以下是总结 ---{truncation_notice}
-
-    {summary}
-
-    --- 总结结束 ---"""
-                            spinner.text = "总结完成"
-                            spinner.ok("✅")
-                        except Exception as e:
-                            spinner.text = "总结失败"
-                            spinner.fail("❌")
-                            PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
-                            output = f"输出过长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
+                    PrettyOutput.section("输出过长，正在总结...", OutputType.SYSTEM)
+                    try:
+                        
+                        model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
+                        model.set_suppress_output(False)
+                        # If the output exceeds the maximum context length, only take the last part
+                        max_count = self.max_token_count
+                        if get_context_token_count(output) > max_count:
+                            output_to_summarize = output[-max_count:]
+                            truncation_notice = f"\n(注意：由于输出过长，仅总结最后 {max_count} 个字符)"
+                        else:
+                            output_to_summarize = output
+                            truncation_notice = ""
+
+                        prompt = f"""请总结以下工具的执行结果，提取关键信息和重要结果。注意：
+1. 保留所有重要的数值、路径、错误信息等
+2. 保持结果的准确性
+3. 用简洁的语言描述主要内容
+4. 如果有错误信息，确保包含在总结中
+
+工具名称: {name}
+执行结果:
+{output_to_summarize}
+
+请提供总结:"""
+
+                        summary = model.chat_until_success(prompt)
+                        output = f"""--- 原始输出过长，以下是总结 ---{truncation_notice}
+
+{summary}
+
+--- 总结结束 ---"""
+                    except Exception as e:
+                        PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
+                        output = f"输出过长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
             return output
             
         except Exception as e:

jarvis/jarvis_tools/tool_generator.py

@@ -9,6 +9,8 @@ from yaspin import yaspin
 from jarvis.jarvis_platform.registry import PlatformRegistry
 
 class ToolGenerator:
+    """工具生成器类，用于自动创建与Jarvis系统集成的新工具"""
+    
     name = "tool_generator"
     description = "使用LLM自动生成与系统集成的新工具"
     parameters = {
@@ -31,8 +33,14 @@ class ToolGenerator:
     }
     
     def execute(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Generate and save a new tool using LLM"""
-        # Get fresh model instance for each execution
+        """
+        执行工具生成过程
+        Args:
+            arguments: 包含工具生成所需参数的字典
+        Returns:
+            包含执行结果的字典，包含success、stdout和stderr字段
+        """
+        # 获取代码生成平台实例
         model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
         
         try:
@@ -40,37 +48,37 @@ class ToolGenerator:
             description = arguments["description"]
             input_spec = arguments["input_spec"]
             
-            # Generate tool implementation using LLM
+            # 使用LLM生成工具实现代码
             with yaspin(text="正在生成工具...", color="cyan") as spinner:
                 prompt = self._create_prompt(tool_name, description, input_spec)
                 llm_response = model.chat_until_success(prompt)
                 spinner.text = "工具生成完成"
                 spinner.ok("✅")
             
-            # Extract implementation with more flexible parsing
+            # 从LLM响应中提取实现代码
             with yaspin(text="正在提取工具实现...", color="cyan") as spinner:
                 implementation = self._extract_code(llm_response)
                 if not implementation:
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "Could not extract valid Python code from LLM response"
+                        "stderr": "无法从LLM响应中提取有效的Python代码"
                     }
                 spinner.text = "工具实现提取完成"
                 spinner.ok("✅")
             
-            # Validate return value format
+            # 验证生成的工具代码是否符合返回值格式要求
             with yaspin(text="正在验证工具返回值格式...", color="cyan") as spinner:
                 if not self._validate_return_value_format(implementation):
                     return {
                         "success": False,
                         "stdout": "",
-                        "stderr": "Generated tool does not follow required return value format"
+                        "stderr": "生成的工具不符合要求的返回值格式"
                     }
                 spinner.text = "工具返回值格式验证完成"
                 spinner.ok("✅")
             
-            # Save the new tool
+            # 保存生成的新工具
             with yaspin(text="正在保存工具...", color="cyan") as spinner:
                 tools_dir = Path.home() / ".jarvis" / "tools"
                 tools_dir.mkdir(parents=True, exist_ok=True)
@@ -83,7 +91,7 @@ class ToolGenerator:
             
             return {
                 "success": True,
-                "stdout": f"Tool successfully generated at: {tool_file}",
+                "stdout": f"工具成功生成于: {tool_file}",
                 "stderr": ""
             }
             
@@ -91,11 +99,19 @@ class ToolGenerator:
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"Tool generation failed: {str(e)}"
+                "stderr": f"工具生成失败: {str(e)}"
             }
     
     def _create_prompt(self, tool_name: str, description: str, input_spec: str) -> str:
-        """创建用于工具生成的LLM提示"""
+        """
+        创建用于工具生成的LLM提示
+        Args:
+            tool_name: 工具名称
+            description: 工具描述
+            input_spec: 输入规范
+        Returns:
+            格式化后的提示字符串
+        """
         example_code = '''
 <TOOL>
 from typing import Dict, Any
@@ -176,20 +192,32 @@ class CustomTool:
 '''
     
     def _extract_code(self, response: str) -> str:
-        """Flexibly extract Python code from LLM response"""
-        # Find the first occurrence of <TOOL> and </TOOL>
+        """
+        从LLM响应中提取Python代码
+        Args:
+            response: LLM的响应字符串
+        Returns:
+            提取到的Python代码字符串
+        """
+        # 查找第一个<TOOL>和</TOOL>标签之间的内容
         sm = re.search(r'<TOOL>(.*?)</TOOL>', response, re.DOTALL)
         if sm:
             return sm.group(1)
         return ""
     
     def _validate_return_value_format(self, code: str) -> bool:
-        """Validate that execute method returns correct format"""
+        """
+        验证execute方法的返回值格式是否正确
+        Args:
+            code: 要验证的代码字符串
+        Returns:
+            布尔值，表示格式是否正确
+        """
         required_fields = ["success", "stdout", "stderr"]
-        # Look for execute method
+        # 检查execute方法是否存在
         if "def execute(self, args: Dict) -> Dict:" not in code and \
            "def execute(self, args: Dict) -> Dict[str, Any]:" not in code:
             return False
         
-        # Check for required fields in return statement
-        return all(field in code for field in required_fields)
+        # 检查返回值中是否包含所有必需字段
+        return all(field in code for field in required_fields)