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

jarvis/jarvis_coder/main.py

@@ -3,6 +3,7 @@ import threading
 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.models.registry import PlatformRegistry
 from jarvis.jarvis_codebase.main import CodeBase
@@ -12,7 +13,7 @@ from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.styles import Style
 import fnmatch
 from .patch_handler import PatchHandler
-from .git_utils import generate_commit_message, save_edit_record
+from .git_utils import generate_commit_message, init_git_repo, save_edit_record
 from .plan_generator import PlanGenerator
 
 # 全局锁对象
@@ -29,98 +30,14 @@ class JarvisCoder:
     def _init_directories(self):
         """Initialize directories"""
         self.max_context_length = get_max_context_length()
-
-        root_dir = find_git_root(self.root_dir)
-        if not root_dir:
-            root_dir = self.root_dir
-
-        self.root_dir = root_dir
-
-        PrettyOutput.print(f"Git root directory: {self.root_dir}", OutputType.INFO)
-
-        # 1. Check if the code repository path exists, if it does not exist, create it
-        if not os.path.exists(self.root_dir):
-            PrettyOutput.print(
-                "Root directory does not exist, creating...", OutputType.INFO)
-            os.makedirs(self.root_dir)
-
-        os.chdir(self.root_dir)
-
-        # 2. Create .jarvis-coder directory
-        self.jarvis_dir = os.path.join(self.root_dir, ".jarvis-coder")
-        if not os.path.exists(self.jarvis_dir):
-            os.makedirs(self.jarvis_dir)
-
-        self.record_dir = os.path.join(self.jarvis_dir, "record")
-        if not os.path.exists(self.record_dir):
-            os.makedirs(self.record_dir)
-
-        # 3. Process .gitignore file
-        gitignore_path = os.path.join(self.root_dir, ".gitignore")
-        gitignore_modified = False
-        jarvis_ignore_pattern = ".jarvis-*"
-
-        # 3.1 If .gitignore does not exist, create it
-        if not os.path.exists(gitignore_path):
-            PrettyOutput.print("Create .gitignore file", OutputType.INFO)
-            with open(gitignore_path, "w", encoding="utf-8") as f:
-                f.write(f"{jarvis_ignore_pattern}\n")
-            gitignore_modified = True
-        else:
-            # 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
-            if jarvis_ignore_pattern not in content.split("\n"):
-                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"):
-                        f.write("\n")
-                    f.write(f"{jarvis_ignore_pattern}\n")
-                gitignore_modified = True
-
-        # 4. Check if the code repository is a git repository, if not, initialize the git repository
-        if not os.path.exists(os.path.join(self.root_dir, ".git")):
-            PrettyOutput.print("Initialize Git repository", OutputType.INFO)
-            os.system("git init")
-            os.system("git add .")
-            os.system("git commit -m 'Initial commit'")
-        # 5. If .gitignore is modified, commit the changes
-        elif gitignore_modified:
-            PrettyOutput.print("Commit .gitignore changes", OutputType.INFO)
-            os.system("git add .gitignore")
-            os.system("git commit -m 'chore: update .gitignore to exclude .jarvis-* files'")
-        # 6. Check if there are uncommitted files in the code repository, if there are, commit once
-        elif self._has_uncommitted_files():
-            PrettyOutput.print("Commit uncommitted changes", OutputType.INFO)
-            os.system("git add .")
-            git_diff = os.popen("git diff --cached").read()
-            commit_message = generate_commit_message(git_diff)
-            os.system(f"git commit -m '{commit_message}'")
+        self.root_dir = init_git_repo(self.root_dir)
 
     def _init_codebase(self):
         """Initialize codebase"""
         self._codebase = CodeBase(self.root_dir)
 
