abstra 3.23.12__py3-none-any.whl → 3.24.0__py3-none-any.whl

abstra_internals/repositories/git/dulwich.py

@@ -0,0 +1,1353 @@
+import datetime
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Tuple
+from urllib.parse import urlparse
+
+import urllib3
+
+from abstra_internals.environment import REMOTE_NAME
+from abstra_internals.logger import AbstraLogger
+
+from .types import GitCommit, GitFileChange, GitRepositoryInterface, GitStatus
+
+try:
+    from dulwich import porcelain
+    from dulwich.client import HttpGitClient
+    from dulwich.errors import NotGitRepository
+    from dulwich.index import build_index_from_tree
+    from dulwich.objects import Commit
+    from dulwich.porcelain import reset
+    from dulwich.repo import Repo
+    from dulwich.stash import Stash
+
+    DULWICH_AVAILABLE = True
+except ImportError:
+    DULWICH_AVAILABLE = False
+    if TYPE_CHECKING:
+        from dulwich import porcelain
+        from dulwich.client import HttpGitClient
+        from dulwich.errors import NotGitRepository
+        from dulwich.index import build_index_from_tree
+        from dulwich.objects import Commit
+        from dulwich.porcelain import reset
+        from dulwich.repo import Repo
+        from dulwich.stash import Stash
+
+
+class DulwichGitRepository(GitRepositoryInterface):
+    """Repository for Git operations using Dulwich library"""
+
+    def __init__(self, working_directory: Path):
+        super().__init__(working_directory)
+
+        self._repo: Optional["Repo"] = None  # type: ignore
+        self._try_load_repo()
+
+    def _try_load_repo(self):
+        """Try to load existing repository"""
+        try:
+            if self.is_git_repository():
+                self._repo = Repo(str(self.working_directory))  # type: ignore
+        except Exception:
+            self._repo = None
+
+    def configure_git_user(self, fallback_email: str, fallback_name: str):
+        """Ensure git user is configured for commits (required in CI environments)"""
+        if not self._repo:
+            return
+        try:
+            config = self._repo.get_config()
+            try:
+                config.get((b"user",), b"name")
+            except KeyError:
+                config.set((b"user",), b"name", fallback_name.encode())
+            try:
+                config.get((b"user",), b"email")
+            except KeyError:
+                config.set((b"user",), b"email", fallback_email.encode())
+            config.write_to_path()
+        except Exception:
+            pass
+
+    def is_git_available(self) -> bool:
+        """Check if dulwich is available"""
+        return DULWICH_AVAILABLE
+
+    def find_git_root(self, start_path: Optional[Path] = None) -> Optional[Path]:
+        """Find the root directory of the git repository"""
+        if start_path is None:
+            start_path = self.working_directory
+
+        if start_path is None:
+            start_path = Path.cwd()
+
+        current = start_path.resolve()
+        while current != current.parent:
+            if (current / ".git").exists():
+                return current
+            current = current.parent
+        return None
+
+    def is_git_repository(self) -> bool:
+        """Check if current directory is a git repository"""
+        if not self.is_git_available():
+            return False
+
+        try:
+            pass  # Ensure try block has at least one except clause
+            Repo(str(self.working_directory))  # type: ignore
+            return True
+        except (NotGitRepository, Exception):  # type: ignore
+            return False
+
+    def init_repository(self) -> bool:
+        """Initialize a new git repository in the working directory"""
+        if not self.is_git_available():
+            return False
+
+        try:
+            self._repo = porcelain.init(str(self.working_directory))
+
+            # Set HEAD to point to main branch instead of master BEFORE any commits
+            # This ensures the first commit goes to main branch
+            self._repo.refs.set_symbolic_ref(b"HEAD", b"refs/heads/main")
+
+            add_success = True
+            try:
+                porcelain.add(
+                    str(self.working_directory), [str(self.working_directory)]
+                )
+            except Exception:
+                add_success = False
+
+            commit_success = False
+
+            if add_success:
+                try:
+                    status = porcelain.status(str(self.working_directory))
+                    has_staged_files = (
+                        len(status.staged["add"]) > 0
+                        or len(status.staged["modify"]) > 0
+                        or len(status.staged["delete"]) > 0
+                    )
+
+                    if has_staged_files:
+                        # Commit staged files
+                        porcelain.commit(str(self.working_directory), b"First commit")
+                        commit_success = True
+                except Exception:
+                    pass
+
+            # If we haven't created a commit yet, create an empty one
+            if not commit_success:
+                try:
+                    # Create empty commit using porcelain - this should work even with no files
+                    # We need to ensure the index exists first
+                    index_path = os.path.join(
+                        str(self.working_directory), ".git", "index"
+                    )
+                    if not os.path.exists(index_path):
+                        # Touch the index file to create it
+                        Path(index_path).touch()
+
+                    porcelain.commit(str(self.working_directory), b"First commit")
+                    commit_success = True
+                except Exception:
+                    # Last resort: create commit manually
+                    try:
+                        import time
+
+                        from dulwich.objects import Commit as DulwichCommit
+                        from dulwich.objects import Tree
+
+                        # Create empty tree
+                        empty_tree = Tree()
+                        tree_id = self._repo.object_store.add_object(empty_tree)
+
+                        # Create commit object
+                        commit = DulwichCommit()
+                        commit.tree = tree_id
+                        commit.author = commit.committer = (
+                            b"Abstra <no-reply@abstra.app>"
+                        )
+                        commit.commit_time = commit.author_time = int(time.time())
+                        commit.commit_timezone = commit.author_timezone = 0
+                        commit.message = b"First commit"
+
+                        commit_id = self._repo.object_store.add_object(commit)
+                        # commit_id may be None per dulwich typing; only set if present
+                        if commit_id is not None:
+                            self._repo.refs[b"refs/heads/main"] = commit_id
+                        commit_success = True
+                    except Exception:
+                        pass
+
+            if commit_success:
+                # After commit, remove the master branch reference if it was created
+                try:
+                    if b"refs/heads/master" in self._repo.refs:
+                        del self._repo.refs[b"refs/heads/master"]
+                except Exception:
+                    pass
+
+            return True
+        except Exception:
+            return False
+
+    def get_current_branch(self) -> Optional[str]:
+        """Get the current branch name"""
+        if not self._repo:
+            return None
+
+        try:
+            # Get HEAD reference from dulwich refs (more reliable than file system)
+            head_ref = self._repo.refs[b"HEAD"]  # type: ignore
+            if head_ref.startswith(b"ref: "):
+                ref_path = head_ref[5:].decode("utf-8")
+                if ref_path.startswith("refs/heads/"):
+                    return ref_path[11:]  # Remove "refs/heads/"
+
+            # For repositories without commits, fallback to reading HEAD file directly
+            try:
+                head_file = os.path.join(self._repo.path, ".git", "HEAD")
+                with open(head_file, "r", encoding="utf-8") as f:
+                    head_content = f.read().strip()
+                    if head_content.startswith("ref: refs/heads/"):
+                        return head_content[16:]  # Remove "ref: refs/heads/"
+            except Exception:
+                pass
+
+            return None
+        except Exception:
+            return None
+
+    def get_all_branches(self) -> List[str]:
+        """Get all local branches"""
+        if not self._repo:
+            return []
+
+        if not self._repo:
+            return []
+        try:
+            branches = []
+            for ref_name, _ in self._repo.refs.as_dict().items():  # type: ignore
+                if ref_name.startswith(b"refs/heads/"):
+                    branch_name = ref_name[11:].decode("utf-8")  # Remove "refs/heads/"
+                    branches.append(branch_name)
+            return branches
+        except Exception:
+            return []
+
+    def get_last_commit(self) -> Optional[GitCommit]:
+        """Get information about the last commit"""
+        commits = self.get_commit_history(limit=1)
+        return commits[0] if commits else None
+
+    def get_commit_history(
+        self, limit: int = 10, offset: int = 0, branch: Optional[str] = None
+    ) -> List[GitCommit]:
+        """Get commit history with pagination"""
+        if not self._repo:
+            return []
+
+        try:
+            commits = []
+
+            if branch:
+                # Get commits from specific branch only
+                try:
+                    branch_ref = f"refs/heads/{branch}".encode()
+                    if branch_ref in self._repo.refs:
+                        ref_sha = self._repo.refs[branch_ref]
+                        all_refs = [ref_sha]
+                    else:
+                        # Try remote branch
+                        remote_ref = f"refs/remotes/origin/{branch}".encode()
+                        if remote_ref in self._repo.refs:
+                            ref_sha = self._repo.refs[remote_ref]
+                            all_refs = [ref_sha]
+                        else:
+                            return []
+                except Exception:
+                    return []
+            else:
+                # Get all branch refs to include commits from all branches
+                all_refs = []
+                for ref_name, ref_sha in self._repo.refs.as_dict().items():
+                    if ref_name.startswith(b"refs/heads/") or ref_name.startswith(
+                        b"refs/remotes/"
+                    ):
+                        all_refs.append(ref_sha)
+
+                # If no refs found, fallback to HEAD
+                if not all_refs:
+                    all_refs = [self._repo.head()]
+
+            walker = self._repo.get_walker(include=all_refs, max_entries=limit + offset)  # type: ignore
+
+            # Skip offset entries
+            for i, entry in enumerate(walker):
+                if i < offset:
+                    continue
+                if len(commits) >= limit:
+                    break
+
+                commit = entry.commit
+                # Convert timestamp to date string to match native format
+                date_obj = datetime.datetime.fromtimestamp(commit.commit_time)
+                # Use ISO format with time, matching native implementation
+                date_str = date_obj.strftime("%Y-%m-%d %H:%M:%S")
+
+                commits.append(
+                    GitCommit(
+                        hash=commit.id.decode("ascii"),
+                        message=commit.message.decode("utf-8", errors="ignore").strip(),
+                        author=commit.author.decode("utf-8", errors="ignore")
+                        .split("<")[0]
+                        .strip(),
+                        date=date_str,
+                    )
+                )
+
+            return commits
+        except Exception:
+            return []
+
+    def get_changed_files(self) -> List[str]:
+        """Get list of changed files"""
+        if not self._repo:
+            return []
+
+        try:
+            # Get status using dulwich - porcelain.status expects repo path
+            status = porcelain.status(str(self.working_directory))  # type: ignore
+
+            changed_files = []
+
+            # Add staged files
+            for file_path in status.staged["add"]:  # type: ignore
+                if isinstance(file_path, bytes):
+                    changed_files.append(file_path.decode("utf-8"))
+                else:
+                    changed_files.append(file_path)
+            for file_path in status.staged["delete"]:  # type: ignore
+                if isinstance(file_path, bytes):
+                    changed_files.append(file_path.decode("utf-8"))
+                else:
+                    changed_files.append(file_path)
+            for file_path in status.staged["modify"]:  # type: ignore
+                if isinstance(file_path, bytes):
+                    changed_files.append(file_path.decode("utf-8"))
+                else:
+                    changed_files.append(file_path)
+
+            # Add unstaged files
+            for file_path in status.unstaged:  # type: ignore
+                if isinstance(file_path, bytes):
+                    changed_files.append(file_path.decode("utf-8"))
+                else:
+                    changed_files.append(file_path)
+
+            # Add untracked files
+            for file_path in status.untracked:  # type: ignore
+                if isinstance(file_path, bytes):
+                    changed_files.append(file_path.decode("utf-8"))
+                else:
+                    changed_files.append(file_path)
+
+            return sorted(list(set(changed_files)))
+        except Exception:
+            return []
+
+    def get_changed_files_with_status(self) -> List[GitFileChange]:
+        """Get list of changed files with their git status"""
+        if not self._repo:
+            return []
+
+        try:
+            # Get status using dulwich - porcelain.status expects repo path
+            status = porcelain.status(str(self.working_directory))  # type: ignore
+
+            files = []
+
+            # Add staged files
+            for file_path in status.staged["add"]:  # type: ignore
+                filename = (
+                    file_path.decode("utf-8")
+                    if isinstance(file_path, bytes)
+                    else str(file_path)
+                )
+                files.append(
+                    GitFileChange(path=filename, status="added", status_code="A ")
+                )
+
+            for file_path in status.staged["delete"]:  # type: ignore
+                filename = (
+                    file_path.decode("utf-8")
+                    if isinstance(file_path, bytes)
+                    else str(file_path)
+                )
+                files.append(
+                    GitFileChange(path=filename, status="deleted", status_code="D ")
+                )
+
+            for file_path in status.staged["modify"]:  # type: ignore
+                filename = (
+                    file_path.decode("utf-8")
+                    if isinstance(file_path, bytes)
+                    else str(file_path)
+                )
+                files.append(
+                    GitFileChange(path=filename, status="modified", status_code="M ")
+                )
+
+            # Add unstaged files
+            for file_path in status.unstaged:  # type: ignore
+                filename = (
+                    file_path.decode("utf-8")
+                    if isinstance(file_path, bytes)
+                    else str(file_path)
+                )
+                files.append(
+                    GitFileChange(path=filename, status="modified", status_code=" M")
+                )
+
+            # Add untracked files
+            for file_path in status.untracked:  # type: ignore
+                filename = (
+                    file_path.decode("utf-8")
+                    if isinstance(file_path, bytes)
+                    else str(file_path)
+                )
+                files.append(
+                    GitFileChange(path=filename, status="untracked", status_code="??")
+                )
+
+            return files
+        except Exception:
+            return []
+
+    def has_uncommitted_changes(self) -> bool:
+        """Check if there are uncommitted changes"""
+        return len(self.get_changed_files()) > 0
+
+    def get_repository_status(self) -> GitStatus:
+        """Get comprehensive repository status"""
+        if not self.is_git_available():
+            return GitStatus(available=False)
+
+        git_root = self.find_git_root()
+        if (
+            git_root is not None
+            and git_root.resolve() != self.working_directory.resolve()  # type: ignore
+        ):
+            return GitStatus(available=False)
+
+        original_working_dir = None
+        if self.is_git_repository():
+            git_root = self.working_directory
+        elif self.find_git_root():
+            git_root = self.find_git_root()
+            original_working_dir = self.working_directory
+            self.working_directory = git_root
+            self._try_load_repo()
+        elif self.init_repository():
+            git_root = self.working_directory
+        else:
+            return GitStatus(available=False)
+
+        try:
+            branch = self.get_current_branch()
+            if not branch:
+                # Check if we're in detached HEAD state or new repo
+                try:
+                    head_ref = self._repo.refs[b"HEAD"]  # type: ignore
+                    if isinstance(head_ref, bytes) and len(head_ref) == 40:  # SHA hash
+                        branch = f"detached-{head_ref[:8].decode('ascii')}"
+                    else:
+                        # For new repositories without commits, default to "main"
+                        branch = "main"
+                except Exception:
+                    # For new repositories without commits, default to "main"
+                    branch = "main"
+
+            branches = self.get_all_branches()
+            last_commit = self.get_last_commit()
+            changed_files = self.get_changed_files()
+            changed_files_with_status = self.get_changed_files_with_status()
+            has_changes = len(changed_files) > 0
+
+            return GitStatus(
+                available=True,
+                branch=branch,
+                branches=branches,
+                last_commit=last_commit,
+                has_changes=has_changes,
+                changed_files=changed_files,
+                changed_files_with_status=changed_files_with_status,
+            )
+        finally:
+            if original_working_dir is not None:
+                self.working_directory = original_working_dir
+
+    def checkout_branch(self, branch_name: str) -> bool:
+        """Switch to a different branch"""
+        if not self._repo:
+            return False
+
+        try:
+            # First try to checkout existing local branch
+            local_branch_ref = f"refs/heads/{branch_name}".encode()
+            if local_branch_ref in self._repo.refs:
+                porcelain.checkout_branch(
+                    str(self.working_directory), branch_name.encode("utf-8")
+                )  # type: ignore
+                return True
+
+            # If local branch doesn't exist, try to create from remote
+            remote_branch_ref = f"refs/remotes/origin/{branch_name}".encode()
+            if remote_branch_ref in self._repo.refs:
+                # Create local branch tracking remote
+                remote_commit = self._repo.refs[remote_branch_ref]
+                self._repo.refs[local_branch_ref] = remote_commit
+                porcelain.checkout_branch(
+                    str(self.working_directory), branch_name.encode("utf-8")
+                )  # type: ignore
+                return True
+
+            return False
+        except Exception:
+            return False
+
+    def checkout_commit(self, commit_hash: str) -> bool:
+        """Switch to a specific commit (detached HEAD state)"""
+        if not self._repo:
+            return False
+
+        try:
+            # Set HEAD to point directly to the commit (detached HEAD)
+            self._repo.refs[b"HEAD"] = commit_hash.encode("utf-8")  # type: ignore
+            # Reset working directory to match the commit using dulwich's reset_hard equivalent
+            porcelain.reset(
+                str(self.working_directory), "hard", commit_hash.encode("utf-8")
+            )  # type: ignore
+            return True
+        except Exception:
+            return False
+
+    def pull_changes(
+        self,
+        strategy: str = "merge",
+        allow_unrelated: bool = True,
+        conflict_resolution: Optional[str] = "theirs",
+    ) -> bool:
+        """Pull changes from abstra remote repository"""
+        if not self._repo:
+            return False
+
+        if not self.has_remote(REMOTE_NAME):
+            return False
+
+        try:
+            try:
+                if not self._needs_auth():
+                    porcelain.pull(
+                        self._repo,
+                        REMOTE_NAME,
+                        # Add strategy flags similar to native
+                    )
+                    return True
+            except Exception:
+                pass  # Fall through to custom implementation
+
+            # Custom fetch with auth
+            remote_url = self._get_remote_url(REMOTE_NAME)
+            if not remote_url:
+                return False
+
+            client = self._create_authenticated_client(remote_url)
+            if not client:
+                return False
+
+            try:
+                # Perform fetch
+                parsed_url = urlparse(remote_url)
+                repo_path = parsed_url.path.lstrip("/") if parsed_url.path else ""
+
+                result = client.fetch(
+                    repo_path,
+                    self._repo,
+                    determine_wants=lambda refs, depth=None: list(refs.values()),
+                )
+
+                # Update remote tracking branches properly
+                self._update_remote_tracking_refs(result, REMOTE_NAME)
+
+                # Get the remote branch we want to merge
+                remote_branch_ref = f"refs/remotes/{REMOTE_NAME}/main".encode()
+                if remote_branch_ref not in self._repo.refs:
+                    AbstraLogger.warning("No remote main branch found after fetch")
+                    return False
+
+                remote_commit_sha = self._repo.refs[remote_branch_ref]
+                current_head = self._repo.head()
+
+                # Check if we're already up to date
+                if current_head == remote_commit_sha:
+                    AbstraLogger.debug("Already up to date")
+                    return True
+
+                # Perform the merge/pull based on conflict resolution
+                if conflict_resolution == "theirs":
+                    # Simply move HEAD to remote commit (equivalent to git reset --hard origin/main)
+                    self._repo.refs[b"HEAD"] = remote_commit_sha
+                    self._reset_working_tree_to_head()
+
+                    # Also update the local main branch to track remote
+                    self._repo.refs[b"refs/heads/main"] = remote_commit_sha
+
+                    AbstraLogger.info(
+                        f"Successfully pulled changes from {REMOTE_NAME} (using theirs)"
+                    )
+                    return True
+
+                elif conflict_resolution == "ours":
+                    # Keep local changes, just update remote tracking
+                    AbstraLogger.info("Kept local changes (using ours)")
+                    return True
+
+                else:
+                    # Default behavior - try fast-forward, otherwise use "theirs"
+                    if self._is_ancestor(current_head, remote_commit_sha):
+                        # Fast-forward merge
+                        self._repo.refs[b"HEAD"] = remote_commit_sha
+                        self._repo.refs[b"refs/heads/main"] = remote_commit_sha
+                        self._reset_working_tree_to_head()
+                        AbstraLogger.info(
+                            f"Successfully pulled changes from {REMOTE_NAME} (fast-forward)"
+                        )
+                        return True
+                    else:
+                        # Non-fast-forward, default to "theirs" strategy
+                        self._repo.refs[b"HEAD"] = remote_commit_sha
+                        self._repo.refs[b"refs/heads/main"] = remote_commit_sha
+                        self._reset_working_tree_to_head()
+                        AbstraLogger.info(
+                            f"Successfully pulled changes from {REMOTE_NAME}"
+                        )
+                        return True
+
+            except Exception as e:
+                AbstraLogger.error(f"Error during fetch/merge: {e}")
+                return False
+
+        except Exception as e:
+            AbstraLogger.error(f"Error during git pull: {e}")
+            return False
+
+    def _needs_auth(self) -> bool:
+        """Check if authentication is needed"""
+        try:
+            remote_url = self._get_remote_url(REMOTE_NAME)
+            if not remote_url:
+                return False
+            config_key = f"http.{remote_url}.extraHeader"
+            auth_header = self.get_git_config(config_key)
+            return bool(auth_header)
+        except Exception:
+            return False
+
+    def _get_remote_url(self, remote_name: str) -> Optional[str]:
+        """Get remote URL"""
+        try:
+            if not self._repo or not hasattr(self._repo, "get_config"):
+                return None
+            config = self._repo.get_config()
+            remote_url = config.get((b"remote", remote_name.encode("utf-8")), b"url")
+            return remote_url.decode("utf-8") if remote_url else None
+        except Exception:
+            return None
+
+    def _create_authenticated_client(self, remote_url: str):
+        """Create HTTP client with authentication"""
+        try:
+            auth_header = None
+            config_key = f"http.{remote_url}.extraHeader"
+            auth_header = self.get_git_config(config_key)
+
+            if not auth_header:
+                return None
+
+            parsed_url = urlparse(remote_url)
+            base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+            # Parse auth header
+            if ":" not in auth_header:
+                return None
+
+            header_name, header_value = auth_header.split(":", 1)
+            custom_headers = {
+                header_name.strip(): header_value.strip(),
+                "User-Agent": "dulwich/0.24.1",
+            }
+
+            # Create client with custom headers
+            pool_manager = urllib3.PoolManager(headers=custom_headers)
+            client = HttpGitClient(base_url)
+            client.pool_manager = pool_manager
+
+            return client
+        except Exception:
+            return None
+
+    def _update_remote_tracking_refs(self, fetch_result, remote_name: str):
+        """Update remote tracking references after fetch"""
+        try:
+            if not self._repo or not hasattr(self._repo, "refs"):
+                return
+            for ref_name, ref_sha in fetch_result.refs.items():
+                if ref_name.startswith(b"refs/heads/"):
+                    branch_name = ref_name[11:]
+                    remote_ref = f"refs/remotes/{remote_name}/".encode() + branch_name
+                    self._repo.refs[remote_ref] = ref_sha
+
+            for symref_name, symref_target in fetch_result.symrefs.items():
+                if symref_name == b"HEAD" and symref_target.startswith(b"refs/heads/"):
+                    branch_name = symref_target[11:]
+                    remote_head_ref = f"refs/remotes/{remote_name}/HEAD".encode()
+                    remote_branch_ref = (
+                        f"refs/remotes/{remote_name}/".encode() + branch_name
+                    )
+                    if remote_branch_ref in self._repo.refs:
+                        self._repo.refs.set_symbolic_ref(
+                            remote_head_ref, remote_branch_ref
+                        )
+        except Exception as e:
+            AbstraLogger.debug(f"Error updating remote tracking refs: {e}")
+
+    # Remove duplicate _reset_working_tree_to_head method
+
+    def _is_ancestor(self, ancestor_sha: bytes, descendant_sha: bytes) -> bool:
+        """Check if ancestor_sha is an ancestor of descendant_sha"""
+        if not self._repo:
+            return False
+
+        try:
+            # Simple check: if we can walk from descendant back to ancestor
+            walker = self._repo.get_walker(include=[descendant_sha])
+            for entry in walker:
+                if entry.commit.id == ancestor_sha:
+                    return True
+            return False
+        except Exception:
+            return False
+
+    def _reset_working_tree_to_head(self) -> bool:
+        """Reset working tree to match HEAD"""
+        if not self._repo:
+            return False
+        try:
+            # Use dulwich's porcelain reset function for a proper hard reset
+            reset(str(self.working_directory), "hard", "HEAD")
+            AbstraLogger.debug("Successfully reset working tree to HEAD")
+            return True
+        except Exception as e:
+            AbstraLogger.debug(f"Failed to reset working tree: {e}")
+            # Try alternative approach
+            try:
+                # Get current HEAD commit
+                head_sha = self._repo.head() if self._repo else None
+                if not head_sha:
+                    return False
+                commit_obj = self._repo[head_sha] if self._repo else None
+                if not commit_obj or not isinstance(commit_obj, Commit):
+                    AbstraLogger.debug("HEAD does not point to a valid commit")
+                    return False
+                # Get the tree object
+                tree = (
+                    self._repo[commit_obj.tree]
+                    if self._repo and hasattr(commit_obj, "tree")
+                    else None
+                )
+                if not tree:
+                    return False
+                # Update index to match tree
+                index_path = (
+                    os.path.join(self._repo.path, "index") if self._repo else "index"
+                )
+                if (
+                    self._repo
+                    and hasattr(self._repo, "object_store")
+                    and self._repo.object_store is not None
+                ):
+                    build_index_from_tree(
+                        self._repo.path, index_path, self._repo.object_store, tree.id
+                    )
+                else:
+                    AbstraLogger.debug(
+                        "object_store is None, cannot build index from tree"
+                    )
+                    return False
+                AbstraLogger.debug("Successfully updated index")
+                return True
+            except Exception as e2:
+                AbstraLogger.debug(f"Alternative reset also failed: {e2}")
+                return False
+
+    def commit_changes(self, message: str, add_all: bool = True) -> bool:
+        """Commit changes with a message"""
+        if not self._repo:
+            return False
+
+        try:
+            if add_all:
+                # Add all files - porcelain.add expects repo path, not Repo object
+                porcelain.add(
+                    str(self.working_directory), [str(self.working_directory)]
+                )  # type: ignore
+
+            # Commit changes - porcelain.commit expects repo path, not Repo object
+            porcelain.commit(str(self.working_directory), message.encode("utf-8"))  # type: ignore
+            return True
+        except Exception:
+            return False
+
+    def stash_changes(self, message: str = "WIP") -> bool:
+        """Stash uncommitted changes using Dulwich Stash"""
+        if not self._repo:
+            return False
+
+        try:
+            # Use Dulwich Stash class
+            stash = Stash.from_repo(self._repo)  # type: ignore
+            stash.push(message=message.encode("utf-8"))  # type: ignore
+            return True
+        except Exception:
+            return False
+
+    def get_remotes(self) -> List[str]:
+        """Get list of remote names"""
+        if not self._repo:
+            return []
+
+        if not self._repo:
+            return []
+        try:
+            config = self._repo.get_config()  # type: ignore
+            remotes = []
+            for section_name in config.sections():
+                if len(section_name) >= 2 and section_name[0] == b"remote":
+                    remote_name = section_name[1].decode("utf-8")
+                    remotes.append(remote_name)
+            return remotes
+        except Exception as e:
+            AbstraLogger.error(f"Error getting remotes: {e}")
+            return []
+
+    def has_remote(self, remote_name: str) -> bool:
+        """Check if a remote exists"""
+        remotes = self.get_remotes()
+        if not remotes:
+            return False
+        return remote_name in remotes
+
+    def add_remote(self, remote_name: str, remote_url: str) -> bool:
+        """Add a remote to the repository"""
+        if not self._repo:
+            return False
+        try:
+            config = self._repo.get_config()  # type: ignore
+            config.set(
+                (b"remote", remote_name.encode("utf-8")),
+                b"url",
+                remote_url.encode("utf-8"),
+            )
+            config.write_to_path()
+            return True
+        except Exception as e:
+            AbstraLogger.error(f"Error adding remote {remote_name}: {e}")
+            return False
+
+    def set_remote_url(self, remote_name: str, remote_url: str) -> bool:
+        """Set/update the URL for a remote"""
+        if not self._repo:
+            return False
+
+        try:
+            config = self._repo.get_config()  # type: ignore
+            config.set(
+                (b"remote", remote_name.encode("utf-8")),
+                b"url",
+                remote_url.encode("utf-8"),
+            )
+            config.write_to_path()
+            return True
+        except Exception as e:
+            AbstraLogger.error(f"Error setting remote URL for {remote_name}: {e}")
+            return False
+
+    def set_git_config(self, key: str, value: str, local: bool = True) -> bool:
+        """Set a git configuration value"""
+        if not self._repo:
+            return False
+
+        try:
+            config = self._repo.get_config()  # type: ignore
+
+            # Handle special case for http.<url>.* configs
+            if key.startswith("http.") and key.count(".") >= 2:
+                # For keys like "http.https://example.com/repo.git.extraHeader"
+                # We need to find the last dot that separates the option from the URL
+                # Split from the right to separate option from URL
+                http_prefix = "http."
+                remaining = key[len(http_prefix) :]  # Remove "http." prefix
+
+                # Find the last dot to separate option from URL
+                last_dot_index = remaining.rfind(".")
+                if last_dot_index > 0:
+                    url_part = remaining[:last_dot_index]
+                    option_part = remaining[last_dot_index + 1 :]
+
+                    config.set(
+                        (b"http", url_part.encode("utf-8")),
+                        option_part.encode("utf-8"),
+                        value.encode("utf-8"),
+                    )
+                    config.write_to_path()
+                    return True
+
+            # Handle normal config keys like "user.name", "core.editor"
+            parts = key.split(".", 1)
+            if len(parts) == 2:
+                section, option = parts
+                config.set(
+                    (section.encode("utf-8"),),
+                    option.encode("utf-8"),
+                    value.encode("utf-8"),
+                )
+                config.write_to_path()
+                return True
+            return False
+        except Exception as e:
+            AbstraLogger.error(f"Error setting git config {key}: {e}")
+            return False
+
+    def get_git_config(self, key: str, local: bool = True) -> Optional[str]:
+        """Get a git configuration value"""
+        if not self._repo:
+            return None
+
+        try:
+            config = self._repo.get_config()  # type: ignore
+
+            # Handle special case for http.<url>.* configs
+            if key.startswith("http.") and key.count(".") >= 2:
+                # For keys like "http.https://example.com/repo.git.extraHeader"
+                # We need to find the last dot that separates the option from the URL
+                # Split from the right to separate option from URL
+                http_prefix = "http."
+                remaining = key[len(http_prefix) :]  # Remove "http." prefix
+
+                # Find the last dot to separate option from URL
+                last_dot_index = remaining.rfind(".")
+                if last_dot_index > 0:
+                    url_part = remaining[:last_dot_index]
+                    option_part = remaining[last_dot_index + 1 :]
+
+                    try:
+                        value = config.get(
+                            (b"http", url_part.encode("utf-8")),
+                            option_part.encode("utf-8"),
+                        )
+                        return value.decode("utf-8") if value else None
+                    except KeyError:
+                        return None
+
+            # Handle normal config keys like "user.name", "core.editor"
+            parts = key.split(".", 1)
+            if len(parts) == 2:
+                section, option = parts
+                try:
+                    value = config.get(
+                        (section.encode("utf-8"),), option.encode("utf-8")
+                    )
+                    return value.decode("utf-8") if value else None
+                except KeyError:
+                    return None
+            return None
+        except Exception:
+            return None
+
+    def push_and_deploy(self, branch: str = "main") -> bool:
+        """Deploy to Abstra remote (push to abstra remote)"""
+        if not self._repo:
+            return False
+        if not self.has_remote(REMOTE_NAME):
+            return False
+        try:
+            branch_name = branch if branch else "main"
+            branch_ref = f"refs/heads/{branch_name}".encode()
+            if not hasattr(self._repo, "refs") or branch_ref not in self._repo.refs:
+                return False
+            porcelain.push(
+                str(self.working_directory),
+                REMOTE_NAME,
+                refspecs=[f"{branch_name}:{branch_name}"],
+            )
+            return True
+        except Exception:
+            return False
+
+    def revert_commit(self, commit_hash: str) -> bool:
+        """Reset working directory to match a previous commit and create a new commit with that content"""
+        if not self._repo:
+            return False
+        if not commit_hash or not commit_hash.strip():
+            return False
+        if self.has_uncommitted_changes():
+            return False
+        try:
+            # Verify the commit exists
+            try:
+                if not hasattr(self._repo, "__getitem__"):
+                    return False
+                self._repo[commit_hash.encode()]
+            except KeyError:
+                return False
+            # Get current HEAD
+            try:
+                current_head = (
+                    self._repo.head() if hasattr(self._repo, "head") else None
+                )
+                if not current_head:
+                    return False
+                self._repo[current_head]
+            except Exception:
+                return False
+            # Step 1: Reset working directory to target commit state
+            porcelain.reset(str(self.working_directory), "hard", commit_hash.encode())
+            # Step 2: Reset HEAD back to original position (but keep working directory)
+            if hasattr(self._repo, "refs"):
+                self._repo.refs[b"HEAD"] = current_head
+            # Step 3: Add all changes and create new commit
+            porcelain.add(str(self.working_directory), [str(self.working_directory)])
+            commit_message = f"Restore content from commit {commit_hash[:8]}"
+            porcelain.commit(
+                str(self.working_directory), commit_message.encode("utf-8")
+            )
+            return True
+        except Exception:
+            try:
+                porcelain.reset(str(self.working_directory), "hard")
+            except Exception:
+                pass
+            return False
+
+    def check_merge_conflicts(self, remote_commit: str) -> bool:
+        """Check if merging with remote commit would cause conflicts"""
+        if not self._repo:
+            return False
+
+        if not remote_commit:
+            return False
+
+        try:
+            try:
+                current_commit_id = self._repo.head()
+            except Exception:
+                return False
+
+            try:
+                if isinstance(remote_commit, str):
+                    remote_commit_bytes = remote_commit.encode()
+                else:
+                    remote_commit_bytes = remote_commit
+            except KeyError:
+                # If remote commit doesn't exist locally, this is equivalent to merge-base failing
+                # Native git returns True (conflicts) in this case
+                return True
+
+            # Try to find merge base (equivalent to git merge-base)
+            try:
+                merge_base_id = self._find_merge_base_dulwich(
+                    current_commit_id, remote_commit_bytes
+                )
+                if merge_base_id is None:
+                    return True
+            except Exception:
+                return True
+
+            # Now run merge-tree equivalent (equivalent to git merge-tree)
+            try:
+                has_conflicts = self._simulate_merge_tree_dulwich(
+                    merge_base_id, current_commit_id, remote_commit_bytes
+                )
+                return has_conflicts
+            except Exception:
+                return False
+
+        except Exception:
+            return False
+
+    def _find_merge_base_dulwich(self, commit1_id, commit2_id):
+        """Find merge base between two commits - equivalent to git merge-base"""
+        try:
+            if not self._repo:
+                return None
+            if isinstance(commit2_id, str):
+                commit2_id = commit2_id.encode()
+            from collections import deque
+
+            visited1 = set()
+            queue1 = deque([commit1_id])
+            while queue1:
+                commit_id = queue1.popleft()
+                if commit_id in visited1:
+                    continue
+                visited1.add(commit_id)
+                try:
+                    commit_obj = (
+                        self._repo[commit_id]
+                        if hasattr(self._repo, "__getitem__")
+                        else None
+                    )
+                    if (
+                        commit_obj
+                        and isinstance(commit_obj, Commit)
+                        and hasattr(commit_obj, "parents")
+                    ):
+                        queue1.extend(commit_obj.parents)
+                except Exception as e:
+                    print(f"Error accessing commit {commit_id}: {e}")
+                    continue
+            visited2 = set()
+            queue2 = deque([commit2_id])
+            while queue2:
+                commit_id = queue2.popleft()
+                if commit_id in visited2:
+                    continue
+                visited2.add(commit_id)
+                if commit_id in visited1:
+                    return commit_id
+                try:
+                    commit_obj = (
+                        self._repo[commit_id]
+                        if hasattr(self._repo, "__getitem__")
+                        else None
+                    )
+                    if (
+                        commit_obj
+                        and isinstance(commit_obj, Commit)
+                        and hasattr(commit_obj, "parents")
+                    ):
+                        queue2.extend(commit_obj.parents)
+                except Exception as e:
+                    print(f"Error accessing commit {commit_id}: {e}")
+                    continue
+            return None
+        except Exception as e:
+            print(f"Error in _find_merge_base_dulwich: {e}")
+            return None
+
+    def _simulate_merge_tree_dulwich(self, merge_base_id, current_id, remote_id):
+        """Simulate git merge-tree to detect conflicts"""
+        try:
+            if not self._repo:
+                return False
+            if isinstance(remote_id, str):
+                remote_id = remote_id.encode()
+            base_commit = (
+                self._repo[merge_base_id]
+                if hasattr(self._repo, "__getitem__")
+                else None
+            )
+            current_commit = (
+                self._repo[current_id] if hasattr(self._repo, "__getitem__") else None
+            )
+            remote_commit = (
+                self._repo[remote_id] if hasattr(self._repo, "__getitem__") else None
+            )
+            if not base_commit or not current_commit or not remote_commit:
+                return False
+            base_tree = (
+                self._repo[base_commit.tree]
+                if base_commit
+                and isinstance(base_commit, Commit)
+                and hasattr(base_commit, "tree")
+                and hasattr(self._repo, "__getitem__")
+                else None
+            )
+            current_tree = (
+                self._repo[current_commit.tree]
+                if current_commit
+                and isinstance(current_commit, Commit)
+                and hasattr(current_commit, "tree")
+                and hasattr(self._repo, "__getitem__")
+                else None
+            )
+            remote_tree = (
+                self._repo[remote_commit.tree]
+                if remote_commit
+                and isinstance(remote_commit, Commit)
+                and hasattr(remote_commit, "tree")
+                and hasattr(self._repo, "__getitem__")
+                else None
+            )
+            if not base_tree or not current_tree or not remote_tree:
+                return False
+            if base_tree.id == current_tree.id == remote_tree.id:
+                return False
+            if current_tree.id == base_tree.id:
+                return False
+            if remote_tree.id == base_tree.id:
+                return False
+            if current_tree.id == remote_tree.id:
+                return False
+            return self._analyze_tree_conflicts(base_tree, current_tree, remote_tree)
+        except Exception as e:
+            print(f"Error in _simulate_merge_tree_dulwich: {e}")
+            return False
+
+    def _analyze_tree_conflicts(self, base_tree, current_tree, remote_tree):
+        """Analyze trees for conflicts like git merge-tree does"""
+        try:
+            # Get all file entries from all three trees
+            base_entries = self._get_tree_entries(base_tree)
+            current_entries = self._get_tree_entries(current_tree)
+            remote_entries = self._get_tree_entries(remote_tree)
+
+            # Get all unique file paths
+            all_paths = (
+                set(base_entries.keys())
+                | set(current_entries.keys())
+                | set(remote_entries.keys())
+            )
+
+            for path in all_paths:
+                base_entry = base_entries.get(path)
+                current_entry = current_entries.get(path)
+                remote_entry = remote_entries.get(path)
+                # Only check for conflicts if all entries are not None and are tuples
+                if (
+                    (base_entry is not None and isinstance(base_entry, tuple))
+                    or (current_entry is not None and isinstance(current_entry, tuple))
+                    or (remote_entry is not None and isinstance(remote_entry, tuple))
+                ):
+                    try:
+                        if self._has_file_conflict(
+                            base_entry, current_entry, remote_entry
+                        ):
+                            return True
+                    except TypeError:
+                        continue
+
+            return False
+
+        except Exception as e:
+            print(f"Error in _analyze_tree_conflicts: {e}")
+            return True  # Conservative: assume conflicts on error
+
+    def _get_tree_entries(self, tree):
+        """Get all file entries from a tree recursively"""
+        entries = {}
+
+        def walk_tree(tree_obj, prefix=""):
+            try:
+                if not tree_obj or not hasattr(tree_obj, "items"):
+                    return
+                for name, mode, sha in tree_obj.items():
+                    path = prefix + name.decode("utf-8", errors="replace")
+                    if mode & 0o040000:  # Directory
+                        try:
+                            subtree = (
+                                self._repo[sha]
+                                if self._repo and hasattr(self._repo, "__getitem__")
+                                else None
+                            )
+                            if subtree is not None:
+                                walk_tree(subtree, path + "/")
+                        except Exception as e:
+                            print(f"DEBUG: Error accessing subtree {sha}: {e}")
+                    else:  # File
+                        entries[path] = (mode, sha)
+            except Exception as e:
+                print(f"DEBUG: Error accessing tree {tree_obj}: {e}")
+
+        walk_tree(tree)
+        return entries
+
+    def _has_file_conflict(self, base_entry, current_entry, remote_entry):
+        """Check if a file has conflicts between the three versions"""
+        # If all three are identical or missing, no conflict
+        if base_entry == current_entry == remote_entry:
+            return False
+
+        # If file doesn't exist in base
+        if base_entry is None:
+            if current_entry is None or remote_entry is None:
+                return False  # One side didn't add the file
+            # Both sides added - conflict if different content
+            return current_entry[1] != remote_entry[1]  # Compare SHA
+
+        # File exists in base
+        if current_entry is None and remote_entry is None:
+            return False  # Both sides deleted - no conflict
+
+        if current_entry is None:
+            return False  # Only remote changed - no conflict
+
+        if remote_entry is None:
+            return False  # Only current changed - no conflict
+
+        # All three versions exist - check for conflicts
+        current_changed = current_entry[1] != base_entry[1]
+        remote_changed = remote_entry[1] != base_entry[1]
+
+        if not current_changed or not remote_changed:
+            return False  # At most one side changed
+
+        # Both sides changed - conflict if they changed differently
+        return current_entry[1] != remote_entry[1]
+
+    def get_ahead_behind_count(
+        self, local_commit: str, remote_commit: str
+    ) -> Tuple[int, int]:
+        """Calculate ahead/behind count between local and remote commits"""
+        if not self._repo:
+            return (0, 0)
+
+        try:
+            # Verify both commits exist
+            try:
+                self._repo[local_commit.encode()]
+                self._repo[remote_commit.encode()]
+            except KeyError:
+                # If remote commit doesn't exist locally, we're behind
+                # This matches the native implementation behavior
+                return (1, 1)  # Indicates divergence requiring merge/rebase
+
+            # Count commits that local has but remote doesn't (ahead)
+            try:
+                # Get commits reachable from local but not from remote
+                ahead_walker = self._repo.get_walker(
+                    include=[local_commit.encode()], exclude=[remote_commit.encode()]
+                )
+                ahead_count = len(list(ahead_walker))
+            except Exception:
+                ahead_count = 0
+
+            # Count commits that remote has but local doesn't (behind)
+            try:
+                # Get commits reachable from remote but not from local
+                behind_walker = self._repo.get_walker(
+                    include=[remote_commit.encode()], exclude=[local_commit.encode()]
+                )
+                behind_count = len(list(behind_walker))
+            except Exception:
+                behind_count = 0
+
+            return (ahead_count, behind_count)
+
+        except Exception:
+            return (0, 0)