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

jarvis/jarvis_smart_shell/main.py

@@ -4,48 +4,46 @@ import os
 import sys
 import readline
 from typing import Optional
-from yaspin import yaspin
-from yaspin.spinners import Spinners
+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, load_env_from_file
+from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_env_from_file
 
 def execute_command(command: str) -> None:
-    """显示命令并允许用户编辑，回车执行，Ctrl+C取消"""
+    """Show command and allow user to edit, then execute, Ctrl+C to cancel"""
     try:
-        print("\n生成的命令 (可以编辑，回车执行，Ctrl+C取消):")
-        # 预填充输入行
+        # Pre-fill input line
         readline.set_startup_hook(lambda: readline.insert_text(command))
         try:
-            edited_command = input("> ")
-            if edited_command.strip():  # 确保命令不为空
+            edited_command = get_single_line_input("Generated command (can be edited, press Enter to execute, Ctrl+C to cancel)")
+            if edited_command.strip():  # Ensure command is not empty
                 os.system(edited_command)
         except KeyboardInterrupt:
-            print("\n已取消执行")
+            PrettyOutput.print("Execution cancelled", OutputType.INFO)
         finally:
-            readline.set_startup_hook()  # 清除预填充
+            readline.set_startup_hook()  # Clear pre-filled
     except Exception as e:
-        PrettyOutput.print(f"执行命令时发生错误: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Failed to execute command: {str(e)}", OutputType.ERROR)
 
 def process_request(request: str) -> Optional[str]:
-    """处理用户请求并返回对应的shell命令
+    """Process user request and return corresponding shell command
     
     Args:
-        request: 用户的自然语言请求
+        request: User's natural language request
         
     Returns:
-        Optional[str]: 对应的shell命令，如果处理失败则返回None
+        Optional[str]: Corresponding shell command, return None if processing fails
     """
     try:
-        # 获取语言模型实例
-        PlatformRegistry.suppress_output = True
+        # Get language model instance
         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
         model.set_suppress_output(True)
 
         shell = os.environ.get("SHELL") or "bash"
         current_path = os.getcwd()
         
-        # 设置系统提示
+        # Set system prompt
         system_message = f"""You are a shell command generation assistant.
 
 Your only task is to convert user's natural language requirements into corresponding shell commands.
@@ -85,26 +83,26 @@ Remember: Only return the command itself, without any additional content.
             return None
         
     except Exception as e:
-        PrettyOutput.print(f"处理请求时发生错误: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Failed to process request: {str(e)}", OutputType.ERROR)
         return None
 
 def main():
     # 创建参数解析器
     load_env_from_file()
     parser = argparse.ArgumentParser(
-        description="将自然语言需求转换为shell命令",
+        description="Convert natural language requirements to shell commands",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-示例:
-  %(prog)s "查找当前目录下所有的Python文件"
-  %(prog)s "压缩所有jpg图片"
-  %(prog)s "查找最近一周修改过的文档"
+Example:
+  %(prog)s "Find all Python files in the current directory"
+  %(prog)s "Compress all jpg images"
+  %(prog)s "Find documents modified in the last week"
 """)
     
     # 添加参数
     parser.add_argument(
         "request",
-        help="用自然语言描述你需要执行的操作"
+        help="Describe the operation you want to perform in natural language"
     )
     
     # 解析参数

jarvis/models/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+import re
 from typing import Dict, List, Tuple
 
 from jarvis.utils import OutputType, PrettyOutput, while_success, while_true
@@ -26,7 +27,11 @@ class BasePlatform(ABC):
         raise NotImplementedError("chat is not implemented")
 
     def chat_until_success(self, message: str) -> str:
-        return while_true(lambda: while_success(lambda: self.chat(message), 5), 5)
+        def _chat():
+            response = self.chat(message)
+            response = re.sub(r'<think>(.*?)</think>', '', response, flags=re.DOTALL)
+            return response
+        return while_true(lambda: while_success(lambda: _chat(), 5), 5)
 
     @abstractmethod
     def upload_files(self, file_list: List[str]) -> List[Dict]:

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/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,7 +23,6 @@ class PlatformRegistry:
 
     global_platform_name = "kimi"
     global_platform_registry = None
-    suppress_output = False
 
     @staticmethod
     def get_platform_dir() -> str:
@@ -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:

jarvis/tools/ask_user.py

@@ -18,22 +18,22 @@ 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__":

jarvis/tools/codebase_qa.py

@@ -4,7 +4,7 @@ from jarvis.jarvis_codebase.main import CodeBase
 from jarvis.utils import find_git_root, PrettyOutput, OutputType
 
 class CodebaseQATool:
-    """代码库问答工具，用于回答关于代码库的问题"""
+    """Codebase QA Tool"""
     
     name = "codebase_qa"
     description = "Answer questions about the codebase, can query and understand code functionality, structure, and implementation details"
@@ -29,7 +29,7 @@ class CodebaseQATool:
     }
     
     def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """执行代码问答"""
+        """Execute codebase QA"""
         try:
             dir = params.get("dir")
             question = params["question"]
@@ -42,7 +42,7 @@ class CodebaseQATool:
                 return {
                     "success": False,
                     "stdout": "",
-                    "stderr": "错误：当前目录不在Git仓库中",
+                    "stderr": "Error: Current directory is not in a Git repository",
                     "error": "NotInGitRepository"
                 }
 
@@ -62,13 +62,11 @@ class CodebaseQATool:
             }
             
         except Exception as e:
-            PrettyOutput.print(f"代码问答出错: {str(e)}", output_type=OutputType.ERROR)
+            PrettyOutput.print(f"Codebase QA error: {str(e)}", output_type=OutputType.ERROR)
             return {
                 "success": False,
                 "stdout": "",
-                "stderr": f"执行代码问答时发生错误: {str(e)}",
+                "stderr": f"Error executing codebase QA: {str(e)}",
                 "error": str(type(e).__name__)
             }
 
-def register():
-    return CodebaseQATool() 

jarvis/tools/create_code_sub_agent.py

@@ -0,0 +1,55 @@
+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,
+                "error": 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
             )

jarvis/tools/execute_code_modification.py

@@ -0,0 +1,72 @@
+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 = patch_handler.handle_patch_application(
+                feature=task,
+                structed_plan=structured_plan
+            )
+
+            if not success:
+                return {
+                    "success": False,
+                    "error": "Code modification was cancelled or failed",
+                    "stdout": "Changes have been rolled back",
+                    "stderr": ""
+                }
+
+            return {
+                "success": True,
+                "stdout": "Code modifications have been successfully applied and committed",
+                "stderr": ""
+            }
+
+        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)
+            }

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)
@@ -61,15 +60,15 @@ class FileOperationTool:
                         "error": f"文件不存在: {filepath}"
                     }
                     
-                # 检查文件大小
+                # Check file size
                 if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
                     return {
                         "success": False,
-                        "error": "文件过大 (>10MB)"
+                        "error": "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 +79,10 @@ class FileOperationTool:
                 if not args.get("content"):
                     return {
                         "success": False,
-                        "error": "写入/追加操作需要提供content参数"
+                        "error": "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 +91,19 @@ class FileOperationTool:
                     
                 return {
                     "success": True,
-                    "stdout": f"成功{operation}内容到 {filepath}",
+                    "stdout": f"Successfully {operation} content to {filepath}",
                     "stderr": ""
                 }
                 
             else:
                 return {
                     "success": False,
-                    "error": f"未知操作: {operation}"
+                    "error": f"Unknown operation: {operation}"
                 }
                 
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"文件操作失败: {str(e)}"
+                "error": f"File operation failed: {str(e)}"
             } 

jarvis/tools/find_related_files.py

@@ -0,0 +1,86 @@
+import os
+from typing import Any, Dict
+from jarvis.jarvis_codebase.main import CodeBase
+from jarvis.utils import find_git_root, PrettyOutput, OutputType
+
+class CodebaseSearchTool:
+    """Codebase Search Tool"""
+    
+    name = "find_related_files"
+    description = "Find code files related to the given requirement by searching the codebase using NLP-based semantic search. IMPORTANT: Requires complete sentence descriptions - keywords or phrases alone will not yield comprehensive results."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "dir": {
+                "type": "string",
+                "description": "Project root directory"
+            },
+            "query": {
+                "type": "string",
+                "description": """Requirement description to find related code files. Must be a complete sentence that clearly describes what you're looking for.
+
+Good examples:
+- 'Need to modify the user authentication process to add password validation'
+- 'Want to update the database connection configuration to support multiple databases'
+- 'Looking for the code that handles file upload functionality in the system'
+
+Bad examples (will not work well):
+- 'user auth'
+- 'database config'
+- 'upload'""",
+                "examples": [
+                    "Need to modify the error handling in the authentication process",
+                    "Want to update how the system processes user uploads",
+                    "Looking for the code that manages database connections"
+                ]
+            },
+            "top_k": {
+                "type": "integer",
+                "description": "Number of most relevant files to return",
+                "default": 5
+            }
+        },
+        "required": ["query"]
+    }
+    
+    def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute codebase search"""
+        try:
+            dir = params.get("dir")
+            query = params["query"]
+            top_k = params.get("top_k", 5)
+            
+            # Find the root directory of the codebase
+            current_dir = os.getcwd()
+            root_dir = find_git_root(dir or current_dir)
+            if not root_dir:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "Error: Current directory is not in a Git repository",
+                    "error": "NotInGitRepository"
+                }
+
+            os.chdir(root_dir)
+            codebase = CodeBase(root_dir)
+            # Generate index
+
+            codebase.generate_codebase()
+            # Execute search
+            response = codebase.search_similar(query, top_k)
+            os.chdir(current_dir)
+            return {
+                "success": True,
+                "stdout": str(response),
+                "stderr": "",
+                "error": None
+            }
+            
+        except Exception as e:
+            PrettyOutput.print(f"Codebase QA error: {str(e)}", output_type=OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Error executing codebase QA: {str(e)}",
+                "error": str(type(e).__name__)
+            }