-    def _has_uncommitted_files(self) -> bool:
-        """Check if there are uncommitted files in the code repository"""
-        # Get unstaged modifications
-        unstaged = os.popen("git diff --name-only").read()
-        # Get staged but uncommitted modifications
-        staged = os.popen("git diff --cached --name-only").read()
-        # Get untracked files
-        untracked = os.popen("git ls-files --others --exclude-standard").read()
-        
-        return bool(unstaged or staged or untracked)
-
-    def _prepare_execution(self) -> None:
-        """Prepare execution environment"""
-        self._codebase.generate_codebase()
-
 
-    def _load_related_files(self, feature: str) -> List[Dict]:
+    def _load_related_files(self, feature: str) -> List[str]:
         """Load related file content"""
         ret = []
         # Ensure the index database is generated
@@ -129,300 +46,23 @@ class JarvisCoder:
             self._codebase.generate_codebase()
             
         related_files = self._codebase.search_similar(feature)
-        for file, score in related_files:
-            PrettyOutput.print(f"Related file: {file} (score: {score:.3f})", OutputType.SUCCESS)
-            content = open(file, "r", encoding="utf-8").read()
-            ret.append({"file_path": file, "file_content": content})
+        for file in related_files:
+            PrettyOutput.print(f"Related file: {file}", OutputType.SUCCESS)
+            ret.append(file)
         return ret
 
