covisible 0.1.0__py3-none-any.whl

covisible/__init__.py

@@ -0,0 +1,3 @@
+"""Covisible — PR-first code coverage report generator."""
+
+__version__ = "0.1.0"

covisible/analysis/__init__.py

@@ -0,0 +1,17 @@
+"""Coverage analysis tools."""
+
+from covisible.analysis.blame import GitBlameAnalyzer, get_uncovered_blame_summary
+from covisible.analysis.diff import DiffAnalyzer, DiffHunk, FileDiff
+from covisible.analysis.pr_coverage import PRCoverageAnalyzer
+from covisible.analysis.treemap import TreemapBuilder, build_treemap_data
+
+__all__ = [
+    "DiffAnalyzer",
+    "DiffHunk",
+    "FileDiff",
+    "GitBlameAnalyzer",
+    "PRCoverageAnalyzer",
+    "TreemapBuilder",
+    "build_treemap_data",
+    "get_uncovered_blame_summary",
+]

covisible/analysis/blame.py

@@ -0,0 +1,232 @@
+"""Git blame integration for uncovered code analysis."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class BlameInfo:
+    """Blame information for a single line."""
+
+    line_number: int
+    commit_hash: str
+    author: str
+    author_email: str
+    timestamp: str
+    line_content: str
+
+
+@dataclass
+class AuthorStats:
+    """Statistics for a single author."""
+
+    name: str
+    email: str
+    total_uncovered_lines: int = 0
+    files: set[str] = field(default_factory=set)
+    lines: list[tuple[str, int]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "email": self.email,
+            "total_uncovered_lines": self.total_uncovered_lines,
+            "files_count": len(self.files),
+            "files": sorted(self.files),
+            "lines": self.lines[:20],
+        }
+
+
+class GitBlameAnalyzer:
+    """Analyzes git blame for uncovered lines."""
+
+    def __init__(self, repo_path: Path | str | None = None):
+        self.repo_path = Path(repo_path) if repo_path else Path.cwd()
+        self._cache: dict[Path, dict[int, BlameInfo]] = {}
+
+    def get_blame_for_file(self, file_path: Path | str) -> dict[int, BlameInfo]:
+        """Get blame information for all lines in a file.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            Dictionary mapping line numbers to BlameInfo
+        """
+        file_path = Path(file_path)
+
+        if file_path in self._cache:
+            return self._cache[file_path]
+
+        result: dict[int, BlameInfo] = {}
+
+        try:
+            cmd = [
+                "git", "blame",
+                "--line-porcelain",
+                str(file_path),
+            ]
+
+            output = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                cwd=self.repo_path,
+                check=True,
+            )
+
+            result = self._parse_porcelain_blame(output.stdout)
+
+        except subprocess.CalledProcessError:
+            pass
+
+        self._cache[file_path] = result
+        return result
+
+    def _parse_porcelain_blame(self, output: str) -> dict[int, BlameInfo]:
+        """Parse git blame --line-porcelain output."""
+        result: dict[int, BlameInfo] = {}
+        lines = output.split("\n")
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            if not line:
+                i += 1
+                continue
+
+            parts = line.split(" ")
+            if len(parts) < 3:
+                i += 1
+                continue
+
+            commit_hash = parts[0]
+            if len(commit_hash) != 40:
+                i += 1
+                continue
+
+            line_number = int(parts[2])
+
+            author = ""
+            author_email = ""
+            timestamp = ""
+            content = ""
+
+            i += 1
+            while i < len(lines) and not lines[i].startswith("\t"):
+                if lines[i].startswith("author "):
+                    author = lines[i][7:]
+                elif lines[i].startswith("author-mail "):
+                    author_email = lines[i][12:].strip("<>")
+                elif lines[i].startswith("author-time "):
+                    timestamp = lines[i][12:]
+                i += 1
+
+            if i < len(lines) and lines[i].startswith("\t"):
+                content = lines[i][1:]
+                i += 1
+
+            result[line_number] = BlameInfo(
+                line_number=line_number,
+                commit_hash=commit_hash,
+                author=author,
+                author_email=author_email,
+                timestamp=timestamp,
+                line_content=content,
+            )
+
+        return result
+
+    def get_blame_for_lines(
+        self, file_path: Path | str, line_numbers: list[int]
+    ) -> dict[int, BlameInfo]:
+        """Get blame information for specific lines.
+
+        Args:
+            file_path: Path to the file
+            line_numbers: List of line numbers to get blame for
+
+        Returns:
+            Dictionary mapping line numbers to BlameInfo
+        """
+        all_blame = self.get_blame_for_file(file_path)
+        return {ln: all_blame[ln] for ln in line_numbers if ln in all_blame}
+
+    def analyze_uncovered_lines(
+        self,
+        uncovered_by_file: dict[Path, list[int]],
+    ) -> dict[str, AuthorStats]:
+        """Analyze who wrote uncovered lines.
+
+        Args:
+            uncovered_by_file: Dictionary mapping file paths to uncovered line numbers
+
+        Returns:
+            Dictionary mapping author emails to their stats
+        """
+        author_stats: dict[str, AuthorStats] = {}
+
+        for file_path, line_numbers in uncovered_by_file.items():
+            blame_info = self.get_blame_for_lines(file_path, line_numbers)
+
+            for line_num, info in blame_info.items():
+                email = info.author_email or info.author
+
+                if email not in author_stats:
+                    author_stats[email] = AuthorStats(
+                        name=info.author,
+                        email=info.author_email,
+                    )
+
+                stats = author_stats[email]
+                stats.total_uncovered_lines += 1
+                stats.files.add(str(file_path))
+                stats.lines.append((str(file_path), line_num))
+
+        return author_stats
+
+    def get_top_authors_by_uncovered(
+        self,
+        uncovered_by_file: dict[Path, list[int]],
+        limit: int = 10,
+    ) -> list[AuthorStats]:
+        """Get top authors by number of uncovered lines.
+
+        Args:
+            uncovered_by_file: Dictionary mapping file paths to uncovered line numbers
+            limit: Maximum number of authors to return
+
+        Returns:
+            List of AuthorStats sorted by uncovered lines descending
+        """
+        stats = self.analyze_uncovered_lines(uncovered_by_file)
+        sorted_stats = sorted(
+            stats.values(),
+            key=lambda x: x.total_uncovered_lines,
+            reverse=True,
+        )
+        return sorted_stats[:limit]
+
+
+def get_uncovered_blame_summary(
+    uncovered_by_file: dict[Path, list[int]],
+    repo_path: Path | str | None = None,
+    limit: int = 10,
+) -> list[dict[str, Any]]:
+    """Get summary of who wrote uncovered code.
+
+    Args:
+        uncovered_by_file: Dictionary mapping file paths to uncovered line numbers
+        repo_path: Path to git repository
+        limit: Maximum number of authors to return
+
+    Returns:
+        List of author stats as dictionaries
+    """
+    analyzer = GitBlameAnalyzer(repo_path)
+    top_authors = analyzer.get_top_authors_by_uncovered(uncovered_by_file, limit)
+    return [author.to_dict() for author in top_authors]

covisible/analysis/diff.py

@@ -0,0 +1,229 @@
+"""Git diff parsing and analysis."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class DiffHunk:
+    """A single hunk in a diff."""
+
+    old_start: int
+    old_count: int
+    new_start: int
+    new_count: int
+    added_lines: set[int] = field(default_factory=set)
+    removed_lines: set[int] = field(default_factory=set)
+    context_lines: set[int] = field(default_factory=set)
+
+
+@dataclass
+class FileDiff:
+    """Diff information for a single file."""
+
+    old_path: Path | None
+    new_path: Path | None
+    hunks: list[DiffHunk] = field(default_factory=list)
+    is_new_file: bool = False
+    is_deleted_file: bool = False
+    is_renamed: bool = False
+
+    @property
+    def path(self) -> Path:
+        """Get the current path of the file."""
+        return self.new_path or self.old_path or Path("")
+
+    @property
+    def added_lines(self) -> set[int]:
+        """Get all added line numbers."""
+        result: set[int] = set()
+        for hunk in self.hunks:
+            result.update(hunk.added_lines)
+        return result
+
+    @property
+    def removed_lines(self) -> set[int]:
+        """Get all removed line numbers (in old file)."""
+        result: set[int] = set()
+        for hunk in self.hunks:
+            result.update(hunk.removed_lines)
+        return result
+
+    @property
+    def modified_lines(self) -> set[int]:
+        """Get all modified line numbers (added lines in new file)."""
+        return self.added_lines
+
+
+@dataclass
+class DiffAnalyzer:
+    """Analyzes git diffs to determine changed lines."""
+
+    files: dict[Path, FileDiff] = field(default_factory=dict)
+
+    @classmethod
+    def from_git_diff(
+        cls,
+        diff_range: str,
+        repo_path: Path | str | None = None,
+    ) -> DiffAnalyzer:
+        """Create DiffAnalyzer from git diff command.
+
+        Args:
+            diff_range: Git diff range (e.g., "main..HEAD", "HEAD~1..HEAD")
+            repo_path: Path to git repository (defaults to current directory)
+
+        Returns:
+            DiffAnalyzer with parsed diff information
+        """
+        cmd = ["git", "diff", "--no-color", "-U0", diff_range]
+        cwd = Path(repo_path) if repo_path else None
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            check=True,
+        )
+
+        return cls.from_unified_diff(result.stdout)
+
+    @classmethod
+    def from_diff_file(cls, path: Path | str) -> DiffAnalyzer:
+        """Create DiffAnalyzer from a diff file.
+
+        Args:
+            path: Path to unified diff file
+
+        Returns:
+            DiffAnalyzer with parsed diff information
+        """
+        with open(path) as f:
+            return cls.from_unified_diff(f.read())
+
+    @classmethod
+    def from_unified_diff(cls, diff_content: str) -> DiffAnalyzer:
+        """Parse unified diff format.
+
+        Args:
+            diff_content: Unified diff content
+
+        Returns:
+            DiffAnalyzer with parsed diff information
+        """
+        analyzer = cls()
+        current_file: FileDiff | None = None
+        current_hunk: DiffHunk | None = None
+        new_line_num = 0
+
+        file_header_re = re.compile(r"^diff --git a/(.+) b/(.+)$")
+        old_file_re = re.compile(r"^--- (?:a/)?(.+)$")
+        new_file_re = re.compile(r"^\+\+\+ (?:b/)?(.+)$")
+        hunk_re = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+        new_file_mode_re = re.compile(r"^new file mode")
+        deleted_file_mode_re = re.compile(r"^deleted file mode")
+        rename_re = re.compile(r"^rename (from|to) (.+)$")
+
+        for line in diff_content.splitlines():
+            if match := file_header_re.match(line):
+                if current_file and current_file.new_path:
+                    analyzer.files[current_file.new_path] = current_file
+                current_file = FileDiff(
+                    old_path=Path(match.group(1)),
+                    new_path=Path(match.group(2)),
+                )
+                current_hunk = None
+
+            elif new_file_mode_re.match(line):
+                if current_file:
+                    current_file.is_new_file = True
+
+            elif deleted_file_mode_re.match(line):
+                if current_file:
+                    current_file.is_deleted_file = True
+
+            elif match := rename_re.match(line):
+                if current_file:
+                    current_file.is_renamed = True
+
+            elif match := old_file_re.match(line):
+                if current_file and match.group(1) != "/dev/null":
+                    current_file.old_path = Path(match.group(1))
+
+            elif match := new_file_re.match(line):
+                if current_file and match.group(1) != "/dev/null":
+                    current_file.new_path = Path(match.group(1))
+
+            elif match := hunk_re.match(line):
+                if current_file:
+                    current_hunk = DiffHunk(
+                        old_start=int(match.group(1)),
+                        old_count=int(match.group(2) or 1),
+                        new_start=int(match.group(3)),
+                        new_count=int(match.group(4) or 1),
+                    )
+                    current_file.hunks.append(current_hunk)
+                    new_line_num = current_hunk.new_start
+
+            elif current_hunk is not None:
+                if line.startswith("+") and not line.startswith("+++"):
+                    current_hunk.added_lines.add(new_line_num)
+                    new_line_num += 1
+                elif line.startswith("-") and not line.startswith("---"):
+                    pass
+                elif line.startswith(" "):
+                    current_hunk.context_lines.add(new_line_num)
+                    new_line_num += 1
+
+        if current_file and current_file.new_path:
+            analyzer.files[current_file.new_path] = current_file
+
+        return analyzer
+
+    def get_file_diff(self, path: Path | str) -> FileDiff | None:
+        """Get diff for a specific file."""
+        if isinstance(path, str):
+            path = Path(path)
+
+        if path in self.files:
+            return self.files[path]
+
+        for file_path, diff in self.files.items():
+            if file_path.name == path.name or str(file_path).endswith(str(path)):
+                return diff
+
+        return None
+
+    def get_added_lines(self, path: Path | str) -> set[int]:
+        """Get added line numbers for a file."""
+        diff = self.get_file_diff(path)
+        return diff.added_lines if diff else set()
+
+    def get_modified_files(self) -> list[Path]:
+        """Get list of modified files."""
+        return [
+            diff.path
+            for diff in self.files.values()
+            if not diff.is_deleted_file
+        ]
+
+    def get_new_files(self) -> list[Path]:
+        """Get list of new files."""
+        return [
+            diff.path
+            for diff in self.files.values()
+            if diff.is_new_file
+        ]
+
+    def get_deleted_files(self) -> list[Path]:
+        """Get list of deleted files."""
+        return [
+            diff.old_path
+            for diff in self.files.values()
+            if diff.is_deleted_file and diff.old_path
+        ]

