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

jarvis/jarvis_coder/patch_handler.py

@@ -1,340 +0,0 @@
-import re
-import os
-from typing import List, Tuple, Dict
-import yaml
-from pathlib import Path
-
-from jarvis.jarvis_coder.git_utils import generate_commit_message, init_git_repo, save_edit_record
-from jarvis.models.base import BasePlatform
-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, 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):
-        self.prompt_file = Path.home() / ".jarvis-coder-patch-prompt"
-        self.additional_info = self._load_additional_info()
-        self.root_dir = init_git_repo(os.getcwd())
-        self.record_dir = os.path.join(self.root_dir, ".jarvis-coder", "record")
-        if not os.path.exists(self.record_dir):
-            os.makedirs(self.record_dir)
-    def _load_additional_info(self) -> str:
-        """Load saved additional info from prompt file"""
-        if not self.prompt_file.exists():
-            return ""
-        try:
-            with open(self.prompt_file, 'r') as f:
-                data = yaml.safe_load(f)
-                return data.get('additional_info', '') if data else ''
-        except Exception as e:
-            PrettyOutput.print(f"Failed to load additional info: {e}", OutputType.WARNING)
-            return ""
-
-    def _save_additional_info(self, info: str):
-        """Save additional info to prompt file"""
-        try:
-            with open(self.prompt_file, 'w') as f:
-                yaml.dump({'additional_info': info}, f)
-        except Exception as e:
-            PrettyOutput.print(f"Failed to save additional info: {e}", OutputType.WARNING)
-
-    def _extract_patches(self, response: str) -> List[Patch]:
-        """Extract patches from response with hexadecimal line numbers
-        
-        Args:
-            response: Model response content
-            
-        Returns:
-            List[Patch]: List of patches, each containing the line range and new code
-        """
-        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):
-            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}")
-        confirm = get_single_line_input(f"Accept {file_path} changes? (y/n) [y]").lower() or "y"
-        if confirm == "y":
-            return True
-        else:
-            # Rollback changes
-            os.system(f"git reset {file_path}")
-            os.system(f"git checkout -- {file_path}")
-            PrettyOutput.print(f"Changes to {file_path} have been rolled back", OutputType.WARNING)
-            return False
-        
-    
-
-    def _finalize_changes(self) -> None:
-        """Complete changes and commit"""
-        PrettyOutput.print("Modification confirmed, committing...", OutputType.INFO)
-
-        # Add only modified files under git control
-        os.system("git add -u")
-        
-        # Then get git diff
-        git_diff = os.popen("git diff --cached").read()
-        
-        # Automatically generate commit information, pass in feature
-        commit_message = generate_commit_message(git_diff)
-        
-        # Display and confirm commit information
-        PrettyOutput.print(f"Automatically generated commit information: {commit_message}", OutputType.INFO)
-        user_confirm = get_single_line_input("Use this commit information? (y/n) [y]").lower() or "y"
-        
-        if user_confirm.lower() != "y":
-            commit_message = get_single_line_input("Please enter a new commit information")
-        
-        # No need to git add again, it has already been added
-        os.system(f"git commit -m '{commit_message}'")
-        save_edit_record(self.record_dir, commit_message, git_diff)
-
-    def _revert_changes(self) -> None:
-        """Revert all changes"""
-        PrettyOutput.print("Modification cancelled, reverting changes", OutputType.INFO)
-        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 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()
-        
-        # 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):
-            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:
-                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
-            
-    
-    def retry_comfirm(self) -> Tuple[str, str]:
-        choice = get_single_line_input("\nPlease choose an action: (1) Retry (2) Skip (3) Completely stop [1]: ") or "1"
-        if choice == "2":
-            return "skip", ""
-        if choice == "3":
-            return "break", ""
-            
-        feedback = get_multiline_input("Please enter additional information and requirements:")
-        if feedback:
-            save_prompt = get_single_line_input("Would you like to save this as general feedback for future patches? (y/n) [n]: ").lower() or "n"
-            if save_prompt == "y":
-                self._save_additional_info(feedback)
-                PrettyOutput.print("Feedback saved for future use", OutputType.SUCCESS)
-            
-        return "continue", feedback
-
-    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):
-                    # 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 (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:
-                    <CONTENT>
-                    {content}
-                    </CONTENT>
-                    # Current file modification plan:
-                    {current_plan}
-                    { "# Additional information: " + additional_info if additional_info else "" }
-                    """
-
-
-                PrettyOutput.print(f"Generating formatted patches for {file_path}...", OutputType.PROGRESS)
-                response = PlatformRegistry.get_global_platform_registry().get_codegen_platform().chat_until_success(prompt)
-                patches = self._extract_patches(response)
-
-                if not patches or not self.apply_file_patch(file_path, patches) or not self._confirm_and_apply_changes(file_path):
-                    os.system(f"git reset {file_path}")
-                    os.system(f"git checkout -- {file_path}")
-                    PrettyOutput.print("Patch generation failed", OutputType.WARNING)
-                    act, msg = self.retry_comfirm()
-                    if act == "break":
-                        PrettyOutput.print("Terminate patch application", OutputType.WARNING)
-                        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"
-                        continue
-                else:
-                    self._finalize_changes()
-                    break
-        
-        return True, feedback
-
-
-
-    def handle_patch_application(self, feature: str, structed_plan: Dict[str,str]) -> Tuple[bool, str]:
-        """Process patch application process
-        
-        Args:
-            related_files: Related files list
-            feature: Feature description
-            modification_plan: Modification plan
-            
-        Returns:
-            bool: Whether patch application is successful
-        """
-        PrettyOutput.print("\nThe following modification plan will be applied:", OutputType.INFO)
-        for file_path, patches_code in structed_plan.items():
-            PrettyOutput.print(f"\nFile: {file_path}", OutputType.INFO)
-            PrettyOutput.print(f"Modification plan: \n{patches_code}", OutputType.INFO)
-        # 3. Apply patches
-        success, additional_info = self.apply_patch(feature, structed_plan)
-        if not success:
-            os.system("git reset --hard")
-            return False, additional_info
-        # 6. Apply successfully, let user confirm changes
-        PrettyOutput.print("\nPatches applied, please check the modification effect.", OutputType.SUCCESS)
-        return True, "Modification applied successfully"

jarvis/jarvis_coder/plan_generator.py

@@ -1,145 +0,0 @@
-import re
-from typing import Dict, List, Tuple
-from jarvis.models.registry import PlatformRegistry
-from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, get_single_line_input, is_long_context
-
-class PlanGenerator:
-    """Modification plan generator"""   
-    
-    def _build_prompt(self, feature: str, related_files: List[Dict], additional_info: str) -> str:
-        """Build prompt
-        
-        Args:
-            feature: Feature description
-            related_files: Related files list
-            additional_info: User supplement information
-            
-        Returns:
-            str: Complete prompt
-        """
-        prompt = "You are a code modification expert who can generate modification plans based on requirements and relevant code snippets. I need your help to analyze how to implement the following feature:\n\n"
-        prompt += f"{feature}\n\n"
-                
-        prompt += "Here are the relevant code file snippets:\n\n"
-        
-        for file in related_files:
-            prompt += f"File: {file['file_path']}\n"
-            for part in file["parts"]:
-                prompt += f"<PART>\n{part}\n</PART>\n"
-        
-        prompt += "\nPlease provide detailed modifications needed to implement this feature. Include:\n"
-        prompt += "1. Which files need to be modified\n"
-        prompt += "2. How to modify each file, no explanation needed\n"
-        prompt += "3. Don't assume other files or code exist, only generate modification plans based on provided file contents and description\n"
-        prompt += "4. Don't implement features outside the requirement\n"
-        prompt += "5. Output only one modification plan per file (can be multiple lines)\n"
-        prompt += "6. Output format as follows:\n"
-        prompt += "<PLAN>\n"
-        prompt += "> path/to/file1\n"
-        prompt += "modification plan\n"
-        prompt += "</PLAN>\n"
-        prompt += "<PLAN>\n"
-        prompt += "> path/to/file2\n"
-        prompt += "modification plan\n"
-        prompt += "</PLAN>\n"
-        if additional_info:
-            prompt += f"# Additional information:\n{additional_info}\n"
-        
-        return prompt
-    
-    
-    @staticmethod
-    def get_key_code(files: List[str], feature: str)->List[Dict[str, List[str]]]:
-        """Extract relevant key code snippets from files"""
-        ret = []
-        for file in files:
-            PrettyOutput.print(f"Analyzing file: {file}", OutputType.INFO)
-            model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
-            model.set_suppress_output(True)
-            file_path = file
-            content = open(file_path, "r", encoding="utf-8").read()
-
-            try:
-                prompt = f"""You are a code analysis expert who can extract relevant snippets from code.
-Please return in the following format:
-<PART>
-content
-</PART>
-
-Multiple snippets can be returned. If the file content is not relevant to the requirement, return empty.
-
-Requirement: {feature}
-File path: {file_path}
-Code content:
-{content}
-"""
-
-                # 调用大模型进行分析
-                response = model.chat_until_success(prompt)
-
-                parts = re.findall(r'<PART>\n(.*?)\n</PART>', response, re.DOTALL)
-                ret.append({"file_path": file, "parts": parts})
-            except Exception as e:
-                PrettyOutput.print(f"Failed to analyze file: {str(e)}", OutputType.ERROR)
-        return ret
-    
-    def generate_plan(self, feature: str, related_files: List[str]) -> Dict[str,str]:
-        """Generate modification plan
-        
-        Args:
-            feature: Feature description
-            related_files: Related files list
-            
-        Returns:
-            Tuple[str, Dict[str,str]]: Modification plan, return None if user cancels
-        """
-        additional_info = ""
-        file_info = []
-        if is_long_context(related_files):
-            file_info =  PlanGenerator.get_key_code(related_files, feature)
-        else:
-            for file in related_files:
-                file_info.append({"file_path": file, "parts": [open(file, "r", encoding="utf-8").read()]})
-
-        while True:
-            prompt = self._build_prompt(feature, file_info, additional_info)
-            # Build prompt
-            PrettyOutput.print("Start generating modification plan...", OutputType.PROGRESS)
-            
-            # Get modification plan
-            raw_plan = PlatformRegistry.get_global_platform_registry().get_thinking_platform().chat_until_success(prompt)
-            structed_plan = self._extract_code(raw_plan)
-            if not structed_plan:
-                PrettyOutput.print("Modification plan generation failed, please try again", OutputType.ERROR)
-                tmp = get_multiline_input("Please enter your additional information or suggestions (press Enter to cancel):")
-                if tmp == "__interrupt__" or prompt == "":
-                    return {}
-                additional_info += tmp + "\n"
-                continue
-            user_input = get_single_line_input("Do you agree with this modification plan? (y/n) [y]").strip().lower() or 'y'
-            if user_input == 'y' or user_input == '':
-                return structed_plan
-            elif user_input == 'n':
-                # Get user feedback
-                tmp = get_multiline_input("Please enter your additional information or suggestions (press Enter to cancel):")
-                if prompt == "__interrupt__" or prompt == "":
-                    return {}
-                additional_info += tmp + "\n"
-                continue 
-
-    
-    def _extract_code(self, response: str) -> Dict[str, str]:
-        """Extract code from response
-        
-        Args:
-            response: Model response content
-            
-        Returns:
-            Dict[str, List[str]]: Code dictionary, key is file path, value is code snippet list
-        """
-        code_dict = {}
-        for match in re.finditer(r'<PLAN>\n> (.+?)\n(.*?)\n</PLAN>', response, re.DOTALL):
-            file_path = match.group(1)
-            code_part = match.group(2)
-            code_dict[file_path] = code_part
-        return code_dict

jarvis/tools/execute_code_modification.py

@@ -1,70 +0,0 @@
-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/find_files.py

@@ -1,119 +0,0 @@
-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)}"
-            }