-    def _parse_file_selection(self, input_str: str, max_index: int) -> List[int]:
-        """Parse file selection expression
-        
-        Supported formats:
-        - Single number: "1"
-        - Comma-separated: "1,3,5"
-        - Range: "1-5"
-        - Combination: "1,3-5,7"
-        
-        Args:
-            input_str: User input selection expression
-            max_index: Maximum selectable index
-            
-        Returns:
-            List[int]: Selected index list (starting from 0)
-        """
-        selected = set()
-        
-        # Remove all whitespace characters
-        input_str = "".join(input_str.split())
-        
-        # Process comma-separated parts
-        for part in input_str.split(","):
-            if not part:
-                continue
-            
-            # Process range (e.g.: 3-6)
-            if "-" in part:
-                try:
-                    start, end = map(int, part.split("-"))
-                    # Convert to index starting from 0
-                    start = max(0, start - 1)
-                    end = min(max_index, end - 1)
-                    if start <= end:
-                        selected.update(range(start, end + 1))
-                except ValueError:
-                    PrettyOutput.print(f"Ignore invalid range expression: {part}", OutputType.WARNING)
-            # Process single number
-            else:
-                try:
-                    index = int(part) - 1  # Convert to index starting from 0
-                    if 0 <= index < max_index:
-                        selected.add(index)
-                    else:
-                        PrettyOutput.print(f"Ignore index out of range: {part}", OutputType.WARNING)
-                except ValueError:
-                    PrettyOutput.print(f"Ignore invalid number: {part}", OutputType.WARNING)
-        
-        return sorted(list(selected))
-
-    def _get_file_completer(self) -> Completer:
-        """Create file path completer"""
-        class FileCompleter(Completer):
-            def __init__(self, root_dir: str):
-                self.root_dir = root_dir
-                
-            def get_completions(self, document, complete_event):
-                # Get the text of the current input
-                text = document.text_before_cursor
-                
-                # If the input is empty, return all files in the root directory
-                if not text:
-                    for path in self._list_files(""):
-                        yield Completion(path, start_position=0)
-                    return
-                    
-                # Get the current directory and partial file name
-                current_dir = os.path.dirname(text)
-                file_prefix = os.path.basename(text)
-                
-                # List matching files
-                search_dir = os.path.join(self.root_dir, current_dir) if current_dir else self.root_dir
-                if os.path.isdir(search_dir):
-                    for path in self._list_files(current_dir):
-                        if path.startswith(text):
-                            yield Completion(path, start_position=-len(text))
-            
-            def _list_files(self, current_dir: str) -> List[str]:
-                """List all files in the specified directory (recursively)"""
-                files = []
-                search_dir = os.path.join(self.root_dir, current_dir)
-                
-                for root, _, filenames in os.walk(search_dir):
-                    for filename in filenames:
-                        full_path = os.path.join(root, filename)
-                        rel_path = os.path.relpath(full_path, self.root_dir)
-                        # Ignore .git directory and other hidden files
-                        if not any(part.startswith('.') for part in rel_path.split(os.sep)):
-                            files.append(rel_path)
-                
-                return sorted(files)
-
-        return FileCompleter(self.root_dir)
-
-    def _fuzzy_match_files(self, pattern: str) -> List[str]:
-        """Fuzzy match file path
-        
-        Args:
-            pattern: Matching pattern
-            
-        Returns:
-            List[str]: List of matching file paths
-        """
-        matches = []
-        
-        # 将模式转换为正则表达式
-        pattern = pattern.replace('.', r'\.').replace('*', '.*').replace('?', '.')
-        pattern = f".*{pattern}.*"  # 允许部分匹配
-        regex = re.compile(pattern, re.IGNORECASE)
-        
-        # 遍历所有文件
-        for root, _, files in os.walk(self.root_dir):
-            for file in files:
-                full_path = os.path.join(root, file)
-                rel_path = os.path.relpath(full_path, self.root_dir)
-                # 忽略 .git 目录和其他隐藏文件
-                if not any(part.startswith('.') for part in rel_path.split(os.sep)):
-                    if regex.match(rel_path):
-                        matches.append(rel_path)
-        
-        return sorted(matches)
-
-    def _select_files(self, related_files: List[Dict]) -> List[Dict]:
-        """Let the user select and supplement related files"""
-        PrettyOutput.section("Related files", OutputType.INFO)
-        
-        # Display found files
-        selected_files = list(related_files)  # Default select all
-        for i, file in enumerate(related_files, 1):
-            PrettyOutput.print(f"[{i}] {file['file_path']}", OutputType.INFO)
-        
-        # Ask the user if they need to adjust the file list
-        user_input = input("\nDo you need to adjust the file list? (y/n) [n]: ").strip().lower() or 'n'
-        if user_input == 'y':
-            # Let the user select files
-            PrettyOutput.print("\nPlease enter the file numbers to include (support: 1,3-6 format, press Enter to keep the current selection):", OutputType.INFO)
-            numbers = input(">>> ").strip()
-            if numbers:
-                selected_indices = self._parse_file_selection(numbers, len(related_files))
-                if selected_indices:
-                    selected_files = [related_files[i] for i in selected_indices]
-                else:
-                    PrettyOutput.print("No valid files selected, keep the current selection", OutputType.WARNING)
-        
-        # Ask if they need to supplement files
-        user_input = input("\nDo you need to supplement other files? (y/n) [n]: ").strip().lower() or 'n'
-        if user_input == 'y':
-            # Create file completion session
-            session = PromptSession(
-                completer=self._get_file_completer(),
-                complete_while_typing=True
-            )
-            
-            while True:
-                PrettyOutput.print("\nPlease enter the file path to supplement (support Tab completion and *? wildcard, input empty line to end):", OutputType.INFO)
-                try:
-                    file_path = session.prompt(">>> ").strip()
-                except KeyboardInterrupt:
-                    break
-                    
-                if not file_path:
-                    break
-                    
-                # Process wildcard matching
-                if '*' in file_path or '?' in file_path:
-                    matches = self._fuzzy_match_files(file_path)
-                    if not matches:
-                        PrettyOutput.print("No matching files found", OutputType.WARNING)
-                        continue
-                        
-                    # Display matching files
-                    PrettyOutput.print("\nFound the following matching files:", OutputType.INFO)
-                    for i, path in enumerate(matches, 1):
-                        PrettyOutput.print(f"[{i}] {path}", OutputType.INFO)
-                        
-                    # Let the user select
-                    numbers = input("\nPlease select the file numbers to add (support: 1,3-6 format, press Enter to select all): ").strip()
-                    if numbers:
-                        indices = self._parse_file_selection(numbers, len(matches))
-                        if not indices:
-                            continue
-                        paths_to_add = [matches[i] for i in indices]
-                    else:
-                        paths_to_add = matches
-                else:
-                    paths_to_add = [file_path]
-                
-                # Add selected files
-                for path in paths_to_add:
-                    full_path = os.path.join(self.root_dir, path)
-                    if not os.path.isfile(full_path):
-                        PrettyOutput.print(f"File does not exist: {path}", OutputType.ERROR)
-                        continue
-                    
-                    try:
-                        with open(full_path, "r", encoding="utf-8") as f:
-                            content = f.read()
-                        selected_files.append({
-                            "file_path": path,
-                            "file_content": content
-                        })
-                        PrettyOutput.print(f"File added: {path}", OutputType.SUCCESS)
-                    except Exception as e:
-                        PrettyOutput.print(f"Failed to read file: {str(e)}", OutputType.ERROR)
-        
-        return selected_files
 
