jarvis-ai-assistant 0.1.98__py3-none-any.whl → 0.1.100__py3-none-any.whl

jarvis/models/kimi.py

@@ -35,8 +35,8 @@ class KimiModel(BasePlatform):
             PrettyOutput.print("   • Find the Authorization header in the request", OutputType.INFO)
             PrettyOutput.print("   • Copy the token value (remove the 'Bearer ' prefix)", OutputType.INFO)
             PrettyOutput.print("\n2. Set environment variable:", OutputType.INFO)
-            PrettyOutput.print("   • Method 1: Create or edit ~/.jarvis_env file:", OutputType.INFO)
-            PrettyOutput.print("   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis_env", OutputType.INFO)
+            PrettyOutput.print("   • Method 1: Create or edit ~/.jarvis/env file:", OutputType.INFO)
+            PrettyOutput.print("   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis/env", OutputType.INFO)
             PrettyOutput.print("\n   • Method 2: Set environment variable directly:", OutputType.INFO)
             PrettyOutput.print("   export KIMI_API_KEY=your_key_here", OutputType.INFO)
             PrettyOutput.print("\nAfter setting, run Jarvis again.", OutputType.INFO)

jarvis/models/ollama.py

@@ -1,7 +1,7 @@
 import requests
 from typing import List, Dict, Tuple
 from jarvis.models.base import BasePlatform
-from jarvis.utils import OutputType, PrettyOutput
+from jarvis.utils import OutputType, PrettyOutput, get_single_line_input
 import os
 import json
 
@@ -136,7 +136,7 @@ if __name__ == "__main__":
         ollama = OllamaPlatform()
         while True:
             try:
-                message = input("\nInput question (Ctrl+C to exit): ")
+                message = get_single_line_input("\nInput question (Ctrl+C to exit)")
                 ollama.chat_until_success(message)
             except KeyboardInterrupt:
                 print("\nGoodbye!")

jarvis/models/openai.py

@@ -23,7 +23,7 @@ class OpenAIModel(BasePlatform):
             PrettyOutput.print("  • OPENAI_API_KEY: API key", OutputType.INFO)
             PrettyOutput.print("  • OPENAI_API_BASE: (optional) API base address, default using https://api.openai.com/v1", OutputType.INFO)
             PrettyOutput.print("\nYou can set them in the following ways:", OutputType.INFO)
-            PrettyOutput.print("1. Create or edit ~/.jarvis_env file:", OutputType.INFO)
+            PrettyOutput.print("1. Create or edit ~/.jarvis/env file:", OutputType.INFO)
             PrettyOutput.print("   OPENAI_API_KEY=your_api_key", OutputType.INFO)
             PrettyOutput.print("   OPENAI_API_BASE=your_api_base", OutputType.INFO)
             PrettyOutput.print("   OPENAI_MODEL_NAME=your_model_name", OutputType.INFO)

jarvis/models/registry.py

@@ -3,8 +3,8 @@ import inspect
 import os
 import sys
 from typing import Dict, Type, Optional, List
