jarvis-ai-assistant 0.1.99__py3-none-any.whl → 0.1.101__py3-none-any.whl

jarvis/jarvis_smart_shell/main.py

@@ -8,24 +8,26 @@ from yaspin import yaspin # type: ignore
 from yaspin.spinners import Spinners # type: ignore
 
 from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_env_from_file
+from jarvis.utils import PrettyOutput, OutputType, init_env
 
 def execute_command(command: str) -> None:
     """Show command and allow user to edit, then execute, Ctrl+C to cancel"""
     try:
+        print("\nGenerated command (can be edited, press Enter to execute, Ctrl+C to cancel):")
         # Pre-fill input line
         readline.set_startup_hook(lambda: readline.insert_text(command))
         try:
-            edited_command = get_single_line_input("Generated command (can be edited, press Enter to execute, Ctrl+C to cancel)")
+            edited_command = input("> ")
             if edited_command.strip():  # Ensure command is not empty
                 os.system(edited_command)
         except KeyboardInterrupt:
-            PrettyOutput.print("Execution cancelled", OutputType.INFO)
+            print("\nExecution cancelled")
         finally:
             readline.set_startup_hook()  # Clear pre-filled
     except Exception as e:
         PrettyOutput.print(f"Failed to execute command: {str(e)}", OutputType.ERROR)
 
+
 def process_request(request: str) -> Optional[str]:
     """Process user request and return corresponding shell command
     
@@ -88,7 +90,7 @@ Remember: Only return the command itself, without any additional content.
 
 def main():
     # 创建参数解析器
-    load_env_from_file()
+    init_env()
     parser = argparse.ArgumentParser(
         description="Convert natural language requirements to shell commands",
         formatter_class=argparse.RawDescriptionHelpFormatter,

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/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

@@ -26,7 +26,7 @@ class PlatformRegistry:
 
     @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)
@@ -137,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")
@@ -212,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

@@ -39,16 +39,19 @@ class AskUserTool:
             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

@@ -51,5 +51,6 @@ class CodeSubAgentTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Failed to execute code development subtask: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to execute code development subtask: {str(e)}"
             }

jarvis/tools/create_sub_agent.py

@@ -81,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

@@ -43,7 +43,7 @@ class CodeModifyTool:
             patch_handler = PatchHandler()
 
             # Apply patches and handle the process
-            success = patch_handler.handle_patch_application(
+            success, additional_info = patch_handler.handle_patch_application(
                 feature=task,
                 structed_plan=structured_plan
             )
@@ -51,22 +51,20 @@ class CodeModifyTool:
             if not success:
                 return {
                     "success": False,
-                    "error": "Code modification was cancelled or failed",
                     "stdout": "Changes have been rolled back",
-                    "stderr": ""
+                    "stderr": additional_info
                 }
 
             return {
                 "success": True,
                 "stdout": "Code modifications have been successfully applied and committed",
-                "stderr": ""
+                "stderr": additional_info
             }
 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"Failed to execute code modifications: {str(e)}",
                 "stdout": "",
-                "stderr": str(e)
+                "stderr": f"Failed to execute code modifications: {str(e)}"
             }

jarvis/tools/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_operation.py

@@ -57,14 +57,16 @@ 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": "File too large (>10MB)"
+                        "stdout": "",
+                        "stderr": "File too large (>10MB)"
                     }
                     
                 content = open(filepath, 'r', encoding=encoding).read()
@@ -79,7 +81,8 @@ class FileOperationTool:
                 if not args.get("content"):
                     return {
                         "success": False,
-                        "error": "Write/append operation requires providing the content parameter"
+                        "stdout": "",
+                        "stderr": "Write/append operation requires providing the content parameter"
                     }
                 
                 # Create directory (if it doesn't exist)
@@ -98,12 +101,14 @@ class FileOperationTool:
             else:
                 return {
                     "success": False,
-                    "error": f"Unknown operation: {operation}"
+                    "stdout": "",
+                    "stderr": f"Unknown operation: {operation}"
                 }
                 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"File operation failed: {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)}"
+            }

jarvis/tools/generate_tool.py

@@ -32,16 +32,15 @@ class ToolGeneratorTool:
     }
 
     def __init__(self):
-        """初始化工具生成器
-        """
-        # 设置工具目录
-        self.tools_dir = Path.home() / '.jarvis_tools'
+        """Initialize tool generator"""
+        # Set tool directory
+        self.tools_dir = Path.home() / '.jarvis/tools'
         
-        # 确保工具目录存在
+        # Ensure tool directory exists
         self.tools_dir.mkdir(parents=True, exist_ok=True)
 
     def _generate_tool_code(self, tool_name: str, class_name: str, description: str, parameters: Dict) -> str:
-        """使用大模型生成工具代码"""
+        """Use large model to generate tool code"""
         model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
 
         prompt = f"""Please generate the code for a Python tool class, with the following requirements, and do not output any content except the code:
