gitrupt 0.1.0__py3-none-any.whl

gitrupt/git.py

@@ -0,0 +1,590 @@
+"""
+Git adapter for Gitrupt.
+
+All Git operations go through this module via subprocess.
+Never uses shell=True or constructs commands from untrusted input.
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+from gitrupt.models import StagedFile, ScanTarget
+
+logger = logging.getLogger(__name__)
+
+
+class GitError(Exception):
+    """Raised when a Git command fails or Git is unavailable."""
+
+
+class GitAdapter:
+    """
+    Interface to the installed Git executable.
+
+    Uses subprocess with argument arrays — no shell interpolation.
+    """
+
+    def __init__(self, repo_root: str | None = None) -> None:
+        self._repo_root = repo_root
+
+    # -------------------------------------------------------------------------
+    # Repository detection
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def is_git_available() -> bool:
+        """Check whether Git is installed and accessible."""
+        try:
+            result = subprocess.run(
+                ["git", "--version"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    @staticmethod
+    def find_repo_root(start: str | Path | None = None) -> str | None:
+        """
+        Find the root of the Git repository containing `start`.
+        Returns None if not inside a Git repository.
+        """
+        cwd = str(start) if start else None
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=cwd,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+            return None
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return None
+
+    @staticmethod
+    def find_git_dir(repo_root: str) -> str | None:
+        """Find the .git directory for the repository."""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                git_dir = result.stdout.strip()
+                # May be relative; resolve relative to repo_root
+                path = Path(repo_root) / git_dir
+                return str(path.resolve())
+            return None
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return None
+
+    @staticmethod
+    def find_hooks_dir(repo_root: str) -> str | None:
+        """Find the Git hooks directory."""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-path", "hooks"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                hooks_path = result.stdout.strip()
+                path = Path(repo_root) / hooks_path
+                return str(path.resolve())
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
+
+        # Fallback to standard location
+        git_dir = GitAdapter.find_git_dir(repo_root)
+        if git_dir:
+            return str(Path(git_dir) / "hooks")
+        return None
+
+    # -------------------------------------------------------------------------
+    # Staged file information
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def get_staged_files(repo_root: str) -> list[StagedFile]:
+        """
+        Return a list of staged files with their status.
+
+        Uses: git diff --cached --name-status -z
+        The -z flag uses NUL separators to safely handle filenames with spaces/newlines.
+        """
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--cached", "--name-status", "-z"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=30,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            raise GitError(f"Failed to list staged files: {e}") from e
+
+        if result.returncode != 0:
+            raise GitError(f"git diff --cached failed: {result.stderr.strip()}")
+
+        return _parse_name_status(result.stdout)
+
+
+
+    @staticmethod
+    def get_staged_file_bytes(repo_root: str, file_path: str) -> bytes | None:
+        """
+        Return the raw bytes of the staged (index) version of a file.
+
+        Uses: git show :path  (binary-safe — no text decoding).
+        Returns None for missing files or on error.
+        """
+        try:
+            result = subprocess.run(
+                ["git", "show", f":{file_path}"],
+                check=False,
+                capture_output=True,
+                cwd=repo_root,
+                timeout=30,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            logger.warning("Failed to read staged bytes of %s: %s", file_path, e)
+            return None
+
+        if result.returncode != 0:
+            return None
+        return result.stdout
+    
+
+
+
+
+
+
+
+
+
+
+    @staticmethod
+    def get_staged_diff(repo_root: str) -> str:
+        """
+        Return the unified diff of all staged changes.
+
+        Uses: git diff --cached
+        """
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--cached", "--unified=3"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=60,
+                errors="replace",  # Handle non-UTF-8 content gracefully
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            raise GitError(f"Failed to get staged diff: {e}") from e
+
+        if result.returncode != 0:
+            logger.warning("git diff --cached returned %d: %s", result.returncode, result.stderr)
+            return ""
+
+        return result.stdout
+
+    @staticmethod
+    def get_staged_file_content(repo_root: str, file_path: str) -> str | None:
+        """
+        Get the staged (index) content of a specific file.
+
+        Uses: git show :path
+        """
+        try:
+            result = subprocess.run(
+                ["git", "show", f":{file_path}"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=15,
+                errors="replace",
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            logger.warning("Failed to get content of %s: %s", file_path, e)
+            return None
+
+        if result.returncode != 0:
+            return None
+
+        return result.stdout
+
+    @staticmethod
+    def is_binary_file(repo_root: str, file_path: str) -> bool:
+        """
+        Determine whether a staged file is binary.
+
+        Uses: git diff --cached --numstat
+        """
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--cached", "--numstat", "--", file_path],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=10,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+        if result.returncode != 0:
+            return False
+
+        # Binary files show "-\t-\t" in numstat output
+        output = result.stdout.strip()
+        if output and output.startswith("-\t-\t"):
+            return True
+        return False
+
+    @staticmethod
+    def get_file_size(repo_root: str, file_path: str) -> int:
+        """Get the staged size of a file in bytes."""
+        try:
+            result = subprocess.run(
+                ["git", "cat-file", "-s", f":{file_path}"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=10,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return 0
+
+        if result.returncode != 0:
+            return 0
+
+        try:
+            return int(result.stdout.strip())
+        except ValueError:
+            return 0
+
+    # -------------------------------------------------------------------------
+    # High-level helpers
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def build_scan_target(repo_root: str) -> ScanTarget:
+        """
+        Build a ScanTarget from the current staged state.
+
+        This is the primary entry point for scanners.
+        """
+        staged_files = GitAdapter.get_staged_files(repo_root)
+
+        # Enrich file metadata
+        enriched: list[StagedFile] = []
+        for sf in staged_files:
+            if sf.status == "D":
+                # Deleted files — no content to scan
+                enriched.append(sf)
+                continue
+
+            is_binary = GitAdapter.is_binary_file(repo_root, sf.path)
+            size = GitAdapter.get_file_size(repo_root, sf.path)
+            enriched.append(
+                StagedFile(
+                    path=sf.path,
+                    status=sf.status,
+                    old_path=sf.old_path,
+                    is_binary=is_binary,
+                    size_bytes=size,
+                )
+            )
+
+        staged_diff = GitAdapter.get_staged_diff(repo_root)
+
+        return ScanTarget(
+            staged_files=enriched,
+            staged_diff=staged_diff,
+            repo_root=repo_root,
+        )
+
+    @staticmethod
+    def get_git_version() -> str | None:
+        """Return the installed Git version string."""
+        try:
+            result = subprocess.run(
+                ["git", "--version"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
+        return None
+
+
+
+
+
+    # -------------------------------------------------------------------------
+    # Ref-aware content reads (used by pre-push)
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def get_file_content_at(repo_root: str, ref_prefix: str, path: str) -> str | None:
+        """
+        Read a file's text content from a specific ref.
+
+        ref_prefix is a Git ref prefix ending in ':':
+            ':'            -> the index
+            'HEAD:'        -> the HEAD commit
+            '<sha>:'       -> that commit
+        """
+        try:
+            result = subprocess.run(
+                ["git", "show", f"{ref_prefix}{path}"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=30,
+                errors="replace",
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            logger.warning("Failed to read %s%s: %s", ref_prefix, path, e)
+            return None
+
+        if result.returncode != 0:
+            return None
+        return result.stdout
+
+    @staticmethod
+    def get_file_bytes_at(repo_root: str, ref_prefix: str, path: str) -> bytes | None:
+        """Read a file's raw bytes from a specific ref (binary-safe)."""
+        try:
+            result = subprocess.run(
+                ["git", "show", f"{ref_prefix}{path}"],
+                check=False,
+                capture_output=True,
+                cwd=repo_root,
+                timeout=30,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            logger.warning("Failed to read bytes of %s%s: %s", ref_prefix, path, e)
+            return None
+
+        if result.returncode != 0:
+            return None
+        return result.stdout
+
+    # -------------------------------------------------------------------------
+    # Outgoing-range operations (used by pre-push)
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def get_diff_files(repo_root: str, base: str, head: str) -> list[StagedFile]:
+        """List files changed between two refs (uses the same parser as staged)."""
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--name-status", "-z", base, head],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=60,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            raise GitError(f"Failed to list outgoing files: {e}") from e
+
+        if result.returncode != 0:
+            raise GitError(f"git diff {base}..{head} failed: {result.stderr.strip()}")
+
+        return _parse_name_status(result.stdout)
+
+    @staticmethod
+    def get_diff_text(repo_root: str, base: str, head: str) -> str:
+        """Return the unified diff between two refs."""
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--unified=3", base, head],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=120,
+                errors="replace",
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            raise GitError(f"Failed to compute outgoing diff: {e}") from e
+
+        if result.returncode != 0:
+            logger.warning(
+                "git diff %s..%s returned %d: %s",
+                base, head, result.returncode, result.stderr,
+            )
+            return ""
+
+        return result.stdout
+
+    @staticmethod
+    def build_push_scan_target(
+        repo_root: str,
+        remote_sha: str,
+        local_sha: str,
+    ) -> ScanTarget:
+        """
+        Build a ScanTarget for a pre-push scan.
+
+        - Deletions are skipped.
+        - When remote_sha is all zeros (new branch), the base is Git's empty
+          tree so every file in the pushed tree is treated as added.
+        - File binary/size metadata is computed from the commit content.
+        """
+        EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+        ZERO = "0" * 40
+
+        base = remote_sha if remote_sha and remote_sha != ZERO else EMPTY_TREE
+        head = local_sha
+
+        files = GitAdapter.get_diff_files(repo_root, base, head)
+
+        enriched: list[StagedFile] = []
+        for sf in files:
+            if sf.status == "D":
+                enriched.append(sf)
+                continue
+
+            data = GitAdapter.get_file_bytes_at(repo_root, f"{head}:", sf.path)
+            if data is None:
+                enriched.append(sf)
+                continue
+
+            is_binary = b"\x00" in data[:8192]
+            enriched.append(
+                StagedFile(
+                    path=sf.path,
+                    status=sf.status,
+                    old_path=sf.old_path,
+                    is_binary=is_binary,
+                    size_bytes=len(data),
+                )
+            )
+
+        diff = GitAdapter.get_diff_text(repo_root, base, head)
+
+        return ScanTarget(
+            staged_files=enriched,
+            staged_diff=diff,
+            repo_root=repo_root,
+        )
+
+
+
+
+    @staticmethod
+    def get_git_binary() -> str | None:
+        """Return the absolute path to the git executable on PATH."""
+        import shutil
+        return shutil.which("git")
+
+    @staticmethod
+    def get_core_hooks_path(repo_root: str) -> str | None:
+        """
+        Return the value of core.hooksPath if set, else None.
+
+        When core.hooksPath is set, Git uses it instead of .git/hooks.
+        Gitrupt must inform the user so they know where the hook actually lives.
+        """
+        try:
+            result = subprocess.run(
+                ["git", "config", "--get", "core.hooksPath"],
+                check=False,
+                capture_output=True,
+                text=True,
+                cwd=repo_root,
+                timeout=5,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return None
+
+        if result.returncode != 0:
+            return None
+
+        value = result.stdout.strip()
+        return value or None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Parsing helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def _parse_name_status(output: str) -> list[StagedFile]:
+    """
+    Parse the output of: git diff --cached --name-status -z
+
+    Format per entry:
+        STATUS\0PATH\0          (for A, M, D, T)
+        STATUS\0OLD_PATH\0NEW_PATH\0  (for R, C with similarity score in status like R90)
+    """
+    if not output:
+        return []
+
+    files: list[StagedFile] = []
+    parts = output.split("\0")
+    i = 0
+
+    while i < len(parts):
+        part = parts[i].strip()
+        if not part:
+            i += 1
+            continue
+
+        status_code = part[0].upper()
+
+        if status_code in ("R", "C"):
+            # Rename or copy: STATUS\0old_path\0new_path
+            if i + 2 >= len(parts):
+                break
+            old_path = parts[i + 1]
+            new_path = parts[i + 2]
+            i += 3
+            if old_path and new_path:
+                files.append(
+                    StagedFile(
+                        path=new_path,
+                        status=status_code,
+                        old_path=old_path,
+                    )
+                )
+        else:
+            # Standard: STATUS\0path
+            if i + 1 >= len(parts):
+                break
+            path = parts[i + 1]
+            i += 2
+            if path:
+                files.append(StagedFile(path=path, status=status_code))
+
+    return files

gitrupt/hooks/__init__.py

@@ -0,0 +1,7 @@
+"""
+Hooks package for Gitrupt.
+"""
+
+from gitrupt.hooks.install import HookInstaller
+
+__all__ = ["HookInstaller"]