jarvis-ai-assistant 0.1.113__py3-none-any.whl → 0.1.115__py3-none-any.whl

jarvis/jarvis_tools/file_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any
+from typing import Dict, Any, List, Union
 import os
 
 from jarvis.utils import OutputType, PrettyOutput
@@ -6,54 +6,38 @@ from jarvis.utils import OutputType, PrettyOutput
 
 class FileOperationTool:
     name = "file_operation"
-    description = "File operations (read/write/append/exists)"
+    description = "File operations for reading and writing multiple files"
     parameters = {
         "type": "object",
         "properties": {
             "operation": {
                 "type": "string",
-                "enum": ["read", "write", "append", "exists"],
-                "description": "Type of file operation to perform"
+                "enum": ["read", "write"],
+                "description": "Type of file operation to perform (read or write multiple files)"
             },
-            "filepath": {
-                "type": "string",
-                "description": "Absolute or relative path to the file"
-            },
-            "content": {
-                "type": "string",
-                "description": "Content to write (required for write/append operations)",
-                "default": ""
-            },
-            "encoding": {
-                "type": "string",
-                "description": "File encoding (default: utf-8)",
-                "default": "utf-8"
+            "files": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string"},
+                        "content": {"type": "string"}
+                    },
+                    "required": ["path"]
+                },
+                "description": "List of files to operate on"
             }
         },
-        "required": ["operation", "filepath"]
+        "required": ["operation", "files"]
     }
 
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Execute file operations"""
+    def _handle_single_file(self, operation: str, filepath: str, content: str = "") -> Dict[str, Any]:
+        """Handle operations for a single file"""
         try:
-            operation = args["operation"].strip()
-            filepath = args["filepath"].strip()
-            encoding = args.get("encoding", "utf-8")
-            
-            # Record the operation and the full path
             abs_path = os.path.abspath(filepath)
             PrettyOutput.print(f"文件操作: {operation} - {abs_path}", OutputType.INFO)
             
-            if operation == "exists":
-                exists = os.path.exists(filepath)
-                return {
-                    "success": True,
-                    "stdout": str(exists),
-                    "stderr": ""
-                }
-                
-            elif operation == "read":
+            if operation == "read":
                 if not os.path.exists(filepath):
                     return {
                         "success": False,
@@ -61,7 +45,6 @@ class FileOperationTool:
                         "stderr": f"文件不存在: {filepath}"
                     }
                     
-                # Check file size
                 if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
                     return {
                         "success": False,
@@ -69,41 +52,90 @@ class FileOperationTool:
                         "stderr": "File too large (>10MB)"
                     }
                     
-                content = open(filepath, 'r', encoding=encoding).read()
-                PrettyOutput.print(content, OutputType.INFO)
+                content = open(filepath, 'r', encoding='utf-8').read()
+                output = f"File: {filepath}\n{content}"
+                
+                # Print file content
+                PrettyOutput.print(f"读取文件: {filepath}\n{content}", OutputType.INFO)
+                
                 return {
                     "success": True,
-                    "stdout": content,
+                    "stdout": output,
                     "stderr": ""
                 }
                 
-            elif operation in ["write", "append"]:
-                if not args.get("content"):
-                    return {
-                        "success": False,
-                        "stdout": "",
-                        "stderr": "Write/append operation requires providing the content parameter"
-                    }
-                
-                # Create directory (if it doesn't exist)
+            elif operation == "write":
                 os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
-                    
-                mode = 'a' if operation == "append" else 'w'
-                with open(filepath, mode, encoding=encoding) as f:
-                    f.write(args["content"])
-                    
+                with open(filepath, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                
+                PrettyOutput.print(f"写入文件: {filepath}", OutputType.INFO)
                 return {
                     "success": True,
-                    "stdout": f"Successfully {operation} content to {filepath}",
+                    "stdout": f"Successfully wrote content to {filepath}",
                     "stderr": ""
                 }
-                
-            else:
+            
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Unknown operation: {operation}"
+            }
+            
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"File operation failed for {filepath}: {str(e)}"
+            }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute file operations for multiple files
+        
+        Args:
+            args: Dictionary containing operation and files list
+            
+        Returns:
+            Dict containing:
+                - success: Boolean indicating overall success
+                - stdout: Combined output of all operations as string
+                - stderr: Error message if any
+        """
+        try:
+            operation = args["operation"].strip()
+            
+            if "files" not in args or not isinstance(args["files"], list):
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": f"Unknown operation: {operation}"
+                    "stderr": "files parameter is required and must be a list"
                 }
