diffrag 0.2.3__py3-none-any.whl

diffrag/diff/__init__.py

@@ -0,0 +1,11 @@
+"""Git diff extraction and data models."""
+
+from .git import GitRepository
+from .models import DiffResult, FileDiff, Hunk
+
+__all__ = [
+    "DiffResult",
+    "FileDiff",
+    "GitRepository",
+    "Hunk",
+]

diffrag/diff/git.py

@@ -0,0 +1,227 @@
+"""GitRepository: thin wrapper around git subprocess calls."""
+
+import logging
+import re
+import subprocess
+from pathlib import Path
+
+from ..exceptions import GitError
+from .models import DiffResult, FileDiff, Hunk
+
+log = logging.getLogger(__name__)
+
+_HUNK_HEADER_RE = re.compile(
+    r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@",
+    re.MULTILINE,
+)
+
+_STATUS_MAP = {
+    "M": "modified",
+    "A": "added",
+    "D": "deleted",
+    "R": "renamed",
+    "C": "copied",
+}
+
+
+class GitRepository:
+    """Provides access to git operations for a local repository.
+
+    Args:
+        path: Absolute or relative path to the root of the git repository.
+
+    Raises:
+        GitError: If ``path`` is not inside a git repository.
+    """
+
+    def __init__(self, path: Path) -> None:
+        self._path = path.resolve()
+        self._validate()
+
+    @property
+    def path(self) -> Path:
+        """Absolute path to the repository root.
+
+        Returns:
+            Resolved ``Path`` object pointing to the repository root.
+        """
+        return self._path
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def head_commit(self) -> str:
+        """Return the SHA of the current HEAD commit.
+
+        Returns:
+            Full 40-character SHA string.
+
+        Raises:
+            GitError: If the git command fails (e.g. no commits yet).
+        """
+        return self._run("rev-parse", "HEAD").strip()
+
+    def list_branches(self) -> list[str]:
+        """Return all local branch names.
+
+        Returns:
+            Sorted list of local branch names.
+
+        Raises:
+            GitError: If the git command fails.
+        """
+        output = self._run("branch", "--format=%(refname:short)")
+        return sorted(line.strip() for line in output.splitlines() if line.strip())
+
+    def get_diff(self, base: str, head: str = "HEAD") -> DiffResult:
+        """Extract the diff between *base* and *head*.
+
+        Uses the three-dot ``base...head`` notation so only commits reachable
+        from *head* but not from *base* are included (merge-base diff).
+
+        Args:
+            base: Base ref (branch, tag, or commit SHA).
+            head: Head ref to compare against. Defaults to ``"HEAD"``.
+
+        Returns:
+            A :class:`DiffResult` containing per-file diffs.
+
+        Raises:
+            GitError: If any git command fails or a ref does not exist.
+        """
+        log.info("Computing diff %s...%s in %s", base, head, self._path)
+
+        name_status = self._run("diff", "--name-status", f"{base}...{head}")
+        if not name_status.strip():
+            log.info("No changes found between %s and %s", base, head)
+            return DiffResult(base_ref=base, head_ref=head, file_diffs=())
+
+        file_entries = self._parse_name_status(name_status)
+        file_diffs: list[FileDiff] = []
+
+        for status, new_path, old_path in file_entries:
+            raw = self._run("--no-pager", "diff", "--unified=3", f"{base}...{head}", "--", new_path)
+            hunks = self._parse_hunks(raw)
+            file_diffs.append(
+                FileDiff(
+                    path=new_path,
+                    old_path=old_path,
+                    status=_STATUS_MAP.get(status, status.lower()),
+                    hunks=tuple(hunks),
+                    raw_diff=raw,
+                )
+            )
+            log.debug("Parsed %d hunks for %s (%s)", len(hunks), new_path, status)
+
+        return DiffResult(base_ref=base, head_ref=head, file_diffs=tuple(file_diffs))
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _validate(self) -> None:
+        try:
+            self._run("rev-parse", "--git-dir")
+        except GitError as exc:
+            raise GitError(f"{self._path} is not a git repository") from exc
+
+    def _run(self, *args: str) -> str:
+        """Run a git command and return stdout.
+
+        Args:
+            *args: Arguments passed to ``git`` after the executable name.
+
+        Returns:
+            Decoded stdout string.
+
+        Raises:
+            GitError: If git exits with a non-zero status.
+        """
+        cmd = ["git", *args]
+        log.debug("Running: %s", " ".join(cmd))
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=self._path,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return result.stdout
+        except subprocess.CalledProcessError as exc:
+            raise GitError(f"git command failed: {' '.join(cmd)}\n{exc.stderr.strip()}") from exc
+
+    @staticmethod
+    def _parse_name_status(output: str) -> list[tuple[str, str, str | None]]:
+        """Parse ``git diff --name-status`` output.
+
+        Args:
+            output: Raw output from ``git diff --name-status``.
+
+        Returns:
+            List of ``(status_char, new_path, old_path_or_None)`` tuples.
+        """
+        entries: list[tuple[str, str, str | None]] = []
+        for line in output.strip().splitlines():
+            parts = line.split("\t")
+            status_code = parts[0][0]
+            if status_code in ("R", "C") and len(parts) == 3:
+                entries.append((status_code, parts[2], parts[1]))
+            elif len(parts) >= 2:
+                entries.append((status_code, parts[1], None))
+        return entries
+
+    @staticmethod
+    def _parse_hunks(diff_text: str) -> list[Hunk]:
+        """Parse hunk blocks out of a unified diff string.
+
+        Args:
+            diff_text: Raw unified diff for a single file.
+
+        Returns:
+            List of :class:`Hunk` objects in order of appearance.
+        """
+        hunks: list[Hunk] = []
+        lines = diff_text.splitlines(keepends=True)
+
+        current_header: str | None = None
+        current_lines: list[str] = []
+        old_start = old_count = new_start = new_count = 0
+
+        for line in lines:
+            m = _HUNK_HEADER_RE.match(line)
+            if m:
+                if current_header is not None:
+                    hunks.append(
+                        Hunk(
+                            header=current_header,
+                            content="".join(current_lines),
+                            old_start=old_start,
+                            old_count=old_count,
+                            new_start=new_start,
+                            new_count=new_count,
+                        )
+                    )
+                current_header = line.rstrip("\n")
+                current_lines = []
+                old_start = int(m.group(1))
+                old_count = int(m.group(2)) if m.group(2) is not None else 1
+                new_start = int(m.group(3))
+                new_count = int(m.group(4)) if m.group(4) is not None else 1
+            elif current_header is not None:
+                current_lines.append(line)
+
+        if current_header is not None:
+            hunks.append(
+                Hunk(
+                    header=current_header,
+                    content="".join(current_lines),
+                    old_start=old_start,
+                    old_count=old_count,
+                    new_start=new_start,
+                    new_count=new_count,
+                )
+            )
+
+        return hunks

