blame¶

def to_dict(self) -> Dict[str, Any]:
    """Convert report to dictionary.

    Returns:
        Dict[str, Any]: Dictionary representation
    """
    return {
        "summary": {
            "files_analyzed": self.files_analyzed,
            "total_lines": self.total_lines,
            "total_authors": self.total_authors,
        },
        "top_authors": sorted(
            self.author_summary.items(),
            key=lambda x: x[1].get("total_lines", 0),
            reverse=True,
        )[:10],
        "ownership_distribution": self.ownership_distribution,
        "hot_files": self.hot_files[:10],
        "single_author_files": len(self.single_author_files),
        "abandoned_lines": sum(self.abandoned_code.values()),
        "recommendations": self.recommendations,
    }

def analyze_file(
    self,
    repo_path: Path,
    file_path: str,
    ignore_whitespace: bool = True,
    follow_renames: bool = True,
) -> FileBlame:
    """Analyze blame for a single file.

    Performs git blame analysis on a file to understand
    line-by-line authorship.

    Args:
        repo_path: Path to git repository
        file_path: Path to file relative to repo root
        ignore_whitespace: Ignore whitespace changes
        follow_renames: Follow file renames

    Returns:
        FileBlame: Blame analysis for the file

    Example:
        >>> analyzer = BlameAnalyzer(config)
        >>> blame = analyzer.analyze_file(Path("."), "src/main.py")
        >>> print(f"Primary author: {blame.primary_author}")
    """
    import subprocess

    self.logger.debug(f"Analyzing blame for {file_path}")

    # Check cache
    cache_key = f"{repo_path}/{file_path}"
    if cache_key in self._blame_cache:
        return self._blame_cache[cache_key]

    file_blame = FileBlame(file_path=file_path)

    # Build git blame command
    cmd = ["git", "blame", "--line-porcelain"]

    if ignore_whitespace:
        cmd.append("-w")

    if follow_renames:
        cmd.append("-C")

    cmd.append(file_path)

    try:
        # Run git blame
        result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True, check=True)

        # Parse blame output
        self._parse_blame_output(result.stdout, file_blame)

        # Calculate statistics
        self._calculate_file_stats(file_blame)

        # Cache result
        self._blame_cache[cache_key] = file_blame

    except subprocess.CalledProcessError as e:
        self.logger.error(f"Git blame failed for {file_path}: {e}")
    except Exception as e:
        self.logger.error(f"Error analyzing blame for {file_path}: {e}")

    return file_blame

def analyze_directory(
    self,
    repo_path: Path,
    directory: str = ".",
    file_pattern: str = "*",
    recursive: bool = True,
    max_files: int = 100,
) -> BlameReport:
    """Analyze blame for all files in a directory.

    Performs comprehensive blame analysis across multiple files
    to understand ownership patterns.

    Args:
        repo_path: Path to git repository
        directory: Directory to analyze
        file_pattern: File pattern to match
        recursive: Whether to recurse into subdirectories
        max_files: Maximum files to analyze

    Returns:
        BlameReport: Comprehensive blame analysis

    Example:
        >>> analyzer = BlameAnalyzer(config)
        >>> report = analyzer.analyze_directory(
        ...     Path("."),
        ...     directory="src",
        ...     file_pattern="*.py"
        ... )
        >>> print(f"Bus factor: {report.bus_factor}")
    """
    from pathlib import Path as PathLib

    self.logger.debug(f"Analyzing blame for directory {directory}")

    report = BlameReport()

    # Get list of files
    if recursive:
        pattern = f"**/{file_pattern}"
    else:
        pattern = file_pattern

    target_dir = PathLib(repo_path) / directory
    files = list(target_dir.glob(pattern))

    # Filter to only files (not directories)
    files = [f for f in files if f.is_file()]

    # Limit number of files
    if len(files) > max_files:
        self.logger.info(f"Limiting analysis to {max_files} files")
        files = files[:max_files]

    # Analyze each file
    for file_path in files:
        # Get relative path
        try:
            rel_path = file_path.relative_to(repo_path)
        except ValueError:
            continue

        # Skip binary files and common non-source files
        if self._should_skip_file(str(rel_path)):
            continue

        # Analyze file
        file_blame = self.analyze_file(repo_path, str(rel_path))

        if file_blame.total_lines > 0:
            report.file_blames[str(rel_path)] = file_blame
            report.files_analyzed += 1

    # Calculate report statistics
    self._calculate_report_stats(report)

    # Generate recommendations
    report.recommendations = self._generate_recommendations(report)

    self.logger.debug(
        f"Blame analysis complete: {report.files_analyzed} files, "
        f"{report.total_authors} authors"
    )

    return report

def get_line_history(
    self, repo_path: Path, file_path: str, line_number: int, max_depth: int = 10
) -> List[Dict[str, Any]]:
    """Get history of changes for a specific line.

    Traces the evolution of a specific line through git history.

    Args:
        repo_path: Path to git repository
        file_path: Path to file
        line_number: Line number to trace
        max_depth: Maximum history depth to retrieve

    Returns:
        List[Dict[str, Any]]: History of line changes

    Example:
        >>> analyzer = BlameAnalyzer(config)
        >>> history = analyzer.get_line_history(
        ...     Path("."),
        ...     "src/main.py",
        ...     42
        ... )
        >>> for change in history:
        ...     print(f"{change['date']}: {change['author']}")
    """
    import subprocess

    history = []
    current_line = line_number
    current_file = file_path

    for depth in range(max_depth):
        try:
            # Get blame for current line
            cmd = [
                "git",
                "blame",
                "-L",
                f"{current_line},{current_line}",
                "--line-porcelain",
                current_file,
            ]

            result = subprocess.run(
                cmd, cwd=repo_path, capture_output=True, text=True, check=True
            )

            # Parse blame output
            blame_data = self._parse_single_blame(result.stdout)

            if not blame_data:
                break

            history.append(blame_data)

            # Get previous version
            if blame_data["commit"] == "0000000000000000000000000000000000000000":
                break  # Uncommitted changes

            # Find line in parent commit
            parent_cmd = ["git", "show", f"{blame_data['commit']}^:{current_file}"]

            try:
                subprocess.run(
                    parent_cmd, cwd=repo_path, capture_output=True, text=True, check=True
                )
                # Continue with parent
                # This is simplified - real implementation would track line movement
            except subprocess.CalledProcessError:
                break  # File didn't exist in parent

        except subprocess.CalledProcessError:
            break
        except Exception as e:
            self.logger.error(f"Error getting line history: {e}")
            break

    return history