jarvis-ai-assistant 0.1.124__py3-none-any.whl → 0.1.126__py3-none-any.whl

jarvis/jarvis_code_agent/patch.py

@@ -1,16 +1,21 @@
 import re
-from typing import Dict, Any, List, Tuple
+from typing import Dict, Any, Tuple
 import os
+
 from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.read_code import ReadCodeTool
-from jarvis.jarvis_utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, user_confirm
-
+from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
+from jarvis.jarvis_tools.file_operation import FileOperationTool
+from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
+from jarvis.jarvis_utils.git_utils import get_commits_between, get_latest_commit_hash
+from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import user_confirm
 
 class PatchOutputHandler(OutputHandler):
     def name(self) -> str:
         return "PATCH"
-
     def handle(self, response: str) -> Tuple[bool, Any]:
         return False, apply_patch(response)
     
@@ -21,94 +26,51 @@ class PatchOutputHandler(OutputHandler):
     
     def prompt(self) -> str:
         return """
-# 🛠️ Code Patch Specification
-
-You can output multiple patches, each patch is a <PATCH> block.
+# 🛠️ 上下文代码补丁规范
+使用<PATCH>块来指定代码更改：
 --------------------------------
-# [OPERATION] on [FILE]
-# Start Line: [START_LINE], End Line: [END_LINE] [include/exclude], I can verify the line number range is correct
-# Reason: [CLEAR EXPLANATION]
 <PATCH>
-[FILE] [RANGE]
-[CONTENT]
+File: [文件路径]
+Reason: [修改原因]
+[上下文代码片段]
 </PATCH>
 --------------------------------
-
-Explain:
-- [OPERATION]: The operation to be performed, including:
-  - INSERT: Insert code before the specified line, [RANGE] should be [m,m)
-  - REPLACE: Replace code in the specified range, [RANGE] should be [m,n] n>=m
-  - DELETE: Delete code in the specified range, [RANGE] should be [m,n] n>=m
-  - NEW_FILE: Create a new file, [RANGE] should be [1,1)
-- [FILE]: The path of the file to be modified
-- [RANGE]: The range of the lines to be modified, [m,n] includes both m and n, [m,n) includes m but excludes n
-- [CONTENT]: The content of the code to be modified, if the operation is delete, the [CONTENT] is empty
-
-Critical Rules:
-- NEVER include unchanged code in patch content
-- ONLY show lines that are being modified/added
-- Maintain original line breaks around modified sections
-- Preserve surrounding comments unless explicitly modifying them
-- Verify line number range is correct
-- Verify indentation is correct
+规则：
+1. 代码片段必须包含足够的上下文（前后各3行）
+2. 我可以看到完整代码，所以只需显示修改的代码部分
+3. 保留原始缩进和格式
+4. 对于新文件，提供完整代码
+5. 修改现有文件时，保留周围未更改的代码
+示例：
+<PATCH>
+File: src/utils/math.py
+Reason: 修复除零处理
+def safe_divide(a, b):
+    # 添加参数验证
+    if b == 0:
+        raise ValueError("除数不能为零")
+    return a / b
+# 现有代码 ...
+def add(a, b):
+    return a + b
+</PATCH>
 """
 
-
-def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:
-    """解析补丁格式"""
+def _parse_patch(patch_str: str) -> Dict[str, str]:
+    """解析新的上下文补丁格式"""
     result = {}
-    # 更新正则表达式以更好地处理文件路径和范围
-    header_pattern = re.compile(
-        r'^\s*"?([^\n\r\[]+)"?\s*\[(\d+)(?:,(\d+))?([\]\)])\s*$',  # 匹配文件路径和行号
-        re.ASCII
-    )
     patches = re.findall(r'<PATCH>\n?(.*?)\n?</PATCH>', patch_str, re.DOTALL)