@@ -96,36 +95,37 @@ class ExampleTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {{
                 "success": False,
-                "error": str(e)
+                "stdout": "",
+                "stderr": str(e)
             }}
 ```"""
 
-        # 调用模型生成代码
+        # Call model to generate code
         response = model.chat_until_success(prompt)
 
-        # 提取代码块
+        # Extract code block
         code_start = response.find("```python")
         code_end = response.find("```", code_start + 9)
         
         if code_start == -1 or code_end == -1:
-            # 如果没有找到代码块标记，假设整个响应都是代码
+            # If code block marker not found, assume the entire response is code
             return response
         
-        # 提取代码块内容（去掉```python和```标记）
+        # Extract code block content (remove ```python and ``` markers)
         code = response[code_start + 9:code_end].strip()
         return code
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """生成工具代码"""
+        """Generate tool code"""
         try:
             tool_name = args["tool_name"]
             class_name = args["class_name"]
             description = args["description"]
             parameters = args["parameters"]
 
-            PrettyOutput.print(f"开始生成工具: {tool_name}", OutputType.INFO)
+            PrettyOutput.print(f"Start generating tool: {tool_name}", OutputType.INFO)
 
-            # 生成工具代码
+            # Generate tool code
             tool_code = self._generate_tool_code(
                 tool_name,
                 class_name,
@@ -133,34 +133,35 @@ class ExampleTool:
                 parameters
             )
 
-            # 获取工具文件路径
+            # Get tool file path
             tool_file = self.tools_dir / f"{tool_name}.py"
 
-            # 写入工具文件
+            # Write tool file
             with open(tool_file, "w", encoding="utf-8") as f:
                 f.write(tool_code)
 
-            # 创建或更新 __init__.py
+            # Create or update __init__.py
             init_file = self.tools_dir / "__init__.py"
             if not init_file.exists():
                 with open(init_file, "w", encoding="utf-8") as f:
                     f.write("# Jarvis Tools\n")
 
-            # 注册工具
+            # Register tool
             success = ToolRegistry.get_global_tool_registry().register_tool_by_file(str(tool_file))
             if not success:
                 return {
                     "success": False,
-                    "error": "工具生成成功但注册失败"
+                    "stdout": "",
+                    "stderr": "Tool generated successfully but registration failed"
                 }
 
             return {
                 "success": True,
-                "stdout": f"工具已生成并注册到Jarvis\n"
-                         f"工具目录: {self.tools_dir}\n"
-                         f"工具名称: {tool_name}\n"
-                         f"工具描述: {description}\n"
-                         f"工具参数: {parameters}",
+                "stdout": f"Tool generated and registered to Jarvis\n"
+                         f"Tool directory: {self.tools_dir}\n"
+                         f"Tool name: {tool_name}\n"
+                         f"Tool description: {description}\n"
+                         f"Tool parameters: {parameters}",
                 "stderr": ""
             }
 
@@ -168,5 +169,6 @@ class ExampleTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"生成工具失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to generate tool: {str(e)}"
             }

jarvis/tools/methodology.py

@@ -32,7 +32,7 @@ class MethodologyTool:
     
     def __init__(self):
         """Initialize the experience management tool"""
-        self.methodology_file = os.path.expanduser("~/.jarvis_methodology")
+        self.methodology_file = os.path.expanduser("~/.jarvis/methodology")
         self._ensure_file_exists()
             
     def _ensure_file_exists(self):
@@ -80,7 +80,8 @@ class MethodologyTool:
         if not operation or not problem_type:
             return {
                 "success": False,
-                "error": "Missing required parameters: operation and problem_type"
+                "stdout": "",
+                "stderr": "Missing required parameters: operation and problem_type"
             }
             
         methodologies = self._load_methodologies()
@@ -97,14 +98,16 @@ class MethodologyTool:
                 else:
                     return {
                         "success": False,
-                        "error": f"Methodology for problem type '{problem_type}' not found"
+                        "stdout": "",
+                        "stderr": f"Methodology for problem type '{problem_type}' not found"
                     }
                     
             elif operation in ["update", "add"]:
                 if not content:
                     return {
                         "success": False,
-                        "error": "Need to provide methodology content"
+                        "stdout": "",
+                        "stderr": "Need to provide methodology content"
                     }
                     
                 methodologies[problem_type] = content
@@ -113,19 +116,22 @@ class MethodologyTool:
                 action = "Update" if problem_type in methodologies else "Add"
                 return {
                     "success": True,
-                    "stdout": f"{action} methodology for problem type '{problem_type}'"
+                    "stdout": f"{action} methodology for problem type '{problem_type}'",
+                    "stderr": ""
                 }
                 
             else:
                 return {
                     "success": False,
-                    "error": f"Unsupported operation type: {operation}"
+                    "stdout": "",
+                    "stderr": f"Unsupported operation type: {operation}"
                 }
                 
         except Exception as e:
             return {
                 "success": False,
-                "error": f"Execution failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
             }
             
     def get_methodology(self, problem_type: str) -> Optional[str]: