codetour-cli 0.1.0__py3-none-any.whl

codetour_cli/migration/git_diff.py

@@ -0,0 +1,418 @@
+"""
+Git diff parsing module.
+
+Parses Git diff output to extract line movement information, including hunk headers,
+file renames, and content changes.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Tuple
+import re
+
+import git
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclass
+class HunkHeader:
+    """
+    Represents a Git diff hunk header.
+
+    Format: @@ -42,5 +50,5 @@
+    Meaning: old lines 42-46 → new lines 50-54
+    """
+
+    old_start: int  # Starting line in old file (1-indexed)
+    old_count: int  # Number of lines in old file
+    new_start: int  # Starting line in new file (1-indexed)
+    new_count: int  # Number of lines in new file
+
+    @property
+    def old_end(self) -> int:
+        """Last line number in old file (inclusive)."""
+        return self.old_start + self.old_count - 1 if self.old_count > 0 else self.old_start
+
+    @property
+    def new_end(self) -> int:
+        """Last line number in new file (inclusive)."""
+        return self.new_start + self.new_count - 1 if self.new_count > 0 else self.new_start
+
+    @property
+    def line_delta(self) -> int:
+        """Net change in line count (positive = lines added, negative = lines removed)."""
+        return self.new_count - self.old_count
+
+
+@dataclass
+class FileDiff:
+    """
+    Represents changes to a single file between two commits.
+    """
+
+    old_path: Optional[str]  # None if file is new
+    new_path: Optional[str]  # None if file is deleted
+    is_renamed: bool
+    is_deleted: bool
+    is_new: bool
+    hunks: List[HunkHeader]
+    similarity_index: Optional[int] = None  # For renames (0-100)
+
+    @property
+    def path(self) -> str:
+        """Get the most relevant path (new path if exists, else old path)."""
+        return self.new_path or self.old_path or "<unknown>"
+
+
+@dataclass
+class LineMapping:
+    """
+    Represents a mapping of a line from old position to new position.
+    """
+
+    old_line: int
+    new_line: Optional[int]  # None if line was deleted
+    confidence: float  # 0.0-1.0
+    method: str  # 'git_tracked', 'hunk_offset', 'fuzzy_match', 'no_match'
+    explanation: str
+
+
+class GitDiffParser:
+    """
+    Parses Git diffs to extract line movement information.
+
+    Uses Git's built-in diff algorithms (myers, patience, histogram) to track
+    line changes between commits.
+    """
+
+    def __init__(
+        self,
+        repo: git.Repo,
+        algorithm: str = "histogram"
+    ):
+        """
+        Initialize the parser.
+
+        Args:
+            repo: GitPython repository object
+            algorithm: Diff algorithm ('myers', 'patience', 'histogram')
+        """
+        self.repo = repo
+        self.algorithm = algorithm
+        self.log = logger.bind(repo=repo.working_dir, algorithm=algorithm)
+
+    def parse_hunk_header(self, line: str) -> Optional[HunkHeader]:
+        """
+        Parse a hunk header line.
+
+        Format: @@ -42,5 +50,5 @@ optional context
+        Returns: HunkHeader(old_start=42, old_count=5, new_start=50, new_count=5)
+
+        Args:
+            line: Hunk header line from diff
+
+        Returns:
+            Parsed HunkHeader or None if line is not a valid header
+        """
+        match = re.match(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@', line)
+        if not match:
+            return None
+
+        old_start = int(match.group(1))
+        old_count = int(match.group(2)) if match.group(2) else 1
+        new_start = int(match.group(3))
+        new_count = int(match.group(4)) if match.group(4) else 1
+
+        return HunkHeader(
+            old_start=old_start,
+            old_count=old_count,
+            new_start=new_start,
+            new_count=new_count
+        )
+
+    def get_file_diff(
+        self,
+        commit_a,  # str or git.Commit
+        commit_b,  # str or git.Commit
+        file_path: str
+    ) -> Optional[FileDiff]:
+        """
+        Get diff information for a specific file between two commits.
+
+        Args:
+            commit_a: Source commit SHA or Commit object
+            commit_b: Target commit SHA or Commit object
+            file_path: Path to the file
+
+        Returns:
+            FileDiff object or None if file unchanged
+        """
+        # Convert Commit objects to strings
+        commit_a_str = commit_a.hexsha if hasattr(commit_a, 'hexsha') else commit_a
+        commit_b_str = commit_b.hexsha if hasattr(commit_b, 'hexsha') else commit_b
+
+        self.log.debug(
+            "getting_file_diff",
+            commit_a=commit_a_str[:8],
+            commit_b=commit_b_str[:8],
+            file=file_path
+        )
+
+        # Get diff with rename detection and specified algorithm
+        diff_output = self.repo.git.diff(
+            commit_a_str,
+            commit_b_str,
+            file_path,
+            M=True,  # Rename detection
+            unified=0,  # No context lines (just hunks)
+            diff_algorithm=self.algorithm
+        )
+
+        if not diff_output:
+            self.log.debug("no_changes", file=file_path)
+            return None
+
+        return self._parse_diff_output(diff_output, file_path)
+
+    def get_all_file_diffs(
+        self,
+        commit_a,  # str or git.Commit
+        commit_b,  # str or git.Commit
+    ) -> Dict[str, FileDiff]:
+        """
+        Get diff information for all files between two commits.
+
+        Args:
+            commit_a: Source commit SHA or Commit object
+            commit_b: Target commit SHA or Commit object
+
+        Returns:
+            Dictionary mapping file paths to FileDiff objects
+        """
+        # Convert Commit objects to strings
+        commit_a_str = commit_a.hexsha if hasattr(commit_a, 'hexsha') else commit_a
+        commit_b_str = commit_b.hexsha if hasattr(commit_b, 'hexsha') else commit_b
+
+        self.log.info(
+            "getting_all_diffs",
+            commit_a=commit_a_str[:8],
+            commit_b=commit_b_str[:8]
+        )
+
+        # Get diff for all files
+        diff_output = self.repo.git.diff(
+            commit_a_str,
+            commit_b_str,
+            M=True,  # Rename detection
+            unified=0,  # No context lines
+            diff_algorithm=self.algorithm,
+            name_status=False  # We want full diff, not just status
+        )
+
+        return self._parse_multi_file_diff(diff_output)
+
+    def _parse_diff_output(
+        self,
+        diff_output: str,
+        file_path: str
+    ) -> FileDiff:
+        """
+        Parse raw diff output for a single file.
+
+        Args:
+            diff_output: Raw git diff output
+            file_path: File path
+
+        Returns:
+            FileDiff object
+        """
+        lines = diff_output.split('\n')
+        hunks: List[HunkHeader] = []
+
+        old_path = file_path
+        new_path = file_path
+        is_renamed = False
+        is_deleted = False
+        is_new = False
+        similarity_index = None
+
+        for line in lines:
+            # Check for rename
+            if line.startswith('similarity index'):
+                match = re.match(r'similarity index (\d+)%', line)
+                if match:
+                    similarity_index = int(match.group(1))
+                    is_renamed = True
+
+            # Check for file deletion
+            elif line.startswith('deleted file'):
+                is_deleted = True
+                new_path = None
+
+            # Check for new file
+            elif line.startswith('new file'):
+                is_new = True
+                old_path = None
+
+            # Check for rename paths
+            elif line.startswith('rename from'):
+                old_path = line.replace('rename from ', '')
+            elif line.startswith('rename to'):
+                new_path = line.replace('rename to ', '')
+
+            # Parse hunk headers
+            elif line.startswith('@@'):
+                hunk = self.parse_hunk_header(line)
+                if hunk:
+                    hunks.append(hunk)
+
+        return FileDiff(
+            old_path=old_path,
+            new_path=new_path,
+            is_renamed=is_renamed,
+            is_deleted=is_deleted,
+            is_new=is_new,
+            hunks=hunks,
+            similarity_index=similarity_index
+        )
+
+    def _parse_multi_file_diff(self, diff_output: str) -> Dict[str, FileDiff]:
+        """
+        Parse diff output for multiple files.
+
+        Args:
+            diff_output: Raw git diff output for multiple files
+
+        Returns:
+            Dictionary mapping file paths to FileDiff objects
+        """
+        # Split by file boundaries (diff --git lines)
+        file_diffs: Dict[str, FileDiff] = {}
+        current_file_lines: List[str] = []
+        current_file_path: Optional[str] = None
+
+        for line in diff_output.split('\n'):
+            if line.startswith('diff --git'):
+                # Process previous file if exists
+                if current_file_path and current_file_lines:
+                    file_diff = self._parse_diff_output(
+                        '\n'.join(current_file_lines),
+                        current_file_path
+                    )
+                    file_diffs[file_diff.path] = file_diff
+
+                # Start new file
+                # Format: diff --git a/path/to/file b/path/to/file
+                match = re.match(r'diff --git a/(.*) b/(.*)', line)
+                if match:
+                    current_file_path = match.group(2)  # Use 'b' path (new)
+                    current_file_lines = [line]
+            else:
+                current_file_lines.append(line)
+
+        # Process last file
+        if current_file_path and current_file_lines:
+            file_diff = self._parse_diff_output(
+                '\n'.join(current_file_lines),
+                current_file_path
+            )
+            file_diffs[file_diff.path] = file_diff
+
+        self.log.info("parsed_diffs", num_files=len(file_diffs))
+        return file_diffs
+
+    def map_line_through_hunks(
+        self,
+        line_number: int,
+        hunks: List[HunkHeader]
+    ) -> LineMapping:
+        """
+        Map a line number from old file to new file using hunk headers.
+
+        This implements the "git_tracked" method of line tracking.
+
+        Args:
+            line_number: Line number in old file (1-indexed)
+            hunks: List of hunk headers from diff
+
+        Returns:
+            LineMapping with new line number and confidence
+        """
+        if not hunks:
+            # No changes, line stays the same
+            return LineMapping(
+                old_line=line_number,
+                new_line=line_number,
+                confidence=1.0,
+                method='no_changes',
+                explanation='No hunks found - file unchanged'
+            )
+
+        # Sort hunks by old_start
+        sorted_hunks = sorted(hunks, key=lambda h: h.old_start)
+
+        current_line = line_number
+        cumulative_delta = 0
+
+        for hunk in sorted_hunks:
+            if line_number < hunk.old_start:
+                # Line is before this hunk, apply accumulated delta
+                new_line = current_line + cumulative_delta
+                return LineMapping(
+                    old_line=line_number,
+                    new_line=new_line,
+                    confidence=1.0,
+                    method='hunk_offset',
+                    explanation=f'Line before hunk at {hunk.old_start}, offset by {cumulative_delta}'
+                )
+
+            elif hunk.old_start <= line_number <= hunk.old_end:
+                if hunk.new_count == 0:
+                    # Pure deletion hunk: no corresponding new lines at all.
+                    # new_start is git's own degenerate sentinel here (often 0),
+                    # not a real position -- `new_start + offset_in_hunk` would
+                    # fabricate an invalid line number (e.g. 0) rather than
+                    # honestly reporting "no destination exists" (ADR-0016
+                    # QST-CONF-1). This is a real, common shape -- e.g. two
+                    # adjacent lines swapping order, where the moved line's
+                    # OLD position becomes a pure deletion and its content
+                    # reappears in a separate hunk elsewhere in the same diff.
+                    return LineMapping(
+                        old_line=line_number,
+                        new_line=None,
+                        confidence=0.0,
+                        method='line_removed',
+                        explanation=(
+                            f'Line was part of a pure deletion (hunk '
+                            f'{hunk.old_start}-{hunk.old_end} contributes no new '
+                            f'lines) -- no corresponding new position exists'
+                        )
+                    )
+
+                # Line is within this hunk - need content matching
+                # For now, we'll mark it as uncertain
+                offset_in_hunk = line_number - hunk.old_start
+                estimated_new_line = hunk.new_start + offset_in_hunk
+
+                return LineMapping(
+                    old_line=line_number,
+                    new_line=estimated_new_line,
+                    confidence=0.5,
+                    method='hunk_interior',
+                    explanation=f'Line inside changed hunk {hunk.old_start}-{hunk.old_end}, needs content matching'
+                )
+
+            else:
+                # Line is after this hunk, accumulate delta
+                cumulative_delta += hunk.line_delta
+
+        # Line is after all hunks
+        new_line = line_number + cumulative_delta
+        return LineMapping(
+            old_line=line_number,
+            new_line=new_line,
+            confidence=1.0,
+            method='hunk_offset',
+            explanation=f'Line after all hunks, offset by {cumulative_delta}'
+        )