+            
+            all_outputs = []
+            success = True
+            
+            for file_info in args["files"]:
+                if not isinstance(file_info, dict) or "path" not in file_info:
+                    continue
+                
+                content = file_info.get("content", "") if operation == "write" else ""
+                result = self._handle_single_file(operation, file_info["path"], content)
+                
+                if result["success"]:
+                    all_outputs.append(result["stdout"])
+                else:
+                    all_outputs.append(f"Error with {file_info['path']}: {result['stderr']}")
+                success = success and result["success"]
+            
+            # Combine all outputs with separators
+            combined_output = "\n\n" + "="*80 + "\n\n".join(all_outputs)
+            
+            return {
+                "success": success,
+                "stdout": combined_output,
+                "stderr": ""
+            }
                 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)

jarvis/jarvis_tools/read_code.py

@@ -1,59 +1,59 @@
-from typing import Dict, Any
+from typing import Dict, Any, List
 import os
 from jarvis.utils import OutputType, PrettyOutput
 
 
 class ReadCodeTool:
-    """Read code file with line numbers"""
+    """Read multiple code files with line numbers"""
     
     name = "read_code"
-    description = "Read code file with line numbers"
+    description = "Read multiple code files with line numbers"
     parameters = {
         "type": "object",
         "properties": {
-            "filepath": {
-                "type": "string",
-                "description": "Absolute or relative path to the file"
-            },
-            "start_line": {
-                "type": "integer",
-                "description": "Start line number (0-based, inclusive)",
-                "default": 0
-            },
-            "end_line": {
-                "type": "integer",
-                "description": "End line number (0-based, exclusive). -1 means read to end",
-                "default": -1
+            "files": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to the file"
+                        },
+                        "start_line": {
+                            "type": "integer",
+                            "description": "Start line number (0-based, inclusive)",
+                            "default": 0
+                        },
+                        "end_line": {
+                            "type": "integer",
+                            "description": "End line number (0-based, exclusive). -1 means read to end",
+                            "default": -1
+                        }
+                    },
+                    "required": ["path"]
+                },
+                "description": "List of files to read"
             }
         },
-        "required": ["filepath"]
+        "required": ["files"]
     }
 
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Execute code reading with line numbers
+    def _read_single_file(self, filepath: str, start_line: int = 0, end_line: int = -1) -> Dict[str, Any]:
+        """Read a single code file with line numbers
         
         Args:
-            args: Dictionary containing:
-                - filepath: Path to the file
-                - start_line: Start line number (optional)
-                - end_line: End line number (optional)
-                
+            filepath: Path to the file
+            start_line: Start line number (0-based, inclusive)
+            end_line: End line number (0-based, exclusive). -1 means read to end
+            
         Returns:
-            Dict containing:
-                - success: Boolean indicating success
-                - stdout: File content with line numbers
-                - stderr: Error message if any
+            Dict containing operation result
         """
         try:
-            filepath = args["filepath"].strip()
-            start_line = args.get("start_line", 0)
-            end_line = args.get("end_line", -1)
-            
-            # Record the operation and the full path
             abs_path = os.path.abspath(filepath)
             PrettyOutput.print(f"正在读取代码文件：{abs_path}", OutputType.INFO)
             
-            # Check if file exists
             if not os.path.exists(filepath):
                 return {
                     "success": False,
@@ -61,7 +61,6 @@ class ReadCodeTool:
                     "stderr": f"File does not exist: {filepath}"
                 }
                 
-            # Check file size
             if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
                 return {
                     "success": False,
@@ -69,7 +68,6 @@ class ReadCodeTool:
                     "stderr": "File too large (>10MB)"
                 }
                 
-            # Read file content
             try:
                 with open(filepath, 'r', encoding='utf-8') as f:
                     lines = f.readlines()
@@ -80,7 +78,6 @@ class ReadCodeTool:
                     "stderr": "Failed to decode file with UTF-8 encoding"
                 }
                 
-            # Validate line range
             if start_line < 0:
                 start_line = 0
             if end_line == -1 or end_line > len(lines):
@@ -92,16 +89,13 @@ class ReadCodeTool:
                     "stderr": f"Invalid line range: [{start_line}, {end_line})"
                 }
                 
-            # Format lines with hexadecimal line numbers
             formatted_lines = []
             for i, line in enumerate(lines[start_line:end_line]):
                 line_num = start_line + i
                 formatted_lines.append(f"{line_num:>5}:{line}")
                 
             content = "".join(formatted_lines)