-    def _finalize_changes(self, feature: str) -> 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 = input("Use this commit information? (y/n) [y]: ") or "y"
-        
-        if user_confirm.lower() != "y":
-            commit_message = 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 get_key_code(self, files: List[Dict], feature: str):
-        """Extract relevant key code snippets from files"""
-        for file_info in files:
-            PrettyOutput.print(f"Analyzing file: {file_info['file_path']}", OutputType.INFO)
-            model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
-            model.set_suppress_output(True)
-            file_path = file_info["file_path"]
-            content = file_info["file_content"]
-
-            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)
-                file_info["parts"] = parts
-            except Exception as e:
-                PrettyOutput.print(f"Failed to analyze file: {str(e)}", OutputType.ERROR)
 
     def execute(self, feature: str) -> Dict[str, Any]:
         """Execute code modification"""
         try:
-            self._prepare_execution()
-            
             # Get and select related files
             initial_files = self._load_related_files(feature)
-            selected_files = self._select_files(initial_files)
+            selected_files = select_files(initial_files, self.root_dir)
 
-            # Whether it is a long context
-            if is_long_context([file['file_path'] for file in selected_files]):
-                self.get_key_code(selected_files, feature)
-            else:
-                for file in selected_files:
-                    file["parts"] = [file["file_content"]]
-            
             # Get modification plan
-            raw_plan, structed_plan = PlanGenerator().generate_plan(feature, selected_files)
-            if not raw_plan or not structed_plan:
+            structed_plan = PlanGenerator().generate_plan(feature, selected_files)
+            if not structed_plan:
                 return {
                     "success": False,
                     "stdout": "",
@@ -430,15 +70,13 @@ Code content:
                 }
             
             # Execute modification
-            if PatchHandler().handle_patch_application(feature ,raw_plan, structed_plan):
-                self._finalize_changes(feature)
+            if PatchHandler().handle_patch_application(feature, structed_plan):
                 return {
                     "success": True,
                     "stdout": "Code modification successful",
                     "stderr": "",
                 }
             else:
-                self._revert_changes()
                 return {
                     "success": False,
                     "stdout": "",
@@ -446,7 +84,6 @@ Code content:
                 }
                 
         except Exception as e:
-            self._revert_changes()
             return {
                 "success": False,
                 "stdout": "",
@@ -557,21 +194,6 @@ class FilePathCompleter(Completer):
                 # Calculate the correct start_position
                 yield Completion(path, start_position=-(len(search)))
 
-class SmartCompleter(Completer):
-    """Smart auto-completer, combine word and file path completion"""
-    
-    def __init__(self, word_completer: WordCompleter, file_completer: FilePathCompleter):
-        self.word_completer = word_completer
-        self.file_completer = file_completer
-        
-    def get_completions(self, document, complete_event):
-        """Get completion suggestions"""
-        # If the current line ends with @, use file completion
-        if document.text_before_cursor.strip().endswith('@'):
-            yield from self.file_completer.get_completions(document, complete_event)
-        else:
-            # Otherwise, use word completion
-            yield from self.word_completer.get_completions(document, complete_event)
 
 def get_multiline_input(prompt_text: str, root_dir: Optional[str] = ".") -> str:
     """Get multi-line input, support file path auto-completion function

jarvis/jarvis_coder/patch_handler.py

@@ -1,10 +1,13 @@
 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, while_success
+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):
@@ -12,7 +15,32 @@ class Patch:
         self.new_code = new_code
 
 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
@@ -34,7 +62,7 @@ class PatchHandler:
     def _confirm_and_apply_changes(self, file_path: str) -> bool:
         """Confirm and apply changes"""
         os.system(f"git diff --cached {file_path}")
-        confirm = input(f"\nAccept {file_path} changes? (y/n) [y]: ").lower() or "y"
+        confirm = get_single_line_input(f"Accept {file_path} changes? (y/n) [y]").lower() or "y"
         if confirm == "y":
             return True
         else:
@@ -43,6 +71,38 @@ class PatchHandler:
             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 apply_file_patch(self, file_path: str, patches: List[Patch]) -> bool:
@@ -79,18 +139,26 @@ class PatchHandler:
         return True
             
     
-    def retry_comfirm(self) -> Tuple[str, str]:# Restore user selection logic
-        choice = input("\nPlease choose an action: (1) Retry (2) Skip (3) Completely stop [1]: ") or "1"
+    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", ""
-        return "continue", get_multiline_input("Please enter additional information and requirements:")
+            
+        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, raw_plan: str, structed_plan: Dict[str, str]) -> Tuple[bool, str]:
+    def apply_patch(self, feature: str, structed_plan: Dict[str, str]) -> bool:
         """Apply patch (main entry)"""
         for file_path, current_plan in structed_plan.items():
-            additional_info = ""            
+            additional_info = self.additional_info  # Initialize with saved info
             while True:
                 
                 if os.path.exists(file_path):
@@ -114,16 +182,17 @@ class PatchHandler:
                         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
+                        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 += f"""# Original requirement: {feature}
-                    # Complete modification plan: {raw_plan}
                     # Current file path: {file_path}
                     # Current file content:
                     <CONTENT>
@@ -146,7 +215,7 @@ class PatchHandler:
                     act, msg = self.retry_comfirm()
                     if act == "break":
                         PrettyOutput.print("Terminate patch application", OutputType.WARNING)
-                        return False, msg
+                        return False
                     if act == "skip":
                         PrettyOutput.print(f"Skip file {file_path}", OutputType.WARNING)
                         break
@@ -154,13 +223,14 @@ class PatchHandler:
                         additional_info += msg + "\n"
                         continue
                 else:
+                    self._finalize_changes()
                     break
         
-        return True, ""
+        return True
 
 
 
-    def handle_patch_application(self, feature: str, raw_plan: str, structed_plan: Dict[str,str]) -> bool:
+    def handle_patch_application(self, feature: str, structed_plan: Dict[str,str]) -> bool:
         """Process patch application process
         
         Args:
@@ -176,13 +246,13 @@ class PatchHandler:
             PrettyOutput.print(f"\nFile: {file_path}", OutputType.INFO)
             PrettyOutput.print(f"Modification plan: \n{patches_code}", OutputType.INFO)
         # 3. Apply patches
-        success, error_msg = self.apply_patch(feature, raw_plan, structed_plan)
+        success = self.apply_patch(feature, structed_plan)
         if not success:
             os.system("git reset --hard")
             return False
         # 6. Apply successfully, let user confirm changes
         PrettyOutput.print("\nPatches applied, please check the modification effect.", OutputType.SUCCESS)
-        confirm = input("\nKeep these changes? (y/n) [y]: ").lower() or "y"
+        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