π OpenHands: AI-Driven Development
Replace bash scripts with Python for git operations (#9914)
Tim O'Farrelld9a595c9b14f
diff --git a/openhands/runtime/base.py b/openhands/runtime/base.pyindex 601ced85a7..af499f3d2d 100644--- a/openhands/runtime/base.py+++ b/openhands/runtime/base.py@@ -133,7 +133,8 @@ class Runtime(FileEditRuntimeMixin):git_provider_tokens: PROVIDER_TOKEN_TYPE | None = None,):self.git_handler = GitHandler(- execute_shell_fn=self._execute_shell_fn_git_handler+ execute_shell_fn=self._execute_shell_fn_git_handler,+ create_file_fn=self._create_file_fn_git_handler,)self.sid = sidself.event_stream = event_stream@@ -1017,6 +1018,15 @@ fireturn CommandResult(content=content, exit_code=exit_code)+ def _create_file_fn_git_handler(self, path: str, content: str) -> int:+ """+ This function is used by the GitHandler to execute shell commands.+ """+ obs = self.write(FileWriteAction(path=path, content=content))+ if isinstance(obs, ErrorObservation):+ return -1+ return 0+def get_git_changes(self, cwd: str) -> list[dict[str, str]] | None:self.git_handler.set_cwd(cwd)changes = self.git_handler.get_git_changes()diff --git a/openhands/runtime/utils/git_changes.py b/openhands/runtime/utils/git_changes.pynew file mode 100644index 0000000000..754cf3948c--- /dev/null+++ b/openhands/runtime/utils/git_changes.py@@ -0,0 +1,195 @@+#!/usr/bin/env python3+"""+Get git changes in the current working directory relative to the remote origin if possible.+NOTE: Since this is run as a script, there should be no imports from project files!+"""++import glob+import json+import os+import subprocess+from pathlib import Path+++def run(cmd: str, cwd: str) -> str:+ result = subprocess.run(+ args=cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd+ )+ byte_content = result.stderr or result.stdout or b''++ if result.returncode != 0:+ raise RuntimeError(+ f'error_running_cmd:{result.returncode}:{byte_content.decode()}'+ )+ return byte_content.decode().strip()+++def get_valid_ref(repo_dir: str) -> str | None:+ try:+ current_branch = run('git --no-pager rev-parse --abbrev-ref HEAD', repo_dir)+ except RuntimeError:+ # Not a git repository (Or no commits)+ return None++ try:+ default_branch = (+ run('git --no-pager remote show origin | grep "HEAD branch"', repo_dir)+ .split()[-1]+ .strip()+ )+ except RuntimeError:+ # Git repository does not have a remote origin - use current+ return current_branch++ ref_current_branch = f'origin/{current_branch}'+ ref_non_default_branch = f'$(git --no-pager merge-base HEAD "$(git --no-pager rev-parse --abbrev-ref origin/{default_branch})")'+ ref_default_branch = f'origin/{default_branch}'+ ref_new_repo = '$(git --no-pager rev-parse --verify 4b825dc642cb6eb9a060e54bf8d69288fbee4904)' # compares with empty tree++ refs = [+ ref_current_branch,+ ref_non_default_branch,+ ref_default_branch,+ ref_new_repo,+ ]+ # Find a ref that exists...+ for ref in refs:+ try:+ result = run(f'git --no-pager rev-parse --verify {ref}', repo_dir)+ return result+ except RuntimeError:+ # invalid ref - try next+ continue++ return None+++def get_changes_in_repo(repo_dir: str) -> list[dict[str, str]]:+ # Gets the status relative to the origin default branch - not the same as `git status`++ ref = get_valid_ref(repo_dir)+ if not ref:+ return []++ # Get changed files+ changed_files = run(+ f'git --no-pager diff --name-status {ref}', repo_dir+ ).splitlines()+ changes = []+ for line in changed_files:+ if not line.strip():+ raise RuntimeError(f'unexpected_value_in_git_diff:{changed_files}')++ # Handle different output formats from git diff --name-status+ # Depending on git config, format can be either:+ # * "A file.txt"+ # * "A file.txt"+ # * "R100 old_file.txt new_file.txt" (rename with similarity percentage)+ parts = line.split()+ if len(parts) < 2:+ raise RuntimeError(f'unexpected_value_in_git_diff:{changed_files}')++ status = parts[0].strip()++ # Handle rename operations (status starts with 'R' followed by similarity percentage)+ if status.startswith('R') and len(parts) == 3:+ # Rename: convert to delete (old path) + add (new path)+ old_path = parts[1].strip()+ new_path = parts[2].strip()+ changes.append(+ {+ 'status': 'D',+ 'path': old_path,+ }+ )+ changes.append(+ {+ 'status': 'A',+ 'path': new_path,+ }+ )+ continue++ # Handle copy operations (status starts with 'C' followed by similarity percentage)+ elif status.startswith('C') and len(parts) == 3:+ # Copy: only add the new path (original remains)+ new_path = parts[2].strip()+ changes.append(+ {+ 'status': 'A',+ 'path': new_path,+ }+ )+ continue++ # Handle regular operations (M, A, D, etc.)+ elif len(parts) == 2:+ path = parts[1].strip()+ else:+ raise RuntimeError(f'unexpected_value_in_git_diff:{changed_files}')++ if status == '??':+ status = 'A'+ elif status == '*':+ status = 'M'++ # Check for valid single-character status codes+ if status in {'M', 'A', 'D', 'U'}:+ changes.append(+ {+ 'status': status,+ 'path': path,+ }+ )+ else:+ raise RuntimeError(f'unexpected_status_in_git_diff:{changed_files}')++ # Get untracked files+ untracked_files = run(+ 'git --no-pager ls-files --others --exclude-standard', repo_dir+ ).splitlines()+ for path in untracked_files:+ if path:+ changes.append({'status': 'A', 'path': path})++ return changes+++def get_git_changes(cwd: str) -> list[dict[str, str]]:+ git_dirs = {+ os.path.dirname(f)[2:]+ for f in glob.glob('./*/.git', root_dir=cwd, recursive=True)+ }++ # First try the workspace directory+ changes = get_changes_in_repo(cwd)++ # Filter out any changes which are in one of the git directories+ changes = [+ change+ for change in changes+ if next(+ iter(git_dir for git_dir in git_dirs if change['path'].startswith(git_dir)),+ None,+ )+ is None+ ]++ # Add changes from git directories+ for git_dir in git_dirs:+ git_dir_changes = get_changes_in_repo(str(Path(cwd, git_dir)))+ for change in git_dir_changes:+ change['path'] = git_dir + '/' + change['path']+ changes.append(change)++ changes.sort(key=lambda change: change['path'])++ return changes+++if __name__ == '__main__':+ try:+ changes = get_git_changes(os.getcwd())+ print(json.dumps(changes))+ except Exception as e:+ print(json.dumps({'error': str(e)}))diff --git a/openhands/runtime/utils/git_diff.py b/openhands/runtime/utils/git_diff.pynew file mode 100644index 0000000000..92c854061e--- /dev/null+++ b/openhands/runtime/utils/git_diff.py@@ -0,0 +1,103 @@+#!/usr/bin/env python3+"""+Get git diff in a single git file for the closest git repo in the file system+NOTE: Since this is run as a script, there should be no imports from project files!+"""++import json+import os+import subprocess+import sys+from pathlib import Path+++def get_closest_git_repo(path: Path) -> Path | None:+ while True:+ path = path.parent+ git_path = Path(path, '.git')+ if git_path.is_dir():+ return path+ if path.parent == path:+ return None+++def run(cmd: str, cwd: str) -> str:+ result = subprocess.run(+ args=cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd+ )+ byte_content = result.stderr or result.stdout or b''++ if result.returncode != 0:+ raise RuntimeError(+ f'error_running_cmd:{result.returncode}:{byte_content.decode()}'+ )+ return byte_content.decode().strip()+++def get_valid_ref(repo_dir: str) -> str | None:+ try:+ current_branch = run('git --no-pager rev-parse --abbrev-ref HEAD', repo_dir)+ except RuntimeError:+ # Not a git repository (Or no commits)+ return None++ try:+ default_branch = (+ run('git --no-pager remote show origin | grep "HEAD branch"', repo_dir)+ .split()[-1]+ .strip()+ )+ except RuntimeError:+ # Git repository does not have a remote origin - use current+ return current_branch++ ref_current_branch = f'origin/{current_branch}'+ ref_non_default_branch = f'$(git --no-pager merge-base HEAD "$(git --no-pager rev-parse --abbrev-ref origin/{default_branch})")'+ ref_default_branch = 'origin/' + default_branch+ ref_new_repo = '$(git --no-pager rev-parse --verify 4b825dc642cb6eb9a060e54bf8d69288fbee4904)' # compares with empty tree++ refs = [+ ref_current_branch,+ ref_non_default_branch,+ ref_default_branch,+ ref_new_repo,+ ]+ # Find a ref that exists...+ for ref in refs:+ try:+ run(f'git --no-pager rev-parse --verify {ref}', repo_dir)+ return ref+ except RuntimeError:+ # invalid ref - try next+ continue++ return None+++def get_git_diff(relative_file_path: str) -> dict[str, str]:+ path = Path(os.getcwd(), relative_file_path).resolve()+ closest_git_repo = get_closest_git_repo(path)+ if not closest_git_repo:+ raise ValueError('no_repo')+ current_rev = get_valid_ref(str(closest_git_repo))+ try:+ original = run(+ f'git show "{current_rev}:{path.relative_to(closest_git_repo)}"',+ str(closest_git_repo),+ )+ except RuntimeError:+ original = ''+ try:+ with open(path, 'r') as f:+ modified = '\n'.join(f.read().splitlines())+ except FileNotFoundError:+ modified = ''+ return {+ 'modified': modified,+ 'original': original,+ }+++if __name__ == '__main__':+ diff = get_git_diff(sys.argv[-1])+ print(json.dumps(diff))diff --git a/openhands/runtime/utils/git_handler.py b/openhands/runtime/utils/git_handler.pyindex 8a165a06d6..d3efa2ed58 100644--- a/openhands/runtime/utils/git_handler.py+++ b/openhands/runtime/utils/git_handler.py@@ -1,6 +1,15 @@+import jsonfrom dataclasses import dataclass+from pathlib import Pathfrom typing import Callable-from uuid import uuid4++from openhands.core.logger import openhands_logger as logger+from openhands.runtime.utils import git_changes, git_diff++GIT_CHANGES_CMD = 'python3 /openhands/code/openhands/runtime/utils/git_changes.py'+GIT_DIFF_CMD = (+ 'python3 /openhands/code/openhands/runtime/utils/git_diff.py "{file_path}"'+)@dataclass@@ -25,9 +34,13 @@ class GitHandler:def __init__(self,execute_shell_fn: Callable[[str, str | None], CommandResult],+ create_file_fn: Callable[[str, str], int],):self.execute = execute_shell_fn+ self.create_file_fn = create_file_fnself.cwd: str | None = None+ self.git_changes_cmd = GIT_CHANGES_CMD+ self.git_diff_cmd = GIT_DIFF_CMDdef set_cwd(self, cwd: str) -> None:"""@@ -38,148 +51,13 @@ class GitHandler:"""self.cwd = cwd- def _is_git_repo(self) -> bool:- """- Checks if the current directory is a Git repository.-- Returns:- bool: True if inside a Git repository, otherwise False.- """- cmd = 'git --no-pager rev-parse --is-inside-work-tree'- output = self.execute(cmd, self.cwd)- return output.content.strip() == 'true'-- def _get_current_file_content(self, file_path: str) -> str:- """- Retrieves the current content of a given file.-- Args:- file_path (str): Path to the file.-- Returns:- str: The file content.- """- output = self.execute(f'cat {file_path}', self.cwd)- return output.content-- def _verify_ref_exists(self, ref: str) -> bool:- """- Verifies whether a specific Git reference exists.-- Args:- ref (str): The Git reference to check.-- Returns:- bool: True if the reference exists, otherwise False.- """- cmd = f'git --no-pager rev-parse --verify {ref}'- output = self.execute(cmd, self.cwd)- return output.exit_code == 0-- def _get_ref_content(self, file_path: str) -> str:- """- Retrieves the content of a file from a valid Git reference.- Finds the git repository closest to the file in the tree and executes the command in that context.-- Args:- file_path (str): The file path in the repository.-- Returns:- str: The content of the file from the reference, or an empty string if unavailable.- """- if not self.cwd:- return ''-- unique_id = uuid4().hex-- # Single bash command that finds the closest git repository to the file and gets the ref content- cmd = f"""bash -c '- # Convert to absolute path- file_path="$(realpath "{file_path}")"-- # Find the closest git repository by walking up the directory tree- current_dir="$(dirname "$file_path")"- git_repo_dir=""-- while [[ "$current_dir" != "/" ]]; do- if [[ -d "$current_dir/.git" ]] || git -C "$current_dir" rev-parse --git-dir >/dev/null 2>&1; then- git_repo_dir="$current_dir"- break- fi- current_dir="$(dirname "$current_dir")"- done-- # If no git repository found, exit- if [[ -z "$git_repo_dir" ]]; then- exit 1- fi-- # Get the file path relative to the git repository root- repo_root="$(cd "$git_repo_dir" && git rev-parse --show-toplevel)"- relative_file_path="${{file_path#${{repo_root}}/}}"-- # Function to get current branch- get_current_branch() {{- git -C "$git_repo_dir" rev-parse --abbrev-ref HEAD 2>/dev/null- }}-- # Function to get default branch- get_default_branch() {{- git -C "$git_repo_dir" remote show origin 2>/dev/null | grep "HEAD branch" | awk "{{print \\$NF}}" || echo "main"- }}-- # Function to verify if a ref exists- verify_ref_exists() {{- git -C "$git_repo_dir" rev-parse --verify "$1" >/dev/null 2>&1- }}-- # Get valid reference for comparison- current_branch="$(get_current_branch)"- default_branch="$(get_default_branch)"-- # Check if origin remote exists- has_origin="$(git -C "$git_repo_dir" remote | grep -q "^origin$" && echo "true" || echo "false")"-- if [[ "$has_origin" == "true" ]]; then- ref_current_branch="origin/$current_branch"- ref_non_default_branch="$(git -C "$git_repo_dir" merge-base HEAD "$(git -C "$git_repo_dir" rev-parse --abbrev-ref origin/$default_branch)" 2>/dev/null || echo "")"- ref_default_branch="origin/$default_branch"- else- # For repositories without origin, try HEAD~1 (previous commit) or empty tree- ref_current_branch="HEAD~1"- ref_non_default_branch=""- ref_default_branch=""- fi- ref_new_repo="$(git -C "$git_repo_dir" rev-parse --verify 4b825dc642cb6eb9a060e54bf8d69288fbee4904 2>/dev/null || echo "")" # empty tree-- # Try refs in order of preference- valid_ref=""- for ref in "$ref_current_branch" "$ref_non_default_branch" "$ref_default_branch" "$ref_new_repo"; do- if [[ -n "$ref" ]] && verify_ref_exists "$ref"; then- valid_ref="$ref"- break- fi- done-- # If no valid ref found, exit- if [[ -z "$valid_ref" ]]; then- exit 1- fi-- # Get the file content from the reference- git -C "$git_repo_dir" show "$valid_ref:$relative_file_path" 2>/dev/null || exit 1-- # {unique_id}'"""-- result = self.execute(cmd, self.cwd)-- if result.exit_code != 0:- return ''-- # TODO: The command echoes the bash script. Why?- content = result.content.split(f'{unique_id}')[-1]-- return content+ def _create_python_script_file(self, file: str):+ result = self.execute('mktemp -d', self.cwd)+ script_file = Path(result.content.strip(), Path(file).name)+ with open(file, 'r') as f:+ self.create_file_fn(str(script_file), f.read())+ result = self.execute(f'chmod +x "{script_file}"', self.cwd)+ return script_filedef get_git_changes(self) -> list[dict[str, str]] | None:"""@@ -195,57 +73,31 @@ class GitHandler:if not self.cwd:return None- # Single bash command that:- # 1. Creates a list of directories to check (current dir + direct subdirectories)- # 2. For each directory, checks if it's a git repo and gets status- # 3. Outputs in format: REPO_PATH|STATUS|FILE_PATH- cmd = """bash -c '- {- # Check current directory first- echo "."- # List direct subdirectories (excluding hidden ones)- find . -maxdepth 1 -type d ! -name ".*" ! -name "." 2>/dev/null || true- } | while IFS= read -r dir; do- if [ -d "$dir/.git" ] || git -C "$dir" rev-parse --git-dir >/dev/null 2>&1; then- # Get absolute path of the directory- # Get git status for this repository- git -C "$dir" status --porcelain -uall 2>/dev/null | while IFS= read -r line; do- if [ -n "$line" ]; then- # Extract status (first 2 chars) and file path (from char 3 onwards)- status=$(echo "$line" | cut -c1-2)- file_path=$(echo "$line" | cut -c4-)- # Convert status codes to single character- case "$status" in- "M "*|" M") echo "$dir|M|$file_path" ;;- "A "*|" A") echo "$dir|A|$file_path" ;;- "D "*|" D") echo "$dir|D|$file_path" ;;- "R "*|" R") echo "$dir|R|$file_path" ;;- "C "*|" C") echo "$dir|C|$file_path" ;;- "U "*|" U") echo "$dir|U|$file_path" ;;- "??") echo "$dir|A|$file_path" ;;- *) echo "$dir|M|$file_path" ;;- esac- fi- done- fi- done- ' """-- result = self.execute(cmd.strip(), self.cwd)- if result.exit_code != 0 or not result.content.strip():+ result = self.execute(self.git_changes_cmd, self.cwd)+ if result.exit_code == 0:+ try:+ changes = json.loads(result.content)+ return changes+ except Exception:+ logger.exception(+ 'GitHandler:get_git_changes:error',+ extra={'content': result.content},+ )+ return None++ if self.git_changes_cmd != GIT_CHANGES_CMD:+ # We have already tried to add a script to the workspace - it did not workreturn None- # Parse the output- changes = []- for line in result.content.strip().split('\n'):- if '|' in line:- parts = line.split('|', 2)- if len(parts) == 3:- repo_path, status, file_path = parts- file_path = f'{repo_path}/{file_path}'[2:]- changes.append({'status': status, 'path': file_path})+ # We try to add a script for getting git changes to the runtime - legacy runtimes may be missing the script+ logger.info(+ 'GitHandler:get_git_changes: adding git_changes script to runtime...'+ )+ script_file = self._create_python_script_file(git_changes.__file__)+ self.git_changes_cmd = f'python3 {script_file}'- return changes if changes else None+ # Try again with the new changes cmd+ return self.get_git_changes()def get_git_diff(self, file_path: str) -> dict[str, str]:"""@@ -257,36 +109,23 @@ class GitHandler:Returns:dict[str, str]: A dictionary containing the original and modified content."""- modified = self._get_current_file_content(file_path)- original = self._get_ref_content(file_path)-- return {- 'modified': modified,- 'original': original,- }+ # If cwd is not set, return None+ if not self.cwd:+ raise ValueError('no_dir_in_git_diff')+ result = self.execute(self.git_diff_cmd.format(file_path=file_path), self.cwd)+ if result.exit_code == 0:+ diff = json.loads(result.content)+ return diff-def parse_git_changes(changes_list: list[str]) -> list[dict[str, str]]:- """- Parses the list of changed files and extracts their statuses and paths.+ if self.git_diff_cmd != GIT_DIFF_CMD:+ # We have already tried to add a script to the workspace - it did not work+ raise ValueError('error_in_git_diff')- Args:- changes_list (list[str]): List of changed file entries.+ # We try to add a script for getting git changes to the runtime - legacy runtimes may be missing the script+ logger.info('GitHandler:get_git_diff: adding git_diff script to runtime...')+ script_file = self._create_python_script_file(git_diff.__file__)+ self.git_diff_cmd = f'python3 {script_file} "{{file_path}}"'- Returns:- list[dict[str, str]]: Parsed list of file changes with statuses.- """- result = []- for line in changes_list:- status = line[:2].strip()- path = line[2:].strip()-- # Get the first non-space character as the primary status- primary_status = status.replace(' ', '')[0]- result.append(- {- 'status': primary_status,- 'path': path,- }- )- return result+ # Try again with the new changes cmd+ return self.get_git_diff(file_path)diff --git a/tests/unit/test_git_handler.py b/tests/unit/test_git_handler.pyindex 59434023cd..7f94d0120d 100644--- a/tests/unit/test_git_handler.py+++ b/tests/unit/test_git_handler.py@@ -1,12 +1,19 @@import osimport shutilimport subprocess+import sysimport tempfileimport unittest+from pathlib import Path+from unittest.mock import patch+import pytest++from openhands.runtime.utils import git_changes, git_diff, git_handlerfrom openhands.runtime.utils.git_handler import CommandResult, GitHandler[email protected](sys.platform == 'win32', reason='Windows is not supported')class TestGitHandler(unittest.TestCase):def setUp(self):# Create temporary directories for our test repositories@@ -20,11 +27,17 @@ class TestGitHandler(unittest.TestCase):# Track executed commands for verificationself.executed_commands = []+ self.created_files = []- # Initialize the GitHandler with our real execute function- self.git_handler = GitHandler(self._execute_command)+ # Initialize the GitHandler with our mock functions+ self.git_handler = GitHandler(+ execute_shell_fn=self._execute_command, create_file_fn=self._create_file+ )self.git_handler.set_cwd(self.local_dir)+ self.git_handler.git_changes_cmd = f'python3 {git_changes.__file__}'+ self.git_handler.git_diff_cmd = f'python3 {git_diff.__file__} "{{file_path}}"'+# Set up the git repositoriesself._setup_git_repos()@@ -34,202 +47,265 @@ class TestGitHandler(unittest.TestCase):def _execute_command(self, cmd, cwd=None):"""Execute a shell command and return the result."""- self.executed_commands.append((cmd, cwd))- try:- result = subprocess.run(- cmd, shell=True, cwd=cwd, capture_output=True, text=True, check=False+ result = subprocess.run(+ args=cmd,+ shell=True,+ stdout=subprocess.PIPE,+ stderr=subprocess.PIPE,+ cwd=cwd,+ )+ stderr = result.stderr or b''+ stdout = result.stdout or b''+ return CommandResult((stderr + stdout).decode(), result.returncode)++ def run_command(self, cmd, cwd=None):+ result = self._execute_command(cmd, cwd)+ if result.exit_code != 0:+ raise RuntimeError(+ f'command_error:{cmd};{result.exit_code};{result.content}')- return CommandResult(result.stdout, result.returncode)- except Exception as e:- return CommandResult(str(e), 1)++ def _create_file(self, path, content):+ """Mock function for creating files."""+ self.created_files.append((path, content))+ try:+ with open(path, 'w') as f:+ f.write(content)+ return 0+ except Exception:+ return -1++ def write_file(+ self,+ dir: str,+ name: str,+ additional_content: tuple[str, ...] = ('Line 1', 'Line 2', 'Line 3'),+ ):+ with open(os.path.join(dir, name), 'w') as f:+ f.write(name)+ for line in additional_content:+ f.write('\n')+ f.write(line)+ assert os.path.exists(os.path.join(dir, name))def _setup_git_repos(self):"""Set up real git repositories for testing."""# Set up origin repository+ self.run_command('git init --initial-branch=main', self.origin_dir)self._execute_command(- 'git --no-pager init --initial-branch=main', self.origin_dir- )- self._execute_command(- "git --no-pager config user.email '[email protected]'", self.origin_dir- )- self._execute_command(- "git --no-pager config user.name 'Test User'", self.origin_dir- )-- # Create a file and commit it- with open(os.path.join(self.origin_dir, 'file1.txt'), 'w') as f:- f.write('Original content')-- self._execute_command('git --no-pager add file1.txt', self.origin_dir)- self._execute_command(- "git --no-pager commit -m 'Initial commit'", self.origin_dir+ "git config user.email '[email protected]'", self.origin_dir)+ self._execute_command("git config user.name 'Test User'", self.origin_dir)++ # Set up the initial state...+ self.write_file(self.origin_dir, 'unchanged.txt')+ self.write_file(self.origin_dir, 'committed_modified.txt')+ self.write_file(self.origin_dir, 'staged_modified.txt')+ self.write_file(self.origin_dir, 'unstaged_modified.txt')+ self.write_file(self.origin_dir, 'committed_delete.txt')+ self.write_file(self.origin_dir, 'staged_delete.txt')+ self.write_file(self.origin_dir, 'unstaged_delete.txt')+ self.run_command("git add . && git commit -m 'Initial Commit'", self.origin_dir)# Clone the origin repository to local- self._execute_command(- f'git --no-pager clone {self.origin_dir} {self.local_dir}'- )- self._execute_command(- "git --no-pager config user.email '[email protected]'", self.local_dir- )- self._execute_command(- "git --no-pager config user.name 'Test User'", self.local_dir- )+ self.run_command(f'git clone "{self.origin_dir}" "{self.local_dir}"')- # Create a feature branch in the local repositoryself._execute_command(- 'git --no-pager checkout -b feature-branch', self.local_dir+ "git config user.email '[email protected]'", self.local_dir)+ self._execute_command("git config user.name 'Test User'", self.local_dir)- # Modify a file and create a new file- with open(os.path.join(self.local_dir, 'file1.txt'), 'w') as f:- f.write('Modified content')+ self.run_command('git checkout -b feature-branch', self.local_dir)- with open(os.path.join(self.local_dir, 'file2.txt'), 'w') as f:- f.write('New file content')-- # Add and commit file1.txt changes to create a baseline- self._execute_command('git --no-pager add file1.txt', self.local_dir)- self._execute_command(- "git --no-pager commit -m 'Update file1.txt'", self.local_dir+ # Setup committed changes...+ self.write_file(self.local_dir, 'committed_modified.txt', ('Line 4',))+ self.write_file(self.local_dir, 'committed_add.txt')+ os.remove(os.path.join(self.local_dir, 'committed_delete.txt'))+ self.run_command(+ "git add . && git commit -m 'First batch of changes'", self.local_dir)- # Add and commit file2.txt, then modify it- self._execute_command('git --no-pager add file2.txt', self.local_dir)- self._execute_command(- "git --no-pager commit -m 'Add file2.txt'", self.local_dir- )-- # Modify file2.txt and stage it- with open(os.path.join(self.local_dir, 'file2.txt'), 'w') as f:- f.write('Modified new file content')- self._execute_command('git --no-pager add file2.txt', self.local_dir)-- # Create a file that will be deleted- with open(os.path.join(self.local_dir, 'file3.txt'), 'w') as f:- f.write('File to be deleted')-- self._execute_command('git --no-pager add file3.txt', self.local_dir)- self._execute_command(- "git --no-pager commit -m 'Add file3.txt'", self.local_dir- )- self._execute_command('git --no-pager rm file3.txt', self.local_dir)+ # Setup staged changes...+ self.write_file(self.local_dir, 'staged_modified.txt', ('Line 4',))+ self.write_file(self.local_dir, 'staged_add.txt')+ os.remove(os.path.join(self.local_dir, 'staged_delete.txt'))+ self.run_command('git add .', self.local_dir)++ # Setup unstaged changes...+ self.write_file(self.local_dir, 'unstaged_modified.txt', ('Line 4',))+ self.write_file(self.local_dir, 'unstaged_add.txt')+ os.remove(os.path.join(self.local_dir, 'unstaged_delete.txt'))++ def setup_nested(self):+ nested_1 = Path(self.local_dir, 'nested 1')+ nested_1.mkdir()+ nested_1 = str(nested_1)+ self.run_command('git init --initial-branch=main', nested_1)+ self._execute_command("git config user.email '[email protected]'", nested_1)+ self._execute_command("git config user.name 'Test User'", nested_1)+ self.write_file(nested_1, 'committed_add.txt')+ self.run_command('git add .', nested_1)+ self.run_command('git commit -m "Initial Commit"', nested_1)+ self.write_file(nested_1, 'staged_add.txt')++ nested_2 = Path(self.local_dir, 'nested_2')+ nested_2.mkdir()+ nested_2 = str(nested_2)+ self.run_command('git init --initial-branch=main', nested_2)+ self._execute_command("git config user.email '[email protected]'", nested_2)+ self._execute_command("git config user.name 'Test User'", nested_2)+ self.write_file(nested_2, 'committed_add.txt')+ self.run_command('git add .', nested_2)+ self.run_command('git commit -m "Initial Commit"', nested_2)+ self.write_file(nested_2, 'unstaged_add.txt')- # Modify file1.txt again but don't stage it (unstaged change)- with open(os.path.join(self.local_dir, 'file1.txt'), 'w') as f:- f.write('Modified content again')-- # Push the feature branch to origin- self._execute_command(- 'git --no-pager push -u origin feature-branch', self.local_dir- )-- def test_is_git_repo(self):- """Test that _is_git_repo returns True for a git repository."""- self.assertTrue(self.git_handler._is_git_repo())+ def test_get_git_changes(self):+ """+ Test with unpushed commits, staged commits, and unstaged commits+ """+ changes = self.git_handler.get_git_changes()- # Verify the command was executed- self.assertTrue(- any(- cmd == 'git --no-pager rev-parse --is-inside-work-tree'- for cmd, _ in self.executed_commands+ expected_changes = [+ {'status': 'A', 'path': 'committed_add.txt'},+ {'status': 'D', 'path': 'committed_delete.txt'},+ {'status': 'M', 'path': 'committed_modified.txt'},+ {'status': 'A', 'path': 'staged_add.txt'},+ {'status': 'D', 'path': 'staged_delete.txt'},+ {'status': 'M', 'path': 'staged_modified.txt'},+ {'status': 'A', 'path': 'unstaged_add.txt'},+ {'status': 'D', 'path': 'unstaged_delete.txt'},+ {'status': 'M', 'path': 'unstaged_modified.txt'},+ ]++ if changes != expected_changes:+ raise RuntimeError(+ '\n'.join(+ [+ f'incorrect_changes: {changes};',+ f'content: {os.listdir(self.local_dir)}',+ f'ref: {git_changes.get_valid_ref(self.local_dir)}',+ ]+ ))- )- def test_get_current_file_content(self):- """Test that _get_current_file_content returns the current content of a file."""- content = self.git_handler._get_current_file_content('file1.txt')- self.assertEqual(content.strip(), 'Modified content again')+ assert changes == expected_changes- # Verify the command was executed- self.assertTrue(- any(cmd == 'cat file1.txt' for cmd, _ in self.executed_commands)- )+ def test_get_git_changes_after_push(self):+ """+ Test with staged commits, and unstaged commits+ """+ self.run_command('git push -u origin feature-branch', self.local_dir)+ changes = self.git_handler.get_git_changes()- def test_get_git_changes(self):- """Test that get_git_changes returns the combined list of changed and untracked files."""- # Create an untracked file- with open(os.path.join(self.local_dir, 'untracked.txt'), 'w') as f:- f.write('Untracked file content')+ expected_changes = [+ {'status': 'A', 'path': 'staged_add.txt'},+ {'status': 'D', 'path': 'staged_delete.txt'},+ {'status': 'M', 'path': 'staged_modified.txt'},+ {'status': 'A', 'path': 'unstaged_add.txt'},+ {'status': 'D', 'path': 'unstaged_delete.txt'},+ {'status': 'M', 'path': 'unstaged_modified.txt'},+ ]- # Create a new file and stage it- with open(os.path.join(self.local_dir, 'new_file2.txt'), 'w') as f:- f.write('New file 2 content')- self._execute_command('git --no-pager add new_file2.txt', self.local_dir)+ assert changes == expected_changes- changes = self.git_handler.get_git_changes()- self.assertIsNotNone(changes)-- # Should include file1.txt (modified), file3.txt (deleted), new_file2.txt (added), and untracked.txt (untracked)- paths = [change['path'] for change in changes]- self.assertIn('file1.txt', paths)- self.assertIn('file3.txt', paths)- self.assertIn('new_file2.txt', paths)- self.assertIn('untracked.txt', paths)-- # Check that the changes include both changed and untracked files- statuses = [change['status'] for change in changes]- self.assertIn('M', statuses) # Modified- self.assertIn('A', statuses) # Added- self.assertIn('D', statuses) # Deleted-- def test_get_git_changes_multiple_repositories(self):- """Test that get_git_changes can detect changes in multiple git repositories within a workspace."""- # Create a workspace directory with multiple git repositories- workspace_dir = os.path.join(self.test_dir, 'workspace')- repo1_dir = os.path.join(workspace_dir, 'repo1')- repo2_dir = os.path.join(workspace_dir, 'repo2')- non_git_dir = os.path.join(workspace_dir, 'non_git')-- os.makedirs(workspace_dir, exist_ok=True)- os.makedirs(repo1_dir, exist_ok=True)- os.makedirs(repo2_dir, exist_ok=True)- os.makedirs(non_git_dir, exist_ok=True)-- # Set up repo1- self._execute_command('git --no-pager init', repo1_dir)- self._execute_command(- "git --no-pager config user.email '[email protected]'", repo1_dir- )- self._execute_command("git --no-pager config user.name 'Test User'", repo1_dir)- with open(os.path.join(repo1_dir, 'repo1_file.txt'), 'w') as f:- f.write('repo1 content')- self._execute_command('git --no-pager add repo1_file.txt', repo1_dir)- self._execute_command("git --no-pager commit -m 'Initial commit'", repo1_dir)- # Modify the file to create changes- with open(os.path.join(repo1_dir, 'repo1_file.txt'), 'w') as f:- f.write('repo1 modified content')-- # Set up repo2- self._execute_command('git --no-pager init', repo2_dir)- self._execute_command(- "git --no-pager config user.email '[email protected]'", repo2_dir- )- self._execute_command("git --no-pager config user.name 'Test User'", repo2_dir)- with open(os.path.join(repo2_dir, 'repo2_file.txt'), 'w') as f:- f.write('repo2 content')- self._execute_command('git --no-pager add repo2_file.txt', repo2_dir)- self._execute_command("git --no-pager commit -m 'Initial commit'", repo2_dir)- # Add an untracked file- with open(os.path.join(repo2_dir, 'untracked.txt'), 'w') as f:- f.write('untracked content')-- # Add a file to the non-git directory (should be ignored)- with open(os.path.join(non_git_dir, 'ignored_file.txt'), 'w') as f:- f.write('ignored content')-- # Create a GitHandler for the workspace directory- workspace_handler = GitHandler(self._execute_command)- workspace_handler.set_cwd(workspace_dir)-- # Clear executed commands to start fresh- self.executed_commands = []+ def test_get_git_changes_nested_repos(self):+ """+ Test with staged commits, and unstaged commits+ """+ self.setup_nested()- # Get changes from all repositories- changes = workspace_handler.get_git_changes()- self.assertIsNotNone(changes)+ changes = self.git_handler.get_git_changes()- # Should find changes from both repositories- assert len(changes) == 2- assert {'status': 'M', 'path': 'repo1/repo1_file.txt'} in changes- assert {'status': 'A', 'path': 'repo2/untracked.txt'} in changes+ expected_changes = [+ {'status': 'A', 'path': 'committed_add.txt'},+ {'status': 'D', 'path': 'committed_delete.txt'},+ {'status': 'M', 'path': 'committed_modified.txt'},+ {'status': 'A', 'path': 'nested 1/staged_add.txt'},+ {'status': 'A', 'path': 'nested_2/unstaged_add.txt'},+ {'status': 'A', 'path': 'staged_add.txt'},+ {'status': 'D', 'path': 'staged_delete.txt'},+ {'status': 'M', 'path': 'staged_modified.txt'},+ {'status': 'A', 'path': 'unstaged_add.txt'},+ {'status': 'D', 'path': 'unstaged_delete.txt'},+ {'status': 'M', 'path': 'unstaged_modified.txt'},+ ]++ assert changes == expected_changes++ def test_get_git_diff_staged_modified(self):+ """Test on a staged modified"""+ diff = self.git_handler.get_git_diff('staged_modified.txt')+ expected_diff = {+ 'original': 'staged_modified.txt\nLine 1\nLine 2\nLine 3',+ 'modified': 'staged_modified.txt\nLine 4',+ }+ assert diff == expected_diff++ def test_get_git_diff_unchanged(self):+ """Test that get_git_diff delegates to the git_diff module."""+ diff = self.git_handler.get_git_diff('unchanged.txt')+ expected_diff = {+ 'original': 'unchanged.txt\nLine 1\nLine 2\nLine 3',+ 'modified': 'unchanged.txt\nLine 1\nLine 2\nLine 3',+ }+ assert diff == expected_diff++ def test_get_git_diff_unpushed(self):+ """Test that get_git_diff delegates to the git_diff module."""+ diff = self.git_handler.get_git_diff('committed_modified.txt')+ expected_diff = {+ 'original': 'committed_modified.txt\nLine 1\nLine 2\nLine 3',+ 'modified': 'committed_modified.txt\nLine 4',+ }+ assert diff == expected_diff++ def test_get_git_diff_unstaged_add(self):+ """Test that get_git_diff delegates to the git_diff module."""+ diff = self.git_handler.get_git_diff('unstaged_add.txt')+ expected_diff = {+ 'original': '',+ 'modified': 'unstaged_add.txt\nLine 1\nLine 2\nLine 3',+ }+ assert diff == expected_diff++ def test_get_git_changes_fallback(self):+ """Test that get_git_changes falls back to creating a script file when needed."""++ # Break the git changes command+ with patch(+ 'openhands.runtime.utils.git_handler.GIT_CHANGES_CMD',+ 'non-existant-command',+ ):+ self.git_handler.git_changes_cmd = git_handler.GIT_CHANGES_CMD++ changes = self.git_handler.get_git_changes()++ expected_changes = [+ {'status': 'A', 'path': 'committed_add.txt'},+ {'status': 'D', 'path': 'committed_delete.txt'},+ {'status': 'M', 'path': 'committed_modified.txt'},+ {'status': 'A', 'path': 'staged_add.txt'},+ {'status': 'D', 'path': 'staged_delete.txt'},+ {'status': 'M', 'path': 'staged_modified.txt'},+ {'status': 'A', 'path': 'unstaged_add.txt'},+ {'status': 'D', 'path': 'unstaged_delete.txt'},+ {'status': 'M', 'path': 'unstaged_modified.txt'},+ ]++ assert changes == expected_changes++ def test_get_git_diff_fallback(self):+ """Test that get_git_diff delegates to the git_diff module."""++ # Break the git diff command+ with patch(+ 'openhands.runtime.utils.git_handler.GIT_DIFF_CMD', 'non-existant-command'+ ):+ self.git_handler.git_diff_cmd = git_handler.GIT_DIFF_CMD++ diff = self.git_handler.get_git_diff('unchanged.txt')+ expected_diff = {+ 'original': 'unchanged.txt\nLine 1\nLine 2\nLine 3',+ 'modified': 'unchanged.txt\nLine 1\nLine 2\nLine 3',+ }+ assert diff == expected_diffdiff --git a/tests/unit/test_git_handler_real.py b/tests/unit/test_git_handler_real.pydeleted file mode 100644index 7ae2058502..0000000000--- a/tests/unit/test_git_handler_real.py+++ /dev/null@@ -1,120 +0,0 @@-import os-import shutil-import subprocess-import tempfile-import unittest--from openhands.runtime.utils.git_handler import CommandResult, GitHandler---class TestGitHandlerWithRealRepo(unittest.TestCase):- def setUp(self):- # Create temporary directories for our test repositories- self.test_dir = tempfile.mkdtemp()- self.origin_dir = os.path.join(self.test_dir, 'origin')- self.local_dir = os.path.join(self.test_dir, 'local')-- # Create the directories- os.makedirs(self.origin_dir, exist_ok=True)- os.makedirs(self.local_dir, exist_ok=True)-- # Set up the git repositories- self._setup_git_repos()-- # Initialize the GitHandler with a real execute function- self.git_handler = GitHandler(self._execute_command)- self.git_handler.set_cwd(self.local_dir)-- def tearDown(self):- # Clean up the temporary directories- shutil.rmtree(self.test_dir)-- def _execute_command(self, cmd, cwd=None):- """Execute a shell command and return the result."""- try:- result = subprocess.run(- cmd, shell=True, cwd=cwd, capture_output=True, text=True, check=False- )- return CommandResult(result.stdout, result.returncode)- except Exception as e:- return CommandResult(str(e), 1)-- def _setup_git_repos(self):- """Set up real git repositories for testing."""- # Set up origin repository- self._execute_command('git init --initial-branch=main', self.origin_dir)- self._execute_command(- "git config user.email '[email protected]'", self.origin_dir- )- self._execute_command("git config user.name 'Test User'", self.origin_dir)-- # Create a file and commit it- with open(os.path.join(self.origin_dir, 'file1.txt'), 'w') as f:- f.write('Original content')-- self._execute_command('git add file1.txt', self.origin_dir)- self._execute_command("git commit -m 'Initial commit'", self.origin_dir)-- # Clone the origin repository to local- self._execute_command(f'git clone {self.origin_dir} {self.local_dir}')- self._execute_command(- "git config user.email '[email protected]'", self.local_dir- )- self._execute_command("git config user.name 'Test User'", self.local_dir)-- # Create a feature branch in the local repository- self._execute_command('git checkout -b feature-branch', self.local_dir)-- # Modify a file and create a new file- with open(os.path.join(self.local_dir, 'file1.txt'), 'w') as f:- f.write('Modified content')-- with open(os.path.join(self.local_dir, 'file2.txt'), 'w') as f:- f.write('New file content')-- # Add the new file but don't commit anything yet- self._execute_command('git add file2.txt', self.local_dir)-- def test_is_git_repo(self):- """Test that _is_git_repo returns True for a git repository."""- self.assertTrue(self.git_handler._is_git_repo())-- def test_get_ref_content(self):- """Test that _get_ref_content returns the content from a valid ref."""- # First commit the changes to make sure we have a valid ref- self._execute_command('git add file1.txt', self.local_dir)- self._execute_command("git commit -m 'Update file1.txt'", self.local_dir)-- # Get the content of file1.txt from the main branch- content = self.git_handler._get_ref_content('file1.txt')- self.assertEqual(content.strip(), 'Original content')-- def test_get_current_file_content(self):- """Test that _get_current_file_content returns the current content of a file."""- content = self.git_handler._get_current_file_content('file1.txt')- self.assertEqual(content.strip(), 'Modified content')-- def test_get_git_changes(self):- """Test that get_git_changes returns the combined list of changed and untracked files."""- # Create an untracked file- with open(os.path.join(self.local_dir, 'untracked.txt'), 'w') as f:- f.write('Untracked file content')-- changes = self.git_handler.get_git_changes()- self.assertIsNotNone(changes)-- # Should include file1.txt (modified), file2.txt (added), and untracked.txt (untracked)- paths = [change['path'] for change in changes]- self.assertIn('file1.txt', paths)- self.assertIn('file2.txt', paths)- self.assertIn('untracked.txt', paths)-- def test_get_git_diff(self):- """Test that get_git_diff returns the original and modified content of a file."""- diff = self.git_handler.get_git_diff('file1.txt')- self.assertEqual(diff['modified'].strip(), 'Modified content')- self.assertEqual(diff['original'].strip(), 'Original content')---if __name__ == '__main__':- unittest.main()