-    
-    for patch in patches:
-        parts = patch.split('\n', 1)
-        if len(parts) < 1:
-            continue
-        header_line = parts[0].strip()
-        content = parts[1] if len(parts) > 1 else ''
-        
-        if content and not content.endswith('\n'):
-            content += '\n'
-            
-        # 解析文件路径和行号
-        header_match = header_pattern.match(header_line)
-        if not header_match:
-            PrettyOutput.print(f"无法解析补丁头: {header_line}", OutputType.WARNING)
-            continue
-
-        filepath = header_match.group(1).strip()
-        
-        try:
-            start = int(header_match.group(2))  # 保持1-based行号
-            end = int(header_match.group(3)) if header_match.group(3) else start
-            range_type = header_match.group(4)  # ] 或 ) 表示范围类型
-        except (ValueError, IndexError) as e:
-            PrettyOutput.print(f"解析行号失败: {str(e)}", OutputType.WARNING)
-            continue
-
-        # 根据范围类型调整结束行号
-        if range_type == ')':  # 对于 [m,n) 格式，不包括第n行
-            end = end
-        else:  # 对于 [m,n] 格式，包括第n行
-            end = end + 1
-
-        if filepath not in result:
-            result[filepath] = []
-        result[filepath].append({
-            'filepath': filepath,
-            'start': start,
-            'end': end,
-            'content': content
-        })
-    for filepath in result.keys():
-        result[filepath] = sorted(result[filepath], key=lambda x: x['start'], reverse=True)
+    if patches:
+        for patch in patches:
+            first_line = patch.splitlines()[0]
+            sm = re.match(r'^File:\s*(.+)$', first_line)
+            if not sm:
+                PrettyOutput.print("无效的补丁格式", OutputType.WARNING)
+                continue
+            filepath = sm.group(1).strip()
+            result[filepath] = patch
     return result
 
-
 def apply_patch(output_str: str) -> str:
     """Apply patches to files"""
     try:
@@ -116,262 +78,171 @@ def apply_patch(output_str: str) -> str:
     except Exception as e:
         PrettyOutput.print(f"解析补丁失败: {str(e)}", OutputType.ERROR)
         return ""
-
-    ret = ""
     
-    for filepath, patch_list in patches.items():
-        for i, patch in enumerate(patch_list):
-            try:
-                err = handle_code_operation(filepath, patch)
-                if err:
-                    PrettyOutput.print(err, OutputType.WARNING)
-                    revert_change()
-                    return err
-                PrettyOutput.print(f"成功为文件{filepath}应用补丁{i+1}/{len(patch_list)}", OutputType.SUCCESS)
-            except Exception as e:
-                PrettyOutput.print(f"操作失败: {str(e)}", OutputType.ERROR)
+    # 获取当前提交hash作为起始点
+    start_hash = get_latest_commit_hash()
     
-    if has_uncommitted_changes():
-        diff = get_diff()
-        if handle_commit_workflow(diff):
-            ret += "Successfully applied the patch\n"
-            # Get modified line ranges
-            modified_ranges = get_modified_line_ranges()
-            modified_code = ReadCodeTool().execute({"files": [{"path": filepath, "start_line": start, "end_line": end} for filepath, (start, end) in modified_ranges.items()]})
-            if modified_code["success"]:
-                ret += "New code:\n"
-                ret += modified_code["stdout"]
+    # 按文件逐个处理
+    for filepath, patch_content in patches.items():
+        try:
+            handle_code_operation(filepath, patch_content)
+            PrettyOutput.print(f"文件 {filepath} 处理完成", OutputType.SUCCESS)
+        except Exception as e:
+            revert_file(filepath)  # 回滚单个文件
+            PrettyOutput.print(f"文件 {filepath} 处理失败: {str(e)}", OutputType.ERROR)
+    
+    final_ret = ""
+    diff = get_diff()
+    if diff:
+        PrettyOutput.print(diff, OutputType.CODE, lang="diff")
+        if handle_commit_workflow():
+            # 获取提交信息
+            end_hash = get_latest_commit_hash()
+            commits = get_commits_between(start_hash, end_hash)
+            
+            # 添加提交信息到final_ret
+            if commits:
+                final_ret += "✅ 补丁已应用\n"
+                final_ret += "提交信息:\n"
+                for commit_hash, commit_message in commits:
+                    final_ret += f"- {commit_hash[:7]}: {commit_message}\n"
+                
+                final_ret += f"应用补丁后的代码:\n{diff}"
+                 
+            else:
+                final_ret += "✅ 补丁已应用（没有新的提交）"
         else:
-            ret += "User rejected the patch\nThis is your patch preview:\n"
-            ret += diff
-        user_input = get_multiline_input("你可以继续输入（输入空行重试，Ctrl+C退出）: ")
-        if user_input:
-            ret += "\n" + user_input
+            final_ret += "❌ 我不想提交代码\n"
+            final_ret += "之前的代码:\n"
+            final_ret += diff
+    else:
+        final_ret += "❌ 没有要提交的更改\n"
+    # 用户确认最终结果
+    PrettyOutput.print(final_ret, OutputType.USER)
+    if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
+        return final_ret
+    return get_multiline_input("请输入自定义回复")
+def revert_file(filepath: str):
+    """增强版git恢复，处理新文件"""
+    import subprocess
+    try:
+        # 检查文件是否在版本控制中
+        result = subprocess.run(
+            ['git', 'ls-files', '--error-unmatch', filepath],
+            stderr=subprocess.PIPE
+        )
+        if result.returncode == 0:
+            subprocess.run(['git', 'checkout', 'HEAD', '--', filepath], check=True)
         else:
-            ret = ""
-
-    return ret  # Ensure a string is always returned
-
+            if os.path.exists(filepath):
+                os.remove(filepath)
+        subprocess.run(['git', 'clean', '-f', '--', filepath], check=True)
+    except subprocess.CalledProcessError as e:
+        PrettyOutput.print(f"恢复文件失败: {str(e)}", OutputType.ERROR)
+# 修改后的恢复函数
+def revert_change():
+    import subprocess
+    subprocess.run(['git', 'reset', '--hard', 'HEAD'], check=True)
+    subprocess.run(['git', 'clean', '-fd'], check=True)
+# 修改后的获取差异函数
 def get_diff() -> str:
-    """使用更安全的subprocess代替os.system"""
+    """使用git获取暂存区差异"""
     import subprocess
     try:
         subprocess.run(['git', 'add', '.'], check=True)
         result = subprocess.run(
-            ['git', 'diff', 'HEAD'],
+            ['git', 'diff', '--cached'],
             capture_output=True,
             text=True,
             check=True
         )