-from .base import BasePlatform
-from ..utils import PrettyOutput, OutputType
+from jarvis.models.base import BasePlatform
+from jarvis.utils import PrettyOutput, OutputType
 
 REQUIRED_METHODS = [
     ('chat', ['message']),           # 方法名和参数列表
@@ -23,11 +23,10 @@ class PlatformRegistry:
 
     global_platform_name = "kimi"
     global_platform_registry = None
-    suppress_output = False
 
     @staticmethod
     def get_platform_dir() -> str:
-        user_platform_dir = os.path.expanduser("~/.jarvis_models")
+        user_platform_dir = os.path.expanduser("~/.jarvis/models")
         if not os.path.exists(user_platform_dir):
             try:
                 os.makedirs(user_platform_dir)
@@ -117,7 +116,7 @@ class PlatformRegistry:
                         module = importlib.import_module(module_name)
                     
                     # 遍历模块中的所有类
-                    for name, obj in inspect.getmembers(module):
+                    for _, obj in inspect.getmembers(module):
                         # 检查是否是BasePlatform的子类，但不是BasePlatform本身
                         if (inspect.isclass(obj) and 
                             issubclass(obj, BasePlatform) and 
@@ -126,8 +125,6 @@ class PlatformRegistry:
                             # 检查平台实现
                             if not PlatformRegistry.check_platform_implementation(obj):
                                 continue
-                            if not PlatformRegistry.suppress_output:
-                                PrettyOutput.print(f"Load platform from {os.path.join(directory, filename)}: {obj.platform_name}", OutputType.SUCCESS) # type: ignore
                             platforms[obj.platform_name] = obj # type: ignore
                             break
                 except Exception as e:
@@ -140,22 +137,22 @@ class PlatformRegistry:
     def get_global_platform_registry():
         """Get global platform registry"""
         if PlatformRegistry.global_platform_registry is None:
-            PlatformRegistry.global_platform_registry = PlatformRegistry()
-            
-            # 从用户平台目录加载额外平台
-            platform_dir = PlatformRegistry.get_platform_dir()
-            if platform_dir and os.path.exists(platform_dir):
-                for platform_name, platform_class in PlatformRegistry.load_platform_from_dir(platform_dir).items():
-                    PlatformRegistry.global_platform_registry.register_platform(platform_name, platform_class)
-            platform_dir = os.path.dirname(__file__)
-            if platform_dir and os.path.exists(platform_dir):
-                for platform_name, platform_class in PlatformRegistry.load_platform_from_dir(platform_dir).items():
-                    PlatformRegistry.global_platform_registry.register_platform(platform_name, platform_class)
+            PlatformRegistry.global_platform_registry = PlatformRegistry()  
         return PlatformRegistry.global_platform_registry
     
     def __init__(self):
         """Initialize platform registry"""
         self.platforms: Dict[str, Type[BasePlatform]] = {}
+        # 从用户平台目录加载额外平台
+        platform_dir = PlatformRegistry.get_platform_dir()
+        if platform_dir and os.path.exists(platform_dir):
+            for platform_name, platform_class in PlatformRegistry.load_platform_from_dir(platform_dir).items():
+                self.register_platform(platform_name, platform_class)
+        platform_dir = os.path.dirname(__file__)
+        if platform_dir and os.path.exists(platform_dir):
+            for platform_name, platform_class in PlatformRegistry.load_platform_from_dir(platform_dir).items():
+                self.register_platform(platform_name, platform_class)
+        
 
     def get_normal_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_PLATFORM", "kimi")
@@ -215,6 +212,29 @@ class PlatformRegistry:
             PrettyOutput.print(f"Create platform failed: {str(e)}", OutputType.ERROR)
             return None
             
+    def use_platforms(self, platform_names: List[str]):
+        """Restrict available platforms to the specified list
+        
+        Args:
+            platform_names: List of platform names to use
+        """
+        self.platforms = {
+            name: cls 
+            for name, cls in self.platforms.items()
+            if name in platform_names
+        }
+
+    def dont_use_platforms(self, platform_names: List[str]):
+        """Restrict available platforms by excluding the specified list
+        
+        Args:
+            platform_names: List of platform names to exclude
+        """
+        self.platforms = {
+            name: cls 
+            for name, cls in self.platforms.items()
+            if name not in platform_names
+        }
     def get_available_platforms(self) -> List[str]:
         """Get available platform list"""
         return list(self.platforms.keys()) 

jarvis/tools/ask_user.py

@@ -18,37 +18,40 @@ class AskUserTool:
         
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行询问用户操作
+        """Execute the operation of asking the user
         
         Args:
-            args: 包含问题的字典
+            args: A dictionary containing the question
             
         Returns:
-            Dict: 包含用户响应的字典
+            Dict: A dictionary containing the user's response
         """
         try:
             question = args["question"]
             
-            # 显示问题
-            PrettyOutput.print("\n问题:", OutputType.SYSTEM)
+            # Display the question
+            PrettyOutput.print("\nQuestion:", OutputType.SYSTEM)
             PrettyOutput.print(question, OutputType.SYSTEM)
             
-            # 获取用户输入
+            # Get user input
             user_response = get_multiline_input("Please enter your answer (input empty line to end)")
             
             if user_response == "__interrupt__":
                 return {
                     "success": False,
-                    "error": "User canceled input"
+                    "stdout": "",
+                    "stderr": "User canceled input"
                 }
             
             return {
                 "success": True,
-                "stdout": user_response
+                "stdout": user_response,
+                "stderr": ""
             }
             
         except Exception as e:
             return {
                 "success": False,
-                "error": f"Failed to ask user: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to ask user: {str(e)}"
             } 

jarvis/tools/chdir.py

@@ -38,14 +38,16 @@ class ChdirTool:
             if not os.path.exists(path):
                 return {
                     "success": False,
-                    "error": f"Directory does not exist: {path}"
+                    "stdout": "",
+                    "stderr": f"Directory does not exist: {path}"
                 }
                 
             # 检查是否是目录
             if not os.path.isdir(path):
                 return {
                     "success": False,
-                    "error": f"The path is not a directory: {path}"
+                    "stdout": "",
+                    "stderr": f"The path is not a directory: {path}"
                 }
                 
             # 尝试切换目录
@@ -61,12 +63,14 @@ class ChdirTool:
         except PermissionError:
             return {
                 "success": False,
-                "error": f"No permission to access directory: {path}"
+                "stdout": "",
+                "stderr": f"No permission to access directory: {path}"
             }
         except Exception as e:
             return {
                 "success": False,
-                "error": f"Failed to switch directory: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to switch directory: {str(e)}"
             }
             
 def main():
@@ -83,7 +87,7 @@ def main():
     if result["success"]:
         PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
     else:
-        PrettyOutput.print(result["error"], OutputType.ERROR)
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
         
 if __name__ == "__main__":
     main() 

jarvis/tools/create_code_sub_agent.py

@@ -0,0 +1,56 @@
+from typing import Dict, Any
+
+from jarvis.agent import Agent
+from jarvis.utils import OutputType, PrettyOutput
+from jarvis.jarvis_code_agent.main import system_prompt
+
+
+class CodeSubAgentTool:
+    name = "create_code_sub_agent"
+    description = "Create a sub-agent to handle specific code development subtasks"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "The name of the sub-agent"
+            },
+            "subtask": {
+                "type": "string",
+                "description": "The specific code development subtask to complete"
+            },
+        },
+        "required": ["subtask", "name"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute code development subtask"""
+        try:
+            subtask = args["subtask"]
+            name = args["name"]
+
+            PrettyOutput.print(f"Creating code sub-agent {name} for subtask: {subtask}", OutputType.INFO)
+
+            # Create sub-agent
+            sub_agent = Agent(
+                system_prompt=system_prompt,
+                name=name,
+                is_sub_agent=True
+            )
+
+            # Execute subtask
+            result = sub_agent.run(subtask)
+
+            return {
+                "success": True,
+                "stdout": f"Code Development Subtask Results:\n\n{result}",
+                "stderr": ""
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Failed to execute code development subtask: {str(e)}"
+            }

jarvis/tools/{sub_agent.py → create_sub_agent.py}

@@ -1,7 +1,7 @@
 from typing import Dict, Any
 
 
-from jarvis.agent import Agent
+from jarvis.agent import Agent, origin_agent_system_prompt
 from jarvis.utils import OutputType, PrettyOutput
 
 
@@ -58,8 +58,11 @@ class SubAgentTool:
             if goal:
                 task_description += f"\n\nCompletion goal:\n{goal}"
 
+            
+
             # Create sub-agent
             sub_agent = Agent(
+                system_prompt=origin_agent_system_prompt,
                 name=agent_name,
                 is_sub_agent=True
             )
@@ -78,5 +81,6 @@ class SubAgentTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Sub-agent execution failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Sub-agent execution failed: {str(e)}"
             } 

jarvis/tools/execute_code_modification.py

@@ -0,0 +1,70 @@
+from typing import Dict, Any
+
+from jarvis.agent import Agent
+from jarvis.utils import OutputType, PrettyOutput
+from jarvis.jarvis_coder.patch_handler import PatchHandler
+
+
+class CodeModifyTool:
+    name = "execute_code_modification"
+    description = "Execute code modifications according to the provided plan"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "task": {
+                "type": "string",
+                "description": "The code modification task description"
+            },
+            "structured_plan": {
+                "type": "object",
+                "description": "Dictionary mapping file paths to their modification plans. Example: {'path/to/file.py': 'Add function foo() to handle...'}", 
+                "additionalProperties": {
+                    "type": "string",
+                    "description": "Modification plan for a specific file"
+                },
+                "examples": [{
+                    "src/file1.py": "Add error handling to process_data()",
+                    "src/file2.py": "Update API endpoint URL in get_data()"
+                }]
+            }
+        },
+        "required": ["task", "raw_plan", "structured_plan"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute code modifications using PatchHandler"""
+        try:
+            task = args["task"]
+            structured_plan = args["structured_plan"]
+
+            PrettyOutput.print("Executing code modifications...", OutputType.INFO)
+
+            # Create patch handler instance
+            patch_handler = PatchHandler()
+
+            # Apply patches and handle the process
+            success, additional_info = patch_handler.handle_patch_application(
+                feature=task,
+                structed_plan=structured_plan
+            )
+
+            if not success:
+                return {
+                    "success": False,
+                    "stdout": "Changes have been rolled back",
+                    "stderr": additional_info
+                }
+
+            return {
+                "success": True,
+                "stdout": "Code modifications have been successfully applied and committed",
+                "stderr": additional_info
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Failed to execute code modifications: {str(e)}"
+            }

jarvis/tools/{shell.py → execute_shell.py}

@@ -64,7 +64,6 @@ class ShellTool:
                 "success": return_code == 0,
                 "stdout": output,
                 "stderr": "",
-                "return_code": return_code
             }
                 
         except Exception as e:
@@ -74,5 +73,6 @@ class ShellTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": str(e)
+                "stdout": "",
+                "stderr": str(e)
             } 

jarvis/tools/{file_ops.py → file_operation.py}

@@ -1,6 +1,5 @@
-from typing import Dict, Any, Protocol
+from typing import Dict, Any
 import os
-from enum import Enum
 
 from jarvis.utils import OutputType, PrettyOutput
 
@@ -36,15 +35,15 @@ class FileOperationTool:
 
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行文件操作"""
+        """Execute file operations"""
         try:
             operation = args["operation"]
             filepath = args["filepath"]
             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)
+            PrettyOutput.print(f"File operation: {operation} - {abs_path}", OutputType.INFO)
             
             if operation == "exists":
                 exists = os.path.exists(filepath)
@@ -58,18 +57,20 @@ class FileOperationTool:
                 if not os.path.exists(filepath):
                     return {
                         "success": False,
-                        "error": f"文件不存在: {filepath}"
+                        "stdout": "",
+                        "stderr": f"文件不存在: {filepath}"
                     }
                     
-                # 检查文件大小
+                # Check file size
                 if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
                     return {
                         "success": False,
-                        "error": "文件过大 (>10MB)"
+                        "stdout": "",
+                        "stderr": "File too large (>10MB)"
                     }
                     
-                with open(filepath, 'r', encoding=encoding) as f:
-                    content = f.read()
+                content = open(filepath, 'r', encoding=encoding).read()
+                PrettyOutput.print(content, OutputType.INFO)
                 return {
                     "success": True,
                     "stdout": content,
@@ -80,10 +81,11 @@ class FileOperationTool:
                 if not args.get("content"):
                     return {
                         "success": False,
-                        "error": "写入/追加操作需要提供content参数"
+                        "stdout": "",
+                        "stderr": "Write/append operation requires providing the content parameter"
                     }
                 
-                # 创建目录（如果不存在）
+                # Create directory (if it doesn't exist)
                 os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
                     
                 mode = 'a' if operation == "append" else 'w'
@@ -92,19 +94,21 @@ class FileOperationTool:
                     
                 return {
                     "success": True,
-                    "stdout": f"成功{operation}内容到 {filepath}",
+                    "stdout": f"Successfully {operation} content to {filepath}",
                     "stderr": ""
                 }
                 
             else:
                 return {
                     "success": False,
-                    "error": f"未知操作: {operation}"
+                    "stdout": "",
+                    "stderr": f"Unknown operation: {operation}"
                 }
                 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"文件操作失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"File operation failed: {str(e)}"
             } 

jarvis/tools/find_files.py

@@ -0,0 +1,119 @@
+from typing import Dict, Any
+
+from jarvis.agent import Agent
+from jarvis.tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput
+
+find_files_system_prompt = """You are a Find Files Agent specialized in searching and identifying relevant code files in a codebase. Your task is to find files that are most likely related to the given requirements or problems.
+
+SEARCH WORKFLOW:
+1. Understand Search Requirements
+   - Analyze the search query thoroughly
+   - Identify key technical terms and concepts
+   - Break down complex requirements into searchable terms
+
+2. Execute Search Strategy
+   - Use shell commands to search systematically:
+     * Search for key terms:
+       <TOOL_CALL>
+       name: execute_shell
+       arguments:
+           command: grep -r "pattern" .
+       </TOOL_CALL>
+     * Find files by name patterns:
+       <TOOL_CALL>
+       name: execute_shell
+       arguments:
+           command: find . -name "pattern"
+       </TOOL_CALL>
+     * Examine file contents:
+       <TOOL_CALL>
+       name: execute_shell
+       arguments:
+           command: grep -A 5 -B 5 "pattern" file.py
+       </TOOL_CALL>
+
+3. Analyze Results
+   - Review each potential file
+   - Check file relevance
+   - Examine file relationships
+   - Consider file dependencies
+
+4. Generate File List
+   - List all relevant files
+   - Sort by relevance
+   - Include brief explanation for each file
+   - Format output as YAML
+
+OUTPUT FORMAT:
+files:
+  - path: path/to/file1
+    relevance: "Brief explanation of why this file is relevant"
+  - path: path/to/file2
+    relevance: "Brief explanation of why this file is relevant"
+
+SEARCH BEST PRACTICES:
+- Use multiple search terms
+- Consider file naming conventions
+- Check both file names and contents
+- Look for related files (imports, dependencies)
+- Use grep with context (-A, -B options)
+- Search in specific directories when appropriate
+- Exclude irrelevant directories (like .git, __pycache__)
+
+IMPORTANT:
+1. Focus on finding the most relevant files
+2. Avoid listing irrelevant files
+3. Explain relevance clearly but concisely
+4. Consider both direct and indirect relevance
+5. Use file content to confirm relevance
+"""
+
+class FindFilesTool:
+    name = "find_files"
+    description = "Search and identify relevant code files in the codebase based on requirements or problems"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The search query or requirement description"
+            }
+        },
+        "required": ["query"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute file search task"""
+        try:
+            query = args["query"]
+
+            PrettyOutput.print(f"Creating Find Files agent to search for: {query}", OutputType.INFO)
+
+            tool_registry = ToolRegistry()
+            tool_registry.use_tools(["ask_user", "execute_shell", "file_operation"])
+
+            # Create find files agent
+            find_agent = Agent(
+                system_prompt=find_files_system_prompt,
+                name="Find Files Agent",
+                is_sub_agent=True,
+                tool_registry=tool_registry
+            )
+
+            # Execute search
+            result = find_agent.run(query)
+
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Failed to execute file search: {str(e)}"
+            }