covisible/analysis/grouping.py

@@ -0,0 +1,218 @@
+"""File grouping by module/directory for coverage analysis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from covisible.core.models import CoverageData, FileCoverage
+
+
+@dataclass
+class ModuleGroup:
+    """A group of files representing a module or directory."""
+
+    name: str
+    path: str
+    files: list[FileCoverage] = field(default_factory=list)
+
+    @property
+    def total_lines(self) -> int:
+        return sum(f.total_lines for f in self.files)
+
+    @property
+    def covered_lines(self) -> int:
+        return sum(f.covered_lines for f in self.files)
+
+    @property
+    def uncovered_lines(self) -> int:
+        return self.total_lines - self.covered_lines
+
+    @property
+    def coverage_percent(self) -> float:
+        if self.total_lines == 0:
+            return 100.0
+        return (self.covered_lines / self.total_lines) * 100
+
+    @property
+    def total_functions(self) -> int:
+        return sum(f.total_functions for f in self.files)
+
+    @property
+    def covered_functions(self) -> int:
+        return sum(f.covered_functions for f in self.files)
+
+    @property
+    def file_count(self) -> int:
+        return len(self.files)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "path": self.path,
+            "file_count": self.file_count,
+            "total_lines": self.total_lines,
+            "covered_lines": self.covered_lines,
+            "uncovered_lines": self.uncovered_lines,
+            "coverage_percent": round(self.coverage_percent, 2),
+            "total_functions": self.total_functions,
+            "covered_functions": self.covered_functions,
+        }
+
+
+class ModuleGrouper:
+    """Groups files by module/directory."""
+
+    def __init__(
+        self,
+        coverage: CoverageData,
+        base_path: Path | str | None = None,
+        depth: int = 1,
+    ):
+        """Initialize grouper.
+
+        Args:
+            coverage: Coverage data
+            base_path: Base path to make paths relative to
+            depth: Directory depth for grouping (1 = top-level dirs)
+        """
+        self.coverage = coverage
+        self.base_path = Path(base_path) if base_path else None
+        self.depth = depth
+
+    def _find_common_prefix(self) -> Path | None:
+        """Find common path prefix for all files."""
+        paths = list(self.coverage.files.keys())
+        if not paths:
+            return None
+
+        # Get all parent directories
+        first_parts = paths[0].parts
+        common_parts: list[str] = []
+
+        for i, part in enumerate(first_parts[:-1]):  # Exclude filename
+            if all(len(p.parts) > i and p.parts[i] == part for p in paths):
+                common_parts.append(part)
+            else:
+                break
+
+        if common_parts:
+            return Path(*common_parts)
+        return None
+
+    def group_by_directory(self) -> list[ModuleGroup]:
+        """Group files by directory at specified depth.
+
+        Returns:
+            List of ModuleGroup sorted by uncovered lines descending
+        """
+        groups: dict[str, ModuleGroup] = {}
+
+        # Auto-detect base path if not provided
+        base_path = self.base_path or self._find_common_prefix()
+
+        for file_path, file_cov in self.coverage.files.items():
+            if base_path:
+                try:
+                    rel_path = file_path.relative_to(base_path)
+                except ValueError:
+                    rel_path = file_path
+            else:
+                rel_path = file_path
+
+            parts = rel_path.parts
+            if len(parts) > self.depth:
+                group_path = str(Path(*parts[: self.depth]))
+                group_name = parts[self.depth - 1]
+            else:
+                # File is in root or shallow directory
+                if len(parts) > 0:
+                    group_path = parts[0] if len(parts) > 1 else "."
+                    group_name = parts[0] if len(parts) > 1 else rel_path.name
+                else:
+                    group_path = "."
+                    group_name = "root"
+
+            if group_path not in groups:
+                groups[group_path] = ModuleGroup(name=group_name, path=group_path)
+
+            groups[group_path].files.append(file_cov)
+
+        return sorted(
+            groups.values(),
+            key=lambda g: g.uncovered_lines,
+            reverse=True,
+        )
+
+    def group_by_pattern(self, patterns: dict[str, str]) -> list[ModuleGroup]:
+        """Group files by custom patterns.
+
+        Args:
+            patterns: Dictionary mapping group names to glob patterns
+
+        Returns:
+            List of ModuleGroup
+        """
+        import fnmatch
+
+        groups: dict[str, ModuleGroup] = {}
+        unmatched = ModuleGroup(name="Other", path="other")
+
+        for name, pattern in patterns.items():
+            groups[name] = ModuleGroup(name=name, path=pattern)
+
+        for file_path, file_cov in self.coverage.files.items():
+            matched = False
+            for name, pattern in patterns.items():
+                if fnmatch.fnmatch(str(file_path), pattern):
+                    groups[name].files.append(file_cov)
+                    matched = True
+                    break
+
+            if not matched:
+                unmatched.files.append(file_cov)
+
+        result = list(groups.values())
+        if unmatched.files:
+            result.append(unmatched)
+
+        return sorted(result, key=lambda g: g.uncovered_lines, reverse=True)
+
+
+def group_coverage_by_directory(
+    coverage: CoverageData,
+    base_path: Path | str | None = None,
+    depth: int = 1,
+) -> list[dict[str, Any]]:
+    """Group coverage data by directory.
+
+    Args:
+        coverage: Coverage data
+        base_path: Base path to make paths relative to
+        depth: Directory depth for grouping
+
+    Returns:
+        List of module group dictionaries
+    """
+    grouper = ModuleGrouper(coverage, base_path, depth)
+    groups = grouper.group_by_directory()
+    return [g.to_dict() for g in groups]
+
+
+def group_coverage_by_pattern(
+    coverage: CoverageData,
+    patterns: dict[str, str],
+) -> list[dict[str, Any]]:
+    """Group coverage data by custom patterns.
+
+    Args:
+        coverage: Coverage data
+        patterns: Dictionary mapping group names to glob patterns
+
+    Returns:
+        List of module group dictionaries
+    """
+    grouper = ModuleGrouper(coverage)
+    groups = grouper.group_by_pattern(patterns)
+    return [g.to_dict() for g in groups]