579 lines
19 KiB
Python
579 lines
19 KiB
Python
"""Async git command wrappers using subprocess."""
|
|
|
|
import asyncio
|
|
import logging
|
|
import os
|
|
from pathlib import Path
|
|
|
|
from .repository import GitStatus, CommitResult, PushResult
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def unquote_git_path(path: str) -> str:
|
|
"""Strip git's porcelain quoting from paths with spaces/special chars."""
|
|
if path.startswith('"') and path.endswith('"'):
|
|
return path[1:-1]
|
|
return path
|
|
|
|
|
|
class GitError(Exception):
|
|
"""Base exception for git operations."""
|
|
|
|
def __init__(self, message: str, stderr: str = "", returncode: int = 1):
|
|
super().__init__(message)
|
|
self.stderr = stderr
|
|
self.returncode = returncode
|
|
|
|
|
|
class MergeConflictError(GitError):
|
|
"""Raised when there's a merge conflict."""
|
|
|
|
pass
|
|
|
|
|
|
class PushRejectedError(GitError):
|
|
"""Raised when push is rejected by remote."""
|
|
|
|
pass
|
|
|
|
|
|
async def _run_git_command(
|
|
*args: str,
|
|
cwd: Path,
|
|
check: bool = True,
|
|
stdin: bytes | None = None,
|
|
env: dict[str, str] | None = None,
|
|
) -> tuple[str, str, int]:
|
|
"""Run a git command asynchronously.
|
|
|
|
Uses asyncio subprocess with argument list (safe, no shell injection).
|
|
This is equivalent to Node.js execFile - arguments are passed directly
|
|
to the process without shell interpretation.
|
|
|
|
Args:
|
|
*args: Git command arguments
|
|
cwd: Working directory for the command
|
|
check: Raise GitError on non-zero exit code
|
|
stdin: Optional stdin data to send to the process
|
|
env: Optional env overrides merged onto os.environ
|
|
"""
|
|
merged_env = {**os.environ, **(env or {})}
|
|
# asyncio.create_subprocess_exec is safe - no shell, args passed directly
|
|
create_process = asyncio.create_subprocess_exec
|
|
proc = await create_process(
|
|
"git",
|
|
*args,
|
|
cwd=str(cwd),
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE,
|
|
stdin=asyncio.subprocess.PIPE if stdin is not None else None,
|
|
env=merged_env,
|
|
)
|
|
stdout, stderr = await proc.communicate(input=stdin)
|
|
stdout_str = stdout.decode().strip()
|
|
stderr_str = stderr.decode().strip()
|
|
returncode = proc.returncode or 0
|
|
|
|
if check and returncode != 0:
|
|
raise GitError(
|
|
f"git {' '.join(args)} failed: {stderr_str}",
|
|
stderr=stderr_str,
|
|
returncode=returncode,
|
|
)
|
|
|
|
return stdout_str, stderr_str, returncode
|
|
|
|
|
|
async def git_status(repo_path: Path) -> GitStatus:
|
|
"""Get the git status of a repository."""
|
|
# Get porcelain status for parsing
|
|
stdout, _, _ = await _run_git_command("status", "--porcelain", "-b", cwd=repo_path)
|
|
|
|
lines = stdout.split("\n") if stdout else []
|
|
|
|
staged = []
|
|
modified = []
|
|
untracked = []
|
|
deleted = []
|
|
branch = "main"
|
|
ahead = 0
|
|
behind = 0
|
|
|
|
for line in lines:
|
|
if not line:
|
|
continue
|
|
|
|
if line.startswith("##"):
|
|
# Parse branch info: ## main...origin/main [ahead 1, behind 2]
|
|
branch_info = line[3:]
|
|
if "..." in branch_info:
|
|
branch = branch_info.split("...")[0]
|
|
else:
|
|
branch = branch_info.split()[0] if branch_info else "main"
|
|
|
|
if "[ahead " in line:
|
|
try:
|
|
ahead_part = line.split("[ahead ")[1].split("]")[0].split(",")[0]
|
|
ahead = int(ahead_part)
|
|
except (IndexError, ValueError):
|
|
pass
|
|
if "behind " in line:
|
|
try:
|
|
behind_part = line.split("behind ")[1].split("]")[0]
|
|
behind = int(behind_part)
|
|
except (IndexError, ValueError):
|
|
pass
|
|
continue
|
|
|
|
# Parse file status
|
|
if len(line) >= 3:
|
|
index_status = line[0]
|
|
worktree_status = line[1]
|
|
filepath = unquote_git_path(line[3:])
|
|
|
|
if index_status == "?" and worktree_status == "?":
|
|
untracked.append(filepath)
|
|
elif index_status == "D" or worktree_status == "D":
|
|
deleted.append(filepath)
|
|
elif index_status in "MARC":
|
|
staged.append(filepath)
|
|
elif worktree_status == "M":
|
|
modified.append(filepath)
|
|
|
|
has_changes = bool(staged or modified or untracked or deleted)
|
|
|
|
return GitStatus(
|
|
has_changes=has_changes,
|
|
staged=staged,
|
|
modified=modified,
|
|
untracked=untracked,
|
|
deleted=deleted,
|
|
branch=branch,
|
|
ahead=ahead,
|
|
behind=behind,
|
|
)
|
|
|
|
|
|
async def git_diff(repo_path: Path, staged: bool = False) -> str:
|
|
"""Get the diff of changes.
|
|
|
|
Args:
|
|
repo_path: Path to the repository
|
|
staged: If True, show only staged changes (--cached)
|
|
"""
|
|
args = ["diff"]
|
|
if staged:
|
|
args.append("--cached")
|
|
else:
|
|
args.append("HEAD")
|
|
|
|
stdout, _, _ = await _run_git_command(*args, cwd=repo_path, check=False)
|
|
return stdout
|
|
|
|
|
|
async def git_add_all(repo_path: Path) -> None:
|
|
"""Stage all changes including untracked files."""
|
|
await _run_git_command("add", "-A", cwd=repo_path)
|
|
|
|
|
|
async def git_check_ignored(repo_path: Path, files: list[str]) -> list[str]:
|
|
"""Check which files git will refuse to stage due to .gitignore.
|
|
|
|
Uses `git add --dry-run` to detect files that will fail to stage,
|
|
including tracked files now covered by .gitignore patterns.
|
|
|
|
Args:
|
|
repo_path: Path to the repository
|
|
files: List of file paths to check
|
|
|
|
Returns:
|
|
List of files that are safe to stage (not ignored)
|
|
"""
|
|
if not files:
|
|
return []
|
|
|
|
try:
|
|
# CRITICAL: The only reliable way to detect stageable files is to try staging them
|
|
# with --dry-run. Neither check-ignore nor ls-files -i work for tracked-but-ignored files.
|
|
# Batch to avoid ARG_MAX
|
|
BATCH_SIZE = 1000
|
|
safe_files = []
|
|
ignored_files = []
|
|
|
|
batches = [files[i : i + BATCH_SIZE] for i in range(0, len(files), BATCH_SIZE)]
|
|
|
|
for batch in batches:
|
|
# Try dry-run add - exit code 0 = success, 128 = some files ignored
|
|
stdout, stderr, returncode = await _run_git_command(
|
|
"add", "--dry-run", "--",
|
|
*batch,
|
|
cwd=repo_path,
|
|
check=False,
|
|
)
|
|
|
|
if returncode == 0:
|
|
# All files in batch are safe
|
|
safe_files.extend(batch)
|
|
elif (returncode == 1 or returncode == 128) and "ignored" in stderr.lower():
|
|
# Some files are ignored - parse error message to find which ones
|
|
# Git error format: "The following paths are ignored by one of your .gitignore files:\npath1\npath2"
|
|
# Exit code 1 = some files ignored, 128 = all files ignored
|
|
batch_ignored = []
|
|
lines = stderr.split("\n")
|
|
for i, line in enumerate(lines):
|
|
if "following paths are ignored" in line.lower():
|
|
# Next lines until "hint:" are the ignored paths
|
|
for ignored_line in lines[i + 1:]:
|
|
if ignored_line.startswith("hint:") or not ignored_line.strip():
|
|
break
|
|
ignored_path = ignored_line.strip()
|
|
if ignored_path:
|
|
batch_ignored.append(ignored_path)
|
|
ignored_files.append(ignored_path)
|
|
|
|
# Files not in ignored list are safe
|
|
safe_files.extend([f for f in batch if f not in batch_ignored and not any(f.startswith(ig + "/") for ig in batch_ignored)])
|
|
else:
|
|
# Unknown error - be conservative and include all files
|
|
logger.warning(f"git add --dry-run returned {returncode}: {stderr}, including all files from batch")
|
|
safe_files.extend(batch)
|
|
|
|
if ignored_files:
|
|
logger.info(f"Filtered {len(ignored_files)} gitignored files (detected via dry-run)")
|
|
|
|
return safe_files
|
|
|
|
except GitError as e:
|
|
# If check fails, return all files (safer than blocking commits)
|
|
logger.warning(f"git ignore check failed in {repo_path}: {e}, proceeding without filter")
|
|
return files
|
|
|
|
|
|
async def git_add_specific(repo_path: Path, files: list[str]) -> None:
|
|
"""Stage specific files only, filtering out gitignored files.
|
|
|
|
Args:
|
|
repo_path: Path to the repository
|
|
files: List of file paths to stage
|
|
"""
|
|
if not files:
|
|
return
|
|
|
|
# Filter out gitignored files before staging
|
|
stageable_files = await git_check_ignored(repo_path, files)
|
|
|
|
if not stageable_files:
|
|
logger.warning(f"All {len(files)} files are gitignored, nothing to stage")
|
|
return
|
|
|
|
if len(stageable_files) < len(files):
|
|
ignored_count = len(files) - len(stageable_files)
|
|
logger.debug(f"Filtered out {ignored_count} gitignored files, staging {len(stageable_files)}")
|
|
|
|
# Batch git add if too many files to avoid ARG_MAX limit
|
|
# Most systems have ARG_MAX ~2MB, conservatively batch at 1000 files
|
|
BATCH_SIZE = 1000
|
|
if len(stageable_files) > BATCH_SIZE:
|
|
logger.info(f"Batching git add for {len(stageable_files)} files ({BATCH_SIZE} per batch)")
|
|
for i in range(0, len(stageable_files), BATCH_SIZE):
|
|
batch = stageable_files[i : i + BATCH_SIZE]
|
|
logger.debug(f"Adding batch {i // BATCH_SIZE + 1}/{(len(stageable_files) + BATCH_SIZE - 1) // BATCH_SIZE}")
|
|
await _run_git_command("add", "--", *batch, cwd=repo_path)
|
|
else:
|
|
# Add files in a single command for efficiency
|
|
await _run_git_command("add", "--", *stageable_files, cwd=repo_path)
|
|
|
|
|
|
async def git_commit(repo_path: Path, message: str) -> CommitResult:
|
|
"""Create a commit with the given message."""
|
|
try:
|
|
stdout, stderr, returncode = await _run_git_command(
|
|
"commit", "-m", message, cwd=repo_path, check=False
|
|
)
|
|
|
|
if returncode != 0:
|
|
# Check for "nothing to commit"
|
|
if "nothing to commit" in stdout or "nothing to commit" in stderr:
|
|
return CommitResult(
|
|
success=False,
|
|
error="Nothing to commit",
|
|
)
|
|
return CommitResult(
|
|
success=False,
|
|
error=stderr or stdout,
|
|
)
|
|
|
|
# Get commit hash
|
|
hash_stdout, _, _ = await _run_git_command(
|
|
"rev-parse", "--short", "HEAD", cwd=repo_path
|
|
)
|
|
|
|
return CommitResult(
|
|
success=True,
|
|
commit_hash=hash_stdout,
|
|
message=message,
|
|
)
|
|
|
|
except GitError as e:
|
|
return CommitResult(
|
|
success=False,
|
|
error=str(e),
|
|
)
|
|
|
|
|
|
async def git_push(
|
|
repo_path: Path,
|
|
remote: str = "origin",
|
|
branch: str = "main",
|
|
) -> PushResult:
|
|
"""Push commits to remote.
|
|
|
|
Uses --no-verify to bypass pre-push hooks (e.g. adversarial-view generators
|
|
that require GPU services). Uses -u to set upstream tracking so that
|
|
subsequent `git status -b` reports ahead/behind correctly.
|
|
"""
|
|
try:
|
|
_, stderr, returncode = await _run_git_command(
|
|
"push", "--no-verify", "-u", remote, branch, cwd=repo_path, check=False
|
|
)
|
|
|
|
if returncode != 0:
|
|
rejected = "rejected" in stderr.lower() or "non-fast-forward" in stderr.lower()
|
|
if rejected:
|
|
raise PushRejectedError(
|
|
f"Push rejected: {stderr}",
|
|
stderr=stderr,
|
|
returncode=returncode,
|
|
)
|
|
return PushResult(
|
|
success=False,
|
|
remote=remote,
|
|
branch=branch,
|
|
error=stderr,
|
|
rejected=rejected,
|
|
)
|
|
|
|
return PushResult(
|
|
success=True,
|
|
remote=remote,
|
|
branch=branch,
|
|
)
|
|
|
|
except PushRejectedError:
|
|
raise
|
|
except GitError as e:
|
|
return PushResult(
|
|
success=False,
|
|
remote=remote,
|
|
branch=branch,
|
|
error=str(e),
|
|
)
|
|
|
|
|
|
async def _abort_rebase_verified(repo_path: Path) -> bool:
|
|
"""Run rebase --abort and verify the rebase state is cleared.
|
|
|
|
Escalates to --quit + reset --hard ORIG_HEAD if abort doesn't clear state.
|
|
Returns True if repo is clean after recovery, False if unrecoverable.
|
|
"""
|
|
rebase_merge = repo_path / ".git" / "rebase-merge"
|
|
rebase_apply = repo_path / ".git" / "rebase-apply"
|
|
|
|
await _run_git_command("rebase", "--abort", cwd=repo_path, check=False)
|
|
if not rebase_merge.exists() and not rebase_apply.exists():
|
|
return True
|
|
|
|
logger.warning(f"rebase --abort didn't clear state in {repo_path}, escalating to --quit")
|
|
await _run_git_command("rebase", "--quit", cwd=repo_path, check=False)
|
|
if not rebase_merge.exists() and not rebase_apply.exists():
|
|
return True
|
|
|
|
logger.error(f"rebase --quit also failed in {repo_path}, resetting to ORIG_HEAD")
|
|
await _run_git_command("reset", "--hard", "ORIG_HEAD", cwd=repo_path, check=False)
|
|
return not rebase_merge.exists() and not rebase_apply.exists()
|
|
|
|
|
|
async def pre_cycle_recover(repo_path: Path) -> dict:
|
|
"""Detect and recover from orphan rebase/merge state left by a prior cycle.
|
|
|
|
Returns dict: {was_stuck: bool, recovered: bool, state: str}
|
|
"""
|
|
rebase_merge = repo_path / ".git" / "rebase-merge"
|
|
rebase_apply = repo_path / ".git" / "rebase-apply"
|
|
merge_head = repo_path / ".git" / "MERGE_HEAD"
|
|
|
|
if rebase_merge.exists() or rebase_apply.exists():
|
|
logger.warning(f"Orphan rebase detected in {repo_path}, attempting recovery")
|
|
recovered = await _abort_rebase_verified(repo_path)
|
|
return {"was_stuck": True, "recovered": recovered, "state": "rebase"}
|
|
|
|
if merge_head.exists():
|
|
logger.warning(f"Orphan merge detected in {repo_path}, aborting")
|
|
await _run_git_command("merge", "--abort", cwd=repo_path, check=False)
|
|
return {"was_stuck": True, "recovered": not merge_head.exists(), "state": "merge"}
|
|
|
|
return {"was_stuck": False, "recovered": False, "state": "clean"}
|
|
|
|
|
|
async def git_pull_rebase(
|
|
repo_path: Path,
|
|
remote: str = "origin",
|
|
branch: str = "main",
|
|
) -> bool:
|
|
"""Pull with rebase to resolve diverged history.
|
|
|
|
Returns True if successful, raises MergeConflictError on conflicts.
|
|
"""
|
|
try:
|
|
_, stderr, returncode = await _run_git_command(
|
|
"pull", "--rebase", remote, branch, cwd=repo_path, check=False
|
|
)
|
|
|
|
if returncode != 0:
|
|
if "conflict" in stderr.lower() or "CONFLICT" in stderr:
|
|
from .conflict_resolution import try_auto_resolve_lockfiles
|
|
|
|
resolution = await try_auto_resolve_lockfiles(repo_path)
|
|
if resolution["resolved"]:
|
|
_, cont_stderr, cont_rc = await _run_git_command(
|
|
"rebase", "--continue",
|
|
cwd=repo_path, check=False,
|
|
env={"GIT_EDITOR": "true"},
|
|
)
|
|
if cont_rc == 0:
|
|
logger.info(
|
|
f"Auto-resolved lockfile conflicts in {repo_path}: "
|
|
f"{resolution['files_resolved']}"
|
|
)
|
|
return True
|
|
logger.warning(
|
|
f"rebase --continue failed after auto-resolution: {cont_stderr}"
|
|
)
|
|
|
|
if not await _abort_rebase_verified(repo_path):
|
|
raise GitError(
|
|
f"Rebase conflict and abort failed — repo stuck in {repo_path}",
|
|
stderr=stderr,
|
|
returncode=returncode,
|
|
)
|
|
raise MergeConflictError(
|
|
f"Merge conflict during rebase: {stderr}",
|
|
stderr=stderr,
|
|
returncode=returncode,
|
|
)
|
|
raise GitError(
|
|
f"Pull rebase failed: {stderr}",
|
|
stderr=stderr,
|
|
returncode=returncode,
|
|
)
|
|
|
|
return True
|
|
|
|
except (MergeConflictError, GitError):
|
|
raise
|
|
except Exception as e:
|
|
raise GitError(f"Unexpected error during pull rebase: {e}")
|
|
|
|
|
|
async def git_fetch(
|
|
repo_path: Path,
|
|
remote: str = "origin",
|
|
) -> bool:
|
|
"""Fetch from remote to update refs without touching the working tree.
|
|
|
|
Returns True on success, False on failure (non-fatal).
|
|
"""
|
|
try:
|
|
_, stderr, returncode = await _run_git_command(
|
|
"fetch", remote, cwd=repo_path, check=False
|
|
)
|
|
if returncode != 0:
|
|
logger.warning(f"git fetch failed in {repo_path}: {stderr}")
|
|
return False
|
|
return True
|
|
except Exception as e:
|
|
logger.warning(f"git fetch error in {repo_path}: {e}")
|
|
return False
|
|
|
|
|
|
async def pre_cycle_sync(
|
|
repo_path: Path,
|
|
remote: str = "origin",
|
|
branch: str = "main",
|
|
) -> dict:
|
|
"""Sync repo with remote before a commit cycle.
|
|
|
|
Sequence: recover orphan state -> fetch -> check if behind -> skip if dirty -> pull --rebase.
|
|
Never stashes — dirty trees are left alone and committed normally.
|
|
All failures are non-fatal (logged and returned in result dict).
|
|
|
|
Returns dict with keys: fetched, pulled, behind_count, skipped_dirty, recovered, error
|
|
"""
|
|
result = {
|
|
"fetched": False,
|
|
"pulled": False,
|
|
"behind_count": 0,
|
|
"skipped_dirty": False,
|
|
"recovered": False,
|
|
"error": None,
|
|
}
|
|
|
|
recovery = await pre_cycle_recover(repo_path)
|
|
if recovery["was_stuck"]:
|
|
result["recovered"] = recovery["recovered"]
|
|
if not recovery["recovered"]:
|
|
result["error"] = f"orphan_{recovery['state']}_unrecovered"
|
|
return result
|
|
|
|
# Step 1: Fetch
|
|
if not await git_fetch(repo_path, remote):
|
|
result["error"] = "fetch_failed"
|
|
return result
|
|
result["fetched"] = True
|
|
|
|
# Step 2: Check if behind (re-read status after fetch updates refs)
|
|
try:
|
|
status = await git_status(repo_path)
|
|
except Exception as e:
|
|
result["error"] = f"status_failed: {e}"
|
|
return result
|
|
|
|
result["behind_count"] = status.behind
|
|
if status.behind == 0:
|
|
return result # Nothing to pull
|
|
|
|
# Step 3: Skip pull if working tree is dirty — multiple agents may be
|
|
# working concurrently, so stashing is unsafe. The dirty changes will
|
|
# get committed this cycle, pushed, and the next cycle will pull clean.
|
|
if status.has_changes:
|
|
result["skipped_dirty"] = True
|
|
logger.debug(
|
|
f"Skipping pull for {repo_path}: dirty working tree "
|
|
f"({status.behind} commits behind, will sync after commit)"
|
|
)
|
|
return result
|
|
|
|
# Step 4: Pull --rebase (clean tree only)
|
|
try:
|
|
await git_pull_rebase(repo_path, remote, branch)
|
|
result["pulled"] = True
|
|
except MergeConflictError as e:
|
|
logger.warning(f"Conflict during pre-cycle pull in {repo_path}: {e}")
|
|
result["error"] = "merge_conflict"
|
|
except GitError as e:
|
|
logger.warning(f"Pull failed in {repo_path}: {e}")
|
|
result["error"] = f"pull_failed: {e}"
|
|
|
|
return result
|
|
|
|
|
|
async def git_log_recent(
|
|
repo_path: Path,
|
|
count: int = 5,
|
|
) -> list[str]:
|
|
"""Get recent commit messages for style reference."""
|
|
stdout, _, _ = await _run_git_command(
|
|
"log", f"-{count}", "--format=%s", cwd=repo_path, check=False
|
|
)
|
|
return [line for line in stdout.split("\n") if line]
|