-
-            output = f"File: {filepath}\nLines: [{start_line}, {end_line})\n{content}";
-            PrettyOutput.print(output, OutputType.CODE)
+            output = f"File: {filepath}\nLines: [{start_line}, {end_line})\n{content}"
             
             return {
                 "success": True,
@@ -115,3 +109,60 @@ class ReadCodeTool:
                 "stdout": "",
                 "stderr": f"Failed to read code: {str(e)}"
             }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute code reading for multiple files
+        
+        Args:
+            args: Dictionary containing:
+                - files: List of file info with path and optional line range
+                
+        Returns:
+            Dict containing:
+                - success: Boolean indicating overall success
+                - stdout: Combined output of all files as string
+                - stderr: Error message if any
+        """
+        try:
+            if "files" not in args or not isinstance(args["files"], list):
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "files parameter is required and must be a list"
+                }
+            
+            all_outputs = []
+            success = True
+            
+            for file_info in args["files"]:
+                if not isinstance(file_info, dict) or "path" not in file_info:
+                    continue
+                
+                result = self._read_single_file(
+                    file_info["path"],
+                    file_info.get("start_line", 0),
+                    file_info.get("end_line", -1)
+                )
+                
+                if result["success"]:
+                    all_outputs.append(result["stdout"])
+                    PrettyOutput.print(result["stdout"], OutputType.CODE)
+                else:
+                    all_outputs.append(f"Error reading {file_info['path']}: {result['stderr']}")
+                success = success and result["success"]
+            
+            # Combine all outputs with separators
+            combined_output = "\n\n" + "="*80 + "\n\n".join(all_outputs)
+            
+            return {
+                "success": success,
+                "stdout": combined_output,
+                "stderr": ""
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Failed to read code files: {str(e)}"
+            }

jarvis/jarvis_tools/registry.py

@@ -17,14 +17,14 @@ arguments:
     param2: value2
 </TOOL_CALL>
 
-Strict Rules:
-- Execute only one tool at a time
-- Tool execution must strictly follow the tool usage format
-- Wait for user to provide execution results
-- Don't assume or imagine results
-- Don't create fake dialogues
-- If current information is insufficient, you may ask the user for more information
-- Not all problem-solving steps are mandatory, skip as appropriate
+STRICT RULES:
+- EXECUTE ONLY ONE TOOL AT EVERY TURN
+- TOOL EXECUTION MUST STRICTLY FOLLOW THE TOOL USAGE FORMAT
+- WAIT FOR USER TO PROVIDE EXECUTION RESULTS
+- DON'T ASSUME OR IMAGINE RESULTS
+- DON'T CREATE FAKE DIALOGUES
+- IF CURRENT INFORMATION IS INSUFFICIENT, YOU MAY ASK THE USER FOR MORE INFORMATION
+- NOT ALL PROBLEM-SOLVING STEPS ARE MANDATORY, SKIP AS APPROPRIATE
 - Request user guidance when multiple iterations show no progress
 - ALWAYS use | syntax for string parameters to prevent parsing errors
     Example:
@@ -189,14 +189,10 @@ class ToolRegistry:
             return {"success": False, "stderr": f"Tool {name} does not exist, available tools: {', '.join(self.tools.keys())}", "stdout": ""}
         return tool.execute(arguments)
 
-    def handle_tool_calls(self, tool_calls: List[Dict]) -> str:
+    def handle_tool_calls(self, tool_call: Dict) -> str:
         """Handle tool calls, only process the first tool"""
         try:
-            if not tool_calls:
-                return ""
-                
             # Only process the first tool call
-            tool_call = tool_calls[0]
             name = tool_call["name"]
             args = tool_call["arguments"]
 
@@ -288,9 +284,6 @@ Please provide a summary:"""
             else:
                 PrettyOutput.section("执行失败", OutputType.WARNING)
                 PrettyOutput.print(result["stderr"], OutputType.WARNING)
-            
-            if len(tool_calls) > 1:
-                output += f"\n\n--- Only one tool can be executed at a time, the following tools were not executed\n{str(tool_calls[1:])} ---"
             return output
             
         except Exception as e:

jarvis/multi_agent.py