diffrag/diff/models.py

@@ -0,0 +1,76 @@
+"""Immutable data models representing a parsed git diff."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Hunk:
+    """A single contiguous change block within a file diff.
+
+    Attributes:
+        header: The ``@@ ... @@`` line that introduces the hunk.
+        content: All diff lines belonging to this hunk (context, additions, deletions).
+        old_start: First line number in the old file.
+        old_count: Number of lines from the old file covered by this hunk.
+        new_start: First line number in the new file.
+        new_count: Number of lines in the new file covered by this hunk.
+    """
+
+    header: str
+    content: str
+    old_start: int
+    old_count: int
+    new_start: int
+    new_count: int
+
+
+@dataclass(frozen=True)
+class FileDiff:
+    """Diff for a single file in a changeset.
+
+    Attributes:
+        path: Current (new) path of the file, relative to the repository root.
+        old_path: Previous path before a rename/copy; ``None`` otherwise.
+        status: One of ``"modified"``, ``"added"``, ``"deleted"``, ``"renamed"``, ``"copied"``.
+        hunks: Ordered list of parsed hunks.
+        raw_diff: Full raw diff text for this file as returned by git.
+    """
+
+    path: str
+    old_path: str | None
+    status: str
+    hunks: tuple[Hunk, ...]
+    raw_diff: str
+
+
+@dataclass(frozen=True)
+class DiffResult:
+    """The complete diff between two git refs.
+
+    Attributes:
+        base_ref: The base git ref (branch, tag, or commit).
+        head_ref: The head git ref being compared.
+        file_diffs: Tuple of per-file diffs in the changeset.
+    """
+
+    base_ref: str
+    head_ref: str
+    file_diffs: tuple[FileDiff, ...]
+
+    @property
+    def changed_files(self) -> list[str]:
+        """Return a list of changed file paths.
+
+        Returns:
+            List of file paths (current path for renames).
+        """
+        return [f.path for f in self.file_diffs]
+
+    @property
+    def is_empty(self) -> bool:
+        """Return ``True`` if there are no changed files.
+
+        Returns:
+            ``True`` when the diff contains no file changes.
+        """
+        return len(self.file_diffs) == 0

diffrag/exceptions.py

@@ -0,0 +1,21 @@
+"""Package-level exception hierarchy."""
+
+
+class AICodeReviewerError(Exception):
+    """Base exception for diffrag."""
+
+
+class GitError(AICodeReviewerError):
+    """Raised when a git operation fails."""
+
+
+class AIClientError(AICodeReviewerError):
+    """Raised when an AI API request fails."""
+
+
+class IndexingError(AICodeReviewerError):
+    """Raised when building or querying the vector index fails."""
+
+
+class ConfigurationError(AICodeReviewerError):
+    """Raised for invalid or missing configuration."""

diffrag/indexing/__init__.py

@@ -0,0 +1,5 @@
+"""Vector index construction and retrieval."""
+
+from .indexer import RepoIndexer
+
+__all__ = ["RepoIndexer"]