codeboarding 0.9.0__py3-none-any.whl

repo_utils/change_detector.py

@@ -0,0 +1,289 @@
+"""
+Rename-aware change detection using git.
+
+This module provides enhanced change detection that properly tracks:
+- File renames (with similarity percentage)
+- File modifications
+- Added/deleted files
+- Copy detection
+
+Uses `git diff --name-status -M -C` for accurate rename tracking.
+"""
+
+import logging
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class ChangeType(Enum):
+    """Git change status types."""
+
+    ADDED = "A"
+    COPIED = "C"
+    DELETED = "D"
+    MODIFIED = "M"
+    RENAMED = "R"
+    TYPE_CHANGED = "T"
+    UNMERGED = "U"
+    UNKNOWN = "X"
+
+
+@dataclass
+class DetectedChange:
+    """A detected file change with rename tracking."""
+
+    change_type: ChangeType
+    file_path: str  # Current/new path
+    old_path: str | None = None  # For renames/copies: the original path
+    similarity: int | None = None  # For renames/copies: 0-100%
+
+    def is_rename(self) -> bool:
+        return self.change_type == ChangeType.RENAMED
+
+    def is_content_change(self) -> bool:
+        """Returns True if file content was modified (not just metadata/rename)."""
+        return self.change_type in (ChangeType.MODIFIED, ChangeType.ADDED)
+
+    def is_structural(self) -> bool:
+        """Returns True if this affects file existence (add/delete)."""
+        return self.change_type in (ChangeType.ADDED, ChangeType.DELETED)
+
+
+@dataclass
+class ChangeSet:
+    """Collection of detected changes with helper methods."""
+
+    changes: list[DetectedChange] = field(default_factory=list)
+    base_ref: str = ""
+    target_ref: str = "HEAD"
+
+    @property
+    def renames(self) -> dict[str, str]:
+        """Get rename mapping: old_path -> new_path."""
+        return {c.old_path: c.file_path for c in self.changes if c.is_rename() and c.old_path}
+
+    @property
+    def modified_files(self) -> list[str]:
+        """Get list of modified file paths."""
+        return [c.file_path for c in self.changes if c.change_type == ChangeType.MODIFIED]
+
+    @property
+    def added_files(self) -> list[str]:
+        """Get list of added file paths."""
+        return [c.file_path for c in self.changes if c.change_type == ChangeType.ADDED]
+
+    @property
+    def deleted_files(self) -> list[str]:
+        """Get list of deleted file paths."""
+        return [c.file_path for c in self.changes if c.change_type == ChangeType.DELETED]
+
+    @property
+    def all_affected_files(self) -> set[str]:
+        """Get all files that were affected (current paths)."""
+        return {c.file_path for c in self.changes}
+
+    @property
+    def all_old_paths(self) -> set[str]:
+        """Get all old paths (for renames)."""
+        return {c.old_path for c in self.changes if c.old_path}
+
+    def is_empty(self) -> bool:
+        return len(self.changes) == 0
+
+    def has_structural_changes(self) -> bool:
+        """Returns True if any files were added or deleted."""
+        return any(c.is_structural() for c in self.changes)
+
+    def has_only_renames(self) -> bool:
+        """Returns True if all changes are pure renames."""
+        return all(c.is_rename() for c in self.changes) and len(self.changes) > 0
+
+
+def detect_changes(
+    repo_dir: Path,
+    base_ref: str,
+    target_ref: str = "HEAD",
+    exclude_patterns: list[str] | None = None,
+    fetch_missing_refs: bool = True,
+) -> ChangeSet:
+    """
+    Detect file changes between two refs using rename-aware git diff.
+
+    Args:
+        repo_dir: Path to the git repository
+        base_ref: Base reference (commit hash, tag, or branch)
+        target_ref: Target reference (default: HEAD, includes working tree)
+        exclude_patterns: List of path patterns to exclude (e.g., [".codeboarding/"])
+
+    Returns:
+        ChangeSet with all detected changes
+
+    Example:
+        changes = detect_changes(repo_path, "abc1234")
+        for rename_old, rename_new in changes.renames.items():
+            print(f"Renamed: {rename_old} -> {rename_new}")
+    """
+    changes: list[DetectedChange] = []
+
+    # Default exclusions for analysis output directories
+    if exclude_patterns is None:
+        exclude_patterns = [".codeboarding/", ".codeboarding\\"]
+
+    cmd = [
+        "git",
+        "diff",
+        "--name-status",
+        "-M",
+        "-C",
+        "--find-renames=50%",
+        base_ref,
+        target_ref,
+    ]
+
+    def _run_diff() -> subprocess.CompletedProcess:
+        return subprocess.run(
+            cmd,
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+    try:
+        result = _run_diff()
+    except subprocess.CalledProcessError as e:
+        stderr_lower = (e.stderr or "").lower()
+        if fetch_missing_refs and "bad object" in stderr_lower:
+            logger.warning("Git diff failed due to missing ref (%s); fetching refs and retrying once", e.stderr.strip())
+            try:
+                subprocess.run(
+                    ["git", "fetch", "--all", "--prune", "--tags"],
+                    cwd=repo_dir,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                result = _run_diff()
+            except subprocess.CalledProcessError as fetch_err:
+                logger.error(f"Git fetch/diff retry failed: {fetch_err.stderr}")
+                return ChangeSet(changes=changes, base_ref=base_ref, target_ref=target_ref)
+        else:
+            logger.error(f"Git diff failed: {e.stderr}")
+            return ChangeSet(changes=changes, base_ref=base_ref, target_ref=target_ref)
+    except FileNotFoundError:
+        logger.error("Git not found in PATH")
+        return ChangeSet(changes=changes, base_ref=base_ref, target_ref=target_ref)
+
+    for line in result.stdout.strip().split("\n"):
+        if not line:
+            continue
+
+        change = _parse_status_line(line)
+        if change:
+            # Skip excluded patterns
+            should_skip = False
+            for pattern in exclude_patterns:
+                if change.file_path.startswith(pattern):
+                    should_skip = True
+                    break
+                if change.old_path and change.old_path.startswith(pattern):
+                    should_skip = True
+                    break
+
+            if should_skip:
+                logger.debug(f"Skipping excluded path: {change.file_path}")
+                continue
+
+            changes.append(change)
+            logger.debug(f"Detected change: {change.change_type.name} {change.file_path}")
+
+    return ChangeSet(changes=changes, base_ref=base_ref, target_ref=target_ref)
+
+
+def detect_changes_from_commit(repo_dir: Path, base_commit: str) -> ChangeSet:
+    """
+    Detect changes from a specific commit to current working tree.
+
+    This includes both committed and uncommitted changes.
+    """
+    return detect_changes(repo_dir, base_commit, "HEAD")
+
+
+def detect_uncommitted_changes(repo_dir: Path) -> ChangeSet:
+    """
+    Detect only uncommitted changes (staged + unstaged).
+    """
+    return detect_changes(repo_dir, "HEAD", "")
+
+
+def _parse_status_line(line: str) -> DetectedChange | None:
+    """
+    Parse a git diff --name-status line.
+
+    Format examples:
+        M       file.py                     # Modified
+        A       newfile.py                  # Added
+        D       oldfile.py                  # Deleted
+        R100    old.py  new.py              # Renamed (100% similar)
+        R075    old.py  new.py              # Renamed (75% similar)
+        C100    src.py  copy.py             # Copied
+
+    Returns DetectedChange or None if parsing fails.
+    """
+    parts = line.split("\t")
+    if len(parts) < 2:
+        return None
+
+    status = parts[0]
+    status_char = status[0].upper()
+
+    try:
+        change_type = ChangeType(status_char)
+    except ValueError:
+        logger.warning(f"Unknown git status: {status_char}")
+        return None
+
+    # Handle renames and copies (have similarity percentage and two paths)
+    if change_type in (ChangeType.RENAMED, ChangeType.COPIED):
+        if len(parts) < 3:
+            return None
+
+        # Extract similarity percentage (e.g., "R100" -> 100)
+        similarity = None
+        if len(status) > 1:
+            try:
+                similarity = int(status[1:])
+            except ValueError:
+                pass
+
+        return DetectedChange(
+            change_type=change_type,
+            file_path=parts[2],  # New path
+            old_path=parts[1],  # Old path
+            similarity=similarity,
+        )
+
+    # Simple change (A, M, D, T)
+    return DetectedChange(
+        change_type=change_type,
+        file_path=parts[1],
+    )
+
+
+def get_current_commit(repo_dir: Path) -> str | None:
+    """Get the current HEAD commit hash."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return None

repo_utils/errors.py

@@ -0,0 +1,6 @@
+class NoGithubTokenFoundError(Exception):
+    pass
+
+
+class RepoDontExistError(Exception):
+    pass

repo_utils/git_diff.py

@@ -0,0 +1,74 @@
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class FileChange:
+    """
+    Container for the changes made to a single file.
+    """
+
+    filename: str
+    additions: int
+    deletions: int
+    added_lines: list[str] = field(default_factory=list)
+    removed_lines: list[str] = field(default_factory=list)
+
+    def llm_str(self):
+        """
+        Returns a string representation of the file change suitable for LLM processing.
+        """
+        return f"File: {self.filename}, Added lines: +{self.additions}, Removed lines: -{self.deletions}"
+
+
+def get_git_diff(repo_dir: Path, version: str) -> list[FileChange]:
+    """
+    Get the git diff between a specific version and the current working tree (uncommitted changes included).
+
+    :param repo_dir: Path to the repository directory.
+    :param version: The commit hash or tag to compare against.
+    :return: A list of FileChange objects describing the differences.
+    """
+    changes: list[FileChange] = []
+
+    try:
+        from git import Repo
+
+        repo = Repo(repo_dir)
+
+        # Compare the specified version to the working tree (including staged + unstaged changes)
+        diff_index = repo.git.diff(version, "--patch")
+
+        # Group diff by file using parsing logic
+        current_file = None
+        added: list[str] = []
+        removed: list[str] = []
+        for line in diff_index.splitlines():
+            if line.startswith("diff --git"):
+                # Save previous file change, if any
+                if current_file:
+                    changes.append(current_file)
+                # Start a new file
+                added, removed = [], []
+                filename = line.split(" b/")[-1]
+                current_file = FileChange(filename=filename, additions=0, deletions=0)
+            elif line.startswith("+++ ") or line.startswith("--- ") or line.startswith("@@"):
+                continue
+            elif line.startswith("+"):
+                added.append(line[1:])
+            elif line.startswith("-"):
+                removed.append(line[1:])
+            if current_file:
+                current_file.additions = len(added)
+                current_file.deletions = len(removed)
+                current_file.added_lines = added
+                current_file.removed_lines = removed
+
+        # Append the last file if it exists
+        if current_file:
+            changes.append(current_file)
+
+    except Exception as e:
+        logging.error(f"Error obtaining git diff: {e}")
+    return changes