-        return result.stdout
-    finally:
-        subprocess.run(['git', 'reset', 'HEAD'], check=True)
-
-def revert_change():
-    import subprocess
-    subprocess.run(['git', 'reset', 'HEAD'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    subprocess.run(['git', 'checkout', '--', '.'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    subprocess.run(['git', 'clean', '-fd'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-def handle_commit_workflow(diff:str)->bool:
+        ret = result.stdout
+        subprocess.run(['git', "reset", "--soft", "HEAD"], check=True)
+        return ret
+    except subprocess.CalledProcessError as e:
+        return f"获取差异失败: {str(e)}"
+def handle_commit_workflow()->bool:
     """Handle the git commit workflow and return the commit details.
     
     Returns:
         tuple[bool, str, str]: (continue_execution, commit_id, commit_message)
     """
-    if not user_confirm("是否要提交代码？", default=True):
+    if is_confirm_before_apply_patch() and not user_confirm("是否要提交代码？", default=True):
         revert_change()
         return False
-
     git_commiter = GitCommitTool()
     commit_result = git_commiter.execute({})
     return commit_result["success"]
 
-def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
-    """Get modified line ranges from git diff for all changed files.
-    
-    Returns:
-        Dictionary mapping file paths to tuple with (start_line, end_line) ranges
-        for modified sections. Line numbers are 1-based.
-    """
-    # Get git diff for all files
-    diff_output = os.popen("git show").read()
-    
-    # Parse the diff to get modified files and their line ranges
-    result = {}
-    current_file = None
-    
-    for line in diff_output.splitlines():
-        # Match lines like "+++ b/path/to/file"
-        file_match = re.match(r"^\+\+\+ b/(.*)", line)
-        if file_match:
-            current_file = file_match.group(1)
-            continue
-            
-        # Match lines like "@@ -100,5 +100,7 @@" where the + part shows new lines
-        range_match = re.match(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", line)
-        if range_match and current_file:
-            start_line = int(range_match.group(1))  # Keep as 1-based
-            line_count = int(range_match.group(2)) if range_match.group(2) else 1
-            end_line = start_line + line_count - 1
-            result[current_file] = (start_line, end_line)
-    
-    return result
 # New handler functions below ▼▼▼
-
-def handle_new_file(filepath: str, patch: Dict[str, Any]):
-    """统一参数格式处理新文件"""
-    os.makedirs(os.path.dirname(filepath), exist_ok=True)
-    with open(filepath, 'w', encoding='utf-8') as f:
-        f.write(patch['content'])
-
-def handle_code_operation(filepath: str, patch: Dict[str, Any]) -> str:
-    """处理紧凑格式补丁"""
+def handle_code_operation(filepath: str, patch_content: str) -> str:
+    """处理基于上下文的代码片段"""
     try:
-        # 新建文件时强制覆盖
-        os.makedirs(os.path.dirname(filepath) or '.', exist_ok=True)
         if not os.path.exists(filepath):
+            # 新建文件
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
             open(filepath, 'w', encoding='utf-8').close()
-        with open(filepath, 'r+', encoding='utf-8') as f:
-            lines = f.readlines()
-            
-            new_lines = validate_and_apply_changes(
-                lines,
-                patch['start'],
-                patch['end'],
-                patch['content']
-            )
-            
-            f.seek(0)
-            f.writelines(new_lines)
-            f.truncate()
-        PrettyOutput.print(f"成功更新 {filepath}", OutputType.SUCCESS)
-        return ""
-    except Exception as e:
-        error_msg = f"Failed to handle code operation: {str(e)}"
-        PrettyOutput.print(error_msg, OutputType.ERROR)
-        return error_msg
-def validate_and_apply_changes(
-    lines: List[str],
-    start: int,
-    end: int,
-    content: str
-) -> List[str]:
-    new_content = content.splitlines(keepends=True)
-    
-    # 插入操作处理
-    if start == end:
-        if start < 1 or start > len(lines)+1:
-            raise ValueError(f"无效插入位置: {start}")
-        return lines[:start-1] + new_content + lines[start-1:]
-    
-    # 范围替换/删除操作
-    if start > end:
-        raise ValueError(f"起始行{start}不能大于结束行{end}")
-    
-    max_line = len(lines)
-    # 自动修正行号范围
-    start = max(1, min(start, max_line+1))
-    end = max(start, min(end, max_line+1))
-    
-    # 执行替换
-    return lines[:start-1] + new_content + lines[end-1:]
-
-
-def file_input_handler(user_input: str, agent: Any) -> str:
-    """Handle file input with optional line ranges.
-    
-    Args:
-        user_input: User input string containing file references
-        agent: Agent instance (unused in current implementation)
+        old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
+        if not old_file_content["success"]:
+            return f"文件读取失败: {old_file_content['stderr']}"
         
-    Returns:
-        str: Prompt with file contents prepended if files are found
-    """
-    prompt = user_input
-    files = []
-    
-    file_refs = re.findall(r"'([^']+)'", user_input)
-    for ref in file_refs:
-        # Handle file:start,end or file:start:end format
-        if ':' in ref:
-            file_path, line_range = ref.split(':', 1)
-            # Initialize with default values
-            start_line = 1  # 1-based
-            end_line = -1
-            
-            # Process line range if specified
-            if ',' in line_range or ':' in line_range:
-                try:
-                    raw_start, raw_end = map(int, re.split(r'[,:]', line_range))
-                    
-                    # Handle special values and Python-style negative indices
-                    try:
-                        with open(file_path, 'r', encoding='utf-8') as f:
-                            total_lines = len(f.readlines())
-                    except FileNotFoundError:
-                        PrettyOutput.print(f"文件不存在: {file_path}", OutputType.WARNING)
-                        continue
-                    # Process start line
-                    if raw_start == 0:  # 0表示整个文件
-                        start_line = 1
-                        end_line = total_lines
-                    else:
-                        start_line = raw_start if raw_start > 0 else total_lines + raw_start + 1
-                    
-                    # Process end line
-                    if raw_end == 0:  # 0表示整个文件（如果start也是0）
-                        end_line = total_lines
-                    else:
-                        end_line = raw_end if raw_end > 0 else total_lines + raw_end + 1
-                    
-                    # Auto-correct ranges
-                    start_line = max(1, min(start_line, total_lines))
-                    end_line = max(start_line, min(end_line, total_lines))
-                    
-                    # Final validation
-                    if start_line < 1 or end_line > total_lines or start_line > end_line:
-                        raise ValueError
-
-                except:
-                    continue
-            
-            # Add file if it exists
-            if os.path.isfile(file_path):
-                files.append({
-                    "path": file_path,
-                    "start_line": start_line,
-                    "end_line": end_line
-                })
-        else:
-            # Handle simple file path
-            if os.path.isfile(ref):
-                files.append({
-                    "path": ref,
-                    "start_line": 1,  # 1-based
-                    "end_line": -1
-                })
-    
-    # Read and process files if any were found
-    if files:
-        result = ReadCodeTool().execute({"files": files})
-        if result["success"]:
-            return result["stdout"] + "\n" + prompt
-    
-    return prompt + """
-==================================================================
-Patch Line Number Range Rules:
-- INSERT: [m,m)
-- REPLACE: [m,n] n>=m
-- DELETE: [m,n] n>=m
-- NEW_FILE: [1,1)
-
-Critical Rules:
-- NEVER include unchanged code in patch content
-- ONLY show lines that are being modified/added
-- Maintain original line breaks around modified sections
-- Preserve surrounding comments unless explicitly modifying them
-- Verify line number range is correct
-- Verify indentation is correct
-==================================================================
+        prompt = f"""
+你是一个代码审查员，请审查以下代码并将其与上下文合并。
+原始代码:
+{old_file_content["stdout"]}
+补丁内容:
+{patch_content}
+"""
+        prompt += f"""
+请将代码与上下文合并并返回完整的合并代码。
+
+要求:
+1. 严格保留原始代码的格式、空行和缩进
+2. 仅在<MERGED_CODE>块中包含实际代码内容，包括空行和缩进
+3. 绝对不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
+4. 除了合并后的代码，不要输出任何其他文本
+
+输出格式:
+<MERGED_CODE>
+[merged_code]
+</MERGED_CODE>
 """
+        model = PlatformRegistry().get_codegen_platform()
+        model.set_suppress_output(False)
+        count = 5
+        start_line = -1
+        end_line = -1
+        response = []
+        while count > 0:
+            count -= 1
+            response.extend(model.chat_until_success(prompt).splitlines())
+            try:
+                start_line = response.index("<MERGED_CODE>") + 1
+            except:
+                pass
+            try:
+                end_line = response.index("</MERGED_CODE>")
+            except:
+                pass
+            if start_line == -1:
+                PrettyOutput.print(f"❌ 为文件 {filepath} 应用补丁失败", OutputType.WARNING)
+                return f"代码合并失败"
+            if end_line == -1:
+                last_line = response[-1]
+                prompt = f"""
+                继续从最后一行开始（不要包含<MERGED_CODE>标签，完成后输出</MERGED_CODE>标签）：
+                {last_line}
+                """
+                response.pop() # 删除最后一行
+                continue
+            if end_line < start_line:
+                PrettyOutput.print(f"❌ 为文件 {filepath} 应用补丁失败", OutputType.WARNING)
+                return f"代码合并失败"
+            break
+        # 写入合并后的代码
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write("\n".join(response[start_line:end_line])+"\n")
+        PrettyOutput.print(f"✅ 为文件 {filepath} 应用补丁成功", OutputType.SUCCESS)
+        return ""
+    except Exception as e:
+        return f"文件操作失败: {str(e)}"

jarvis/jarvis_code_agent/shell_input_handler.py

@@ -0,0 +1,22 @@
+
+
+from typing import Any, Tuple
+
+from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import user_confirm
+
+
+def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
+    lines = user_input.splitlines()
+    cmdline = [line for line in lines if line.startswith("!")]
+    if len(cmdline) == 0:
+        return user_input, False
+    else:
+        script = '\n'.join([c[1:] for c in cmdline])
+        PrettyOutput.print(script, OutputType.CODE, lang="bash")
+        if user_confirm(f"是否要执行以上shell脚本？", default=True):
+            ShellScriptTool().execute({"script_content": script})
+            return "", True
+        return user_input, False
+