@@ -0,0 +1,76 @@
+
+
+from typing import Dict, List, Optional
+
+from jarvis.agent import Agent
+from jarvis.utils import OutputType, PrettyOutput
+
+
+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.tool_registry = config.get('tool_registry', [])
+        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.output_handler_before_tool = config.get('output_handler_before_tool')
+        self.output_handler_after_tool = config.get('output_handler_after_tool')
+        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:
+    def __init__(self, configs: List[AgentConfig], main_agent_name: str):
+        self.agents_config = configs
+        self.agents = {}
+        self.init_agents()
+        self.main_agent_name = main_agent_name
+
+    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,
+                          support_send_msg=True,
+                          execute_tool_confirm=agent_config.execute_tool_confirm,
+                          input_handler=agent_config.input_handler,
+                          output_handler_before_tool=agent_config.output_handler_before_tool,
+                          output_handler_after_tool=agent_config.output_handler_after_tool,
+                          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,
+                          tool_registry=agent_config.tool_registry,
+                          )
+            agent.system_prompt += "You can send message to following agents: " + "\n".join([f"{c.name}: {c.description}" for c in self.agents_config])
+            self.agents[agent_config.name] = agent
+
+    def run(self, user_input: str, file_list: Optional[List[str]] = None) -> str:
+        last_agent = self.main_agent_name
+        msg = self.agents[self.main_agent_name].run(user_input, file_list)
+        while msg:
+            if isinstance(msg, str):
+                return msg
+            elif isinstance(msg, Dict):
+                prompt  = f"""
+Please handle this message:
+from: {last_agent}
+content: {msg['content']}
+"""
+                if msg['to'] not in self.agents:
+                    PrettyOutput.print(f"没有找到{msg['to']}，重试...", OutputType.WARNING)
+                    msg = self.agents[last_agent].run(f"The agent {msg['to']} is not found, agent list: {self.agents.keys()}")
+                    continue
+                PrettyOutput.print(f"{last_agent} 发送消息给 {msg['to']}...", OutputType.INFO)
+                last_agent = self.agents[msg['to']]
+                msg = self.agents[msg['to']].run(prompt)
+        return ""

jarvis/utils.py

@@ -36,7 +36,8 @@ colorama.init()
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
-current_agent = []
+global_agents = set()
+current_agent_name = ""
 
 # Install rich traceback handler
 install_rich_traceback()
@@ -59,14 +60,28 @@ custom_theme = Theme({
 
 console = Console(theme=custom_theme)
 
-def add_agent(agent_name: str):
-    current_agent.append(agent_name)
+def make_agent_name(agent_name: str):
+    if agent_name in global_agents:
+        i = 1
+        while f"{agent_name}_{i}" in global_agents:
+            i += 1
+        return f"{agent_name}_{i}"
+    else:
+        return agent_name
+
+def set_agent(agent_name: str, agent: Any):
+    global_agents.add(agent_name)
+    global current_agent_name
+    current_agent_name = agent_name
 
 def get_agent_list():
-    return ']['.join(current_agent) if current_agent else "No Agent"
+    return "[" + str(len(global_agents)) + "]" + current_agent_name if global_agents else "No Agent"
 
-def delete_current_agent():
-    current_agent.pop()
+def delete_agent(agent_name: str):
+    if agent_name in global_agents:
+        global_agents.remove(agent_name)
+        global current_agent_name
+        current_agent_name = ""
 
 class OutputType(Enum):
     SYSTEM = "system"      # AI assistant message
@@ -156,7 +171,7 @@ class PrettyOutput:
         # Add timestamp and agent info
         if timestamp:
             formatted.append(f"[{datetime.now().strftime('%H:%M:%S')}] ", style="white")
-        formatted.append(f"[{get_agent_list()}]", style="blue")
+        formatted.append(f"{get_agent_list()}", style="blue")
         # Add icon
         icon = PrettyOutput._ICONS.get(output_type, "")
         formatted.append(f"{icon} ", style=output_type.value)
@@ -212,7 +227,7 @@ class PrettyOutput:
             border_style=styles[output_type],
             title=header,
             title_align="left",
-            padding=(1, 2),
+            padding=(1, 1),
             highlight=True
         )
         
@@ -426,7 +441,7 @@ def has_uncommitted_changes():
     working_changes = os.popen("git diff --exit-code").read().strip() != ""
     # Check staged changes
     staged_changes = os.popen("git diff --cached --exit-code").read().strip() != ""
-    os.system("git reset HEAD")
+    os.system("git reset")
     return working_changes or staged_changes
 
 def load_embedding_model():

{jarvis_ai_assistant-0.1.113.dist-info → jarvis_ai_assistant-0.1.115.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.113
+Version: 0.1.115
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire