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

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.99" 
+__version__ = "0.1.101" 

jarvis/agent.py

@@ -8,7 +8,7 @@ import yaml
 from jarvis.models.registry import PlatformRegistry
 from jarvis.tools import ToolRegistry
 from jarvis.tools.registry import load_tools
-from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, load_embedding_model, load_env_from_file
+from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, load_embedding_model, init_env
 import os
 
 class Agent:
@@ -330,8 +330,8 @@ def load_tasks() -> dict:
     """Load tasks from .jarvis files in user home and current directory."""
     tasks = {}
     
-    # Check .jarvis in user directory
-    user_jarvis = os.path.expanduser("~/.jarvis")
+    # Check .jarvis/pre-command in user directory
+    user_jarvis = os.path.expanduser("~/.jarvis/pre-command")
     if os.path.exists(user_jarvis):
         try:
             with open(user_jarvis, "r", encoding="utf-8") as f:
@@ -343,14 +343,14 @@ def load_tasks() -> dict:
                     if desc:  # Ensure description is not empty
                         tasks[str(name)] = str(desc)
             else:
-                PrettyOutput.print("Warning: ~/.jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
+                PrettyOutput.print("Warning: ~/.jarvis/pre-command file should contain a dictionary of task_name: task_description", OutputType.ERROR)
         except Exception as e:
-            PrettyOutput.print(f"Error loading ~/.jarvis file: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Error loading ~/.jarvis/pre-command file: {str(e)}", OutputType.ERROR)
     
-    # Check .jarvis in current directory
-    if os.path.exists(".jarvis"):
+    # Check .jarvis/pre-command in current directory
+    if os.path.exists(".jarvis/pre-command"):
         try:
-            with open(".jarvis", "r", encoding="utf-8") as f:
+            with open(".jarvis/pre-command", "r", encoding="utf-8") as f:
                 local_tasks = yaml.safe_load(f)
                 
             if isinstance(local_tasks, dict):
@@ -359,12 +359,12 @@ def load_tasks() -> dict:
                     if desc:  # Ensure description is not empty
                         tasks[str(name)] = str(desc)
             else:
-                PrettyOutput.print("Warning: .jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
+                PrettyOutput.print("Warning: .jarvis/pre-command file should contain a dictionary of task_name: task_description", OutputType.ERROR)
         except Exception as e:
-            PrettyOutput.print(f"Error loading .jarvis file: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Error loading .jarvis/pre-command file: {str(e)}", OutputType.ERROR)
 
     # Read methodology
-    method_path = os.path.expanduser("~/.jarvis_methodology")
+    method_path = os.path.expanduser("~/.jarvis/methodology")
     if os.path.exists(method_path):
         with open(method_path, "r", encoding="utf-8") as f:
             methodology = yaml.safe_load(f)
@@ -452,7 +452,7 @@ Strict Rules:
 def main():
     """Jarvis main entry point"""
     # Add argument parser
-    load_env_from_file()
+    init_env()
     parser = argparse.ArgumentParser(description='Jarvis AI assistant')
     parser.add_argument('-f', '--files', nargs='*', help='List of files to process')
     args = parser.parse_args()

jarvis/jarvis_code_agent/main.py

@@ -1,5 +1,6 @@
 from jarvis.agent import Agent
-from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, load_env_from_file
+from jarvis.tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, init_env
 
 
 
@@ -9,6 +10,10 @@ system_prompt = """You are Jarvis Code Agent, an AI code development assistant s
 DEVELOPMENT WORKFLOW:
 1. Task Analysis
    - Understand the requirements thoroughly
+   - IMPORTANT: Before suggesting any changes:
+     * Thoroughly examine existing code implementation
+     * Never assume code structure or implementation details
+     * Always verify current code behavior and patterns
    - Break down complex tasks into subtasks
    - IMPORTANT: Each subtask should:
      * Modify only ONE file
@@ -18,7 +23,8 @@ DEVELOPMENT WORKFLOW:
 
 2. Code Discovery & Analysis
    - Initial code search:
-     * Use shell commands to find patterns:
+     * CRITICAL: Always examine actual code implementation first
+     * Use shell commands to find and understand patterns:
        <TOOL_CALL>
        name: execute_shell
        arguments:
@@ -42,13 +48,6 @@ DEVELOPMENT WORKFLOW:
            command: head -n 50 file.py
        </TOOL_CALL>
    - File selection and confirmation:
-     * Find relevant files:
-       <TOOL_CALL>
-       name: find_related_files
-       arguments:
-           query: Need to modify user authentication
-           top_k: 5
-       </TOOL_CALL>
      * Let user confirm selection:
        <TOOL_CALL>
        name: select_code_files
@@ -58,18 +57,14 @@ DEVELOPMENT WORKFLOW:
                - user.py
            root_dir: .
        </TOOL_CALL>
-   - Detailed code examination:
-     * Understand code context:
-       <TOOL_CALL>
-       name: codebase_qa
-       arguments:
-           query: How does the authentication process work?
-           files:
-               - auth.py
-       </TOOL_CALL>
 
 3. Modification Planning
-   Generate a detailed modification plan based on user requirements and actual code conditions.
+   - CRITICAL: Base all plans on actual code implementation, not assumptions
+   - Generate a detailed modification plan based on:
+     * Current code structure and patterns
+     * Existing implementation details
+     * User requirements
+     * Actual code conditions
 
 4. Code Implementation
    - For small changes (≤20 lines):
@@ -90,7 +85,7 @@ DEVELOPMENT WORKFLOW:
 
 FILE SELECTION WORKFLOW:
 1. Initial Search
-   - Use codebase_search to find relevant files
+   - Use shell commands to find relevant files
    - Review search results for relevance
 
 2. User Confirmation
@@ -147,10 +142,8 @@ ITERATION GUIDELINES:
 TOOL USAGE:
 1. Analysis Tools:
    - execute_shell: Run grep/find/head/tail commands
-   - codebase_search: Find relevant files
-   - find_related_files: Find relevant files
+   - find_files: Search and identify relevant code files in the codebase based on requirements or problems
    - select_code_files: Confirm and supplement files
-   - codebase_qa: Understand context
    - ask_user: Ask user for confirmation and information if needed
    - create_code_sub_agent: Create agent for each small change
    - file_operation: Read files
@@ -164,24 +157,30 @@ TOOL USAGE:
    - ask_user: Ask user for confirmation and information if needed
 
 3. Implementation Tools:
-   - execute_shell: Run shell commands
+   - execute_shell: Run shell commands, some changes can use sed/awk/etc. to modify the code
    - execute_code_modification: Apply small changes (≤20 lines)
    - file_operation: Read, write, or append to files
-   
 
 IMPORTANT:
 1. If you can start executing the task, please start directly without asking the user if you can begin.
+2. NEVER assume code structure or implementation - always examine the actual code first.
+3. Base all suggestions and modifications on the current implementation, not assumptions.
+4. If code implementation is unclear, use available tools to investigate before proceeding.
+5. Before you start modifying the code, you should ask the user for confirmation of the modification plan.
+6. For some small changes, you can modify the code using the execute_shell tool directly or use file_operation tool to read the file and modify it.
 """
 
 def main():
     """Jarvis main entry point"""
     # Add argument parser
-    load_env_from_file()
+    init_env()
 
 
     try:
+        tool_registry = ToolRegistry()
+        tool_registry.dont_use_tools(["create_sub_agent"])
         # Get global model instance
-        agent = Agent(system_prompt=system_prompt, name="Jarvis Code Agent")
+        agent = Agent(system_prompt=system_prompt, name="Jarvis Code Agent", tool_registry=tool_registry)
 
         # Interactive mode
         while True:

jarvis/jarvis_codebase/main.py

@@ -10,7 +10,7 @@ import concurrent.futures
 from threading import Lock
 from concurrent.futures import ThreadPoolExecutor
 from jarvis.utils import OutputType, PrettyOutput, find_git_root, get_file_md5, get_max_context_length, get_single_line_input, get_thread_count, load_embedding_model, load_rerank_model
-from jarvis.utils import load_env_from_file
+from jarvis.utils import init_env
 import argparse
 import pickle
 import lzma  # 添加 lzma 导入
@@ -19,7 +19,7 @@ import re
 
 class CodeBase:
     def __init__(self, root_dir: str):
-        load_env_from_file()
+        init_env()
         self.root_dir = root_dir
         os.chdir(self.root_dir)
         self.thread_count = get_thread_count()
@@ -27,7 +27,7 @@ class CodeBase:
         self.index = None
             
         # 初始化数据目录
-        self.data_dir = os.path.join(self.root_dir, ".jarvis-codebase")
+        self.data_dir = os.path.join(self.root_dir, ".jarvis/codebase")
         self.cache_dir = os.path.join(self.data_dir, "cache")
         if not os.path.exists(self.cache_dir):
             os.makedirs(self.cache_dir)

jarvis/jarvis_coder/git_utils.py

@@ -79,7 +79,7 @@ def init_git_repo(root_dir: str) -> str:
     # 3. Process .gitignore file
     gitignore_path = os.path.join(git_dir, ".gitignore")
     gitignore_modified = False
-    jarvis_ignore_pattern = ".jarvis-*"
+    jarvis_ignore_pattern = ".jarvis"
 
     # 3.1 If .gitignore does not exist, create it
     if not os.path.exists(gitignore_path):
@@ -88,13 +88,13 @@ def init_git_repo(root_dir: str) -> str:
             f.write(f"{jarvis_ignore_pattern}\n")
         gitignore_modified = True
     else:
-        # 3.2 Check if it already contains the .jarvis-* pattern
+        # 3.2 Check if it already contains the .jarvis pattern
         with open(gitignore_path, "r", encoding="utf-8") as f:
             content = f.read()
         
-        # 3.2 Check if it already contains the .jarvis-* pattern
+        # 3.2 Check if it already contains the .jarvis pattern
         if jarvis_ignore_pattern not in content.split("\n"):
-            PrettyOutput.print("Add .jarvis-* to .gitignore", OutputType.INFO)
+            PrettyOutput.print("Add .jarvis to .gitignore", OutputType.INFO)
             with open(gitignore_path, "a", encoding="utf-8") as f:
                 # Ensure the file ends with a newline
                 if not content.endswith("\n"):

jarvis/jarvis_coder/main.py

@@ -4,7 +4,7 @@ from typing import Dict, Any, List, Optional
 import re
 
 from jarvis.jarvis_coder.file_select import select_files
-from jarvis.utils import OutputType, PrettyOutput, find_git_root, get_max_context_length, is_long_context, load_env_from_file, while_success
+from jarvis.utils import OutputType, PrettyOutput, find_git_root, get_max_context_length, is_long_context, init_env, while_success
 from jarvis.models.registry import PlatformRegistry
 from jarvis.jarvis_codebase.main import CodeBase
 from prompt_toolkit import PromptSession
@@ -88,14 +88,13 @@ class JarvisCoder:
                 "success": False,
                 "stdout": "",
                 "stderr": f"Execution failed: {str(e)}, please modify the requirement and try again",
-                "error": e
             }
 
 def main():
     """Command line entry"""
     import argparse
 
-    load_env_from_file()
+    init_env()
     
     parser = argparse.ArgumentParser(description='Code modification tool')
     parser.add_argument('-d', '--dir', help='Project root directory', default=os.getcwd())
@@ -122,11 +121,6 @@ def main():
             else:
                 if result.get("stderr"):
                     PrettyOutput.print(result["stderr"], OutputType.WARNING)
-                if result.get("error"):  # Use get() method to avoid KeyError
-                    error = result["error"]
-                    PrettyOutput.print(f"Error type: {type(error).__name__}", OutputType.WARNING)
-                    PrettyOutput.print(f"Error information: {str(error)}", OutputType.WARNING)
-                # Prompt user to continue input
                 PrettyOutput.print("\nYou can modify the requirements and try again", OutputType.INFO)
                 
         except KeyboardInterrupt:

jarvis/jarvis_coder/patch_handler.py

@@ -10,9 +10,10 @@ from jarvis.models.registry import PlatformRegistry
 from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, get_single_line_input, while_success
 
 class Patch:
-    def __init__(self, old_code: str, new_code: str):
-        self.old_code = old_code
-        self.new_code = new_code
+    def __init__(self, start: int, end: int, new_code: str):
+        self.start = start  # Line number where patch starts (inclusive)
+        self.end = end      # Line number where patch ends (exclusive) 
+        self.new_code = new_code  # New code to insert/replace
 
 class PatchHandler:
     def __init__(self):
@@ -43,22 +44,23 @@ class PatchHandler:
             PrettyOutput.print(f"Failed to save additional info: {e}", OutputType.WARNING)
 
     def _extract_patches(self, response: str) -> List[Patch]:
-        """Extract patches from response
+        """Extract patches from response with hexadecimal line numbers
         
         Args:
             response: Model response content
             
         Returns:
-            List[Tuple[str, str, str]]: Patch list, each patch is a tuple of (format, file path, patch content)
+            List[Patch]: List of patches, each containing the line range and new code
         """
-        # 修改后的正则表达式匹配三种补丁格式
-        fmt_pattern = r'<PATCH>\n>>>>>> SEARCH\n(.*?)\n?(={5,})\n(.*?)\n?<<<<<< REPLACE\n</PATCH>'
+        fmt_pattern = r'<PATCH>\n\[([0-9a-f]+),([0-9a-f]+)\)\n(.*?\n)</PATCH>'
         ret = []
         for m in re.finditer(fmt_pattern, response, re.DOTALL):
-            ret.append(Patch(m.group(1), m.group(3)))   
+            start = int(m.group(1), 16)  # Convert hex to decimal
+            end = int(m.group(2), 16)
+            new_code = m.group(3)
+            ret.append(Patch(start, end, new_code))
         return ret
 
-
     def _confirm_and_apply_changes(self, file_path: str) -> bool:
         """Confirm and apply changes"""
         os.system(f"git diff --cached {file_path}")
@@ -104,38 +106,76 @@ class PatchHandler:
         os.system(f"git reset --hard")
         os.system(f"git clean -df")
 
-    
+    def _check_patches_overlap(self, patches: List[Patch]) -> bool:
+        """Check if any patches overlap with each other
+        
+        Args:
+            patches: List of patches to check
+            
+        Returns:
+            bool: True if patches overlap, False otherwise
+        """
+        if not patches:
+            return False
+        
+        # Sort patches by start line
+        sorted_patches = sorted(patches, key=lambda x: x.start)
+        
+        # Check for overlaps
+        for i in range(len(sorted_patches) - 1):
+            current = sorted_patches[i]
+            next_patch = sorted_patches[i + 1]
+            
+            if current.end > next_patch.start:
+                PrettyOutput.print(
+                    f"Overlapping patches detected: [{current.start:04x},{current.end:04x}) and [{next_patch.start:04x},{next_patch.end:04x})",
+                    OutputType.WARNING
+                )
+                return True
+            
+        return False
+
     def apply_file_patch(self, file_path: str, patches: List[Patch]) -> bool:
-        """Apply file patch"""
+        """Apply file patches using line numbers"""
         if not os.path.exists(file_path):
             base_dir = os.path.dirname(file_path)
             os.makedirs(base_dir, exist_ok=True)
             open(file_path, "w", encoding="utf-8").close()
-        file_content = open(file_path, "r", encoding="utf-8").read()
+        
+        # Check for overlapping patches
+        if self._check_patches_overlap(patches):
+            PrettyOutput.print("Cannot apply overlapping patches", OutputType.ERROR)
+            os.system(f"git reset {file_path}")
+            os.system(f"git checkout -- {file_path}")
+            return False
+        
+        with open(file_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        
+        # Sort patches by start line in reverse order to apply from bottom to top
+        patches.sort(key=lambda x: x.start, reverse=True)
+        
         for i, patch in enumerate(patches):
-            if patch.old_code == "" and patch.new_code == "":
-                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)}: Delete file {file_path}", OutputType.INFO)
-                file_content = ""
-                os.system(f"git rm {file_path}")
-                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)} successfully", OutputType.SUCCESS)
-            elif patch.old_code == "":
-                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)}: Replace file {file_path} content: \n{patch.new_code}", OutputType.INFO)
-                file_content = patch.new_code
-                open(file_path, "w", encoding="utf-8").write(patch.new_code)
-                os.system(f"git add {file_path}")
-                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)} successfully", OutputType.SUCCESS)
+            PrettyOutput.print(f"Applying patch {i+1}/{len(patches)} at lines [{patch.start},{patch.end})", OutputType.INFO)
+            
+            if patch.start > len(lines):
+                PrettyOutput.print(f"Invalid patch: start line {patch.start} exceeds file length {len(lines)}", OutputType.WARNING)
+                os.system(f"git reset {file_path}")
+                os.system(f"git checkout -- {file_path}")
+                return False
+            
+            if patch.new_code:
+                new_lines = patch.new_code.splitlines(keepends=True)
+                lines[patch.start:patch.end] = new_lines
             else:
-                PrettyOutput.print(f"Apply patch {i+1}/{len(patches)}: File original content: \n{patch.old_code}\nReplace with: \n{patch.new_code}", OutputType.INFO)
-                if file_content.find(patch.old_code) == -1:
-                    PrettyOutput.print(f"File {file_path} does not contain {patch.old_code}", OutputType.WARNING)
-                    os.system(f"git reset {file_path}")
-                    os.system(f"git checkout -- {file_path}")
-                    return False
-                else:
-                    file_content = file_content.replace(patch.old_code, patch.new_code, 1)
-                    open(file_path, "w", encoding="utf-8").write(file_content)
-                    os.system(f"git add {file_path}")
-                    PrettyOutput.print(f"Apply patch {i+1}/{len(patches)} successfully", OutputType.SUCCESS)
+                del lines[patch.start:patch.end]
+                
+        # Write modified content back to file
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.writelines(lines)
+        
+        os.system(f"git add {file_path}")
+        PrettyOutput.print(f"Successfully applied all patches to {file_path}", OutputType.SUCCESS)
         return True
             
     
@@ -155,43 +195,85 @@ class PatchHandler:
             
         return "continue", feedback
 
-    def apply_patch(self, feature: str, structed_plan: Dict[str, str]) -> bool:
+    def apply_patch(self, feature: str, structed_plan: Dict[str, str]) -> Tuple[bool, str]:
         """Apply patch (main entry)"""
+        feedback = ""
         for file_path, current_plan in structed_plan.items():
             additional_info = self.additional_info  # Initialize with saved info
             while True:
-                
                 if os.path.exists(file_path):
-                    content = open(file_path, "r", encoding="utf-8").read()
+                    # Read file and add line numbers
+                    lines = []
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        for i, line in enumerate(f):
+                            lines.append(f"{i:04x}{line}")  # Changed from i+1 to i for 0-based indexing
+                    content = "".join(lines)
                 else:
                     content = "<File does not exist, need to create>"
-                prompt = """You are a senior software development expert who can generate code patches based on the complete modification plan, current original code file path, code content, and current file's modification plan. The output format should be as follows:
-                        <PATCH>
-                        >>>>>> SEARCH
-                        old_code
-                        ======
-                        new_code
-                        <<<<<< REPLACE
-                        </PATCH>
-                        Rules:
-                        1. When old_code is empty, it means replace everything from start to end
-                        2. When new_code is empty, it means delete old_code
-                        3. When both old_code and new_code are empty, it means delete the file
-                        Notes:
-                        1. Multiple patches can be generated
-                        2. old_code will be replaced with new_code, pay attention to context continuity
-                        3. Avoid breaking existing code logic when generating patches, e.g., don't insert function definitions inside existing function bodies
-                        4. Include sufficient context to avoid ambiguity
-                        5. Patches will be merged using file_content.replace(patch.old_code, patch.new_code, 1), so old_code and new_code need to match exactly, including EMPTY LINES, LINE BREAKS, WHITESPACE, TABS, and COMMENTS
-                        6. Ensure generated code has correct format (syntax, indentation, line breaks)
-                        7. Ensure new_code's indentation and format matches old_code
-                        8. Ensure code is inserted in appropriate locations, e.g., code using variables should be after declarations/definitions
-                        9. Provide at least 3 lines of context before and after modified code for location
-                        10. Each patch should be no more than 20 lines of code, if it is more than 20 lines, split it into multiple patches
-                        11. old code's line breaks should be consistent with the original code
+                    
+                prompt = """You are a senior software development expert who can generate code patches based on the complete modification plan, current original code file path, code content (with 4-digit hexadecimal line numbers), and current file's modification plan. The output format should be as follows:
 
+                <PATCH>
+                [start,end)
+                new_code
+                </PATCH>
 
-                        """
+                Example:
+                <PATCH>
+                [000c,000c)
+                def new_function():
+                    pass
+                </PATCH>
+
+                means:
+                Insert code BEFORE line 12:
+                ```
+                def new_function():
+                    pass
+                ```
+                
+                Example 2:
+                <PATCH>
+                [0004,000b)
+                aa
+                bb
+                cc
+                </PATCH>
+
+                means:
+                Replace lines [4,11) with:
+                ```
+                aa
+                bb
+                cc
+                ```
+
+                Rules:
+                1. start and end are hexadecimal line numbers (e.g., 000a)
+                2. The patch will replace lines [start,end) with new_code (including start, excluding end)
+                3. If start equals end, new_code will be inserted BEFORE that line
+                4. If new_code is empty, lines [start,end) will be deleted
+                5. Multiple patches can be generated
+                6. Each line in the input file starts with its 4-digit hexadecimal line number (0-based)
+                7. Your new_code should NOT include line numbers
+                8. CRITICAL: Patches MUST NOT overlap - ensure each line is modified by at most one patch
+                9. Generate patches from bottom to top of the file
+                10. Ensure new_code maintains correct indentation and formatting
+                11. Each patch should modify no more than 20 lines
+                12. Include sufficient context in new_code to maintain code consistency
+                13. `[` and `)` must be included in the line range
+                14. Line numbers start from 0
+                15. Example of INVALID overlapping patches:
+                    <PATCH>
+                    [0001,0005)
+                    code1
+                    </PATCH>
+                    <PATCH>
+                    [0003,0007)  # This overlaps with the previous patch
+                    code2
+                    </PATCH>
+                """
+                
                 prompt += f"""# Original requirement: {feature}
                     # Current file path: {file_path}
                     # Current file content:
@@ -215,9 +297,12 @@ class PatchHandler:
                     act, msg = self.retry_comfirm()
                     if act == "break":
                         PrettyOutput.print("Terminate patch application", OutputType.WARNING)
-                        return False
+                        additional_info = get_multiline_input("Please enter your additional information or suggestions (press Enter to cancel):")
+                        return False, additional_info
                     if act == "skip":
                         PrettyOutput.print(f"Skip file {file_path}", OutputType.WARNING)
+                        feedback += f"Skip file {file_path}\n"
+                        feedback += "Reason: " + get_multiline_input("Please enter your reason:") + "\n"
                         break
                     else:
                         additional_info += msg + "\n"
@@ -226,11 +311,11 @@ class PatchHandler:
                     self._finalize_changes()
                     break
         
-        return True
+        return True, feedback
 
 
 
-    def handle_patch_application(self, feature: str, structed_plan: Dict[str,str]) -> bool:
+    def handle_patch_application(self, feature: str, structed_plan: Dict[str,str]) -> Tuple[bool, str]:
         """Process patch application process
         
         Args:
@@ -246,17 +331,10 @@ class PatchHandler:
             PrettyOutput.print(f"\nFile: {file_path}", OutputType.INFO)
             PrettyOutput.print(f"Modification plan: \n{patches_code}", OutputType.INFO)
         # 3. Apply patches
-        success = self.apply_patch(feature, structed_plan)
+        success, additional_info = self.apply_patch(feature, structed_plan)
         if not success:
             os.system("git reset --hard")
-            return False
+            return False, additional_info
         # 6. Apply successfully, let user confirm changes
         PrettyOutput.print("\nPatches applied, please check the modification effect.", OutputType.SUCCESS)
-        confirm = get_single_line_input("\nKeep these changes? (y/n) [y]: ").lower() or "y"
-        if confirm != "y":
-            PrettyOutput.print("User cancelled changes, rolling back", OutputType.WARNING)
-            os.system("git reset --hard")  # Rollback all changes
-            return False
-        else:
-            return True
-            
+        return True, "Modification applied successfully"

jarvis/jarvis_platform/main.py

@@ -1,5 +1,5 @@
 from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType, load_env_from_file, get_multiline_input
+from jarvis.utils import PrettyOutput, OutputType, init_env, get_multiline_input
 
 def list_platforms():
     """List all supported platforms and models"""
@@ -106,7 +106,7 @@ def main():
     """Main function"""
     import argparse
 
-    load_env_from_file()
+    init_env()
     
     parser = argparse.ArgumentParser(description='Jarvis AI Platform')
     subparsers = parser.add_subparsers(dest='command', help='Available subcommands')

jarvis/jarvis_rag/main.py

@@ -4,7 +4,7 @@ import faiss
 from typing import List, Tuple, Optional, Dict
 import pickle
 from jarvis.utils import OutputType, PrettyOutput, get_file_md5, get_max_context_length, load_embedding_model, load_rerank_model
-from jarvis.utils import load_env_from_file
+from jarvis.utils import init_env
 from dataclasses import dataclass
 from tqdm import tqdm
 import fitz  # PyMuPDF for PDF files
@@ -137,7 +137,7 @@ class RAGTool:
         Args:
             root_dir: Project root directory
         """
-        load_env_from_file()
+        init_env()
         self.root_dir = root_dir
         os.chdir(self.root_dir)