crackerjack 0.18.2__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/version_analyzer.py

@@ -0,0 +1,461 @@
+"""Intelligent version bump analysis based on code changes and commit patterns."""
+
+import re
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+from .changelog_automation import ChangelogEntry, ChangelogGenerator
+from .git import GitService
+
+
+class VersionBumpType(Enum):
+    """Semantic versioning bump types."""
+
+    MAJOR = "major"  # Breaking changes (x.y.z -> x+1.0.0)
+    MINOR = "minor"  # New features (x.y.z -> x.y+1.0)
+    PATCH = "patch"  # Bug fixes (x.y.z -> x.y.z+1)
+
+
+@dataclass
+class VersionBumpRecommendation:
+    """Recommendation for version bump with reasoning."""
+
+    bump_type: VersionBumpType
+    confidence: float  # 0.0 to 1.0
+    reasoning: list[str]
+    current_version: str
+    recommended_version: str
+    breaking_changes: list[str]
+    new_features: list[str]
+    bug_fixes: list[str]
+    commit_analysis: dict[str, Any]
+
+
+class BreakingChangeAnalyzer:
+    """Analyzes commits for breaking changes that require MAJOR version bump."""
+
+    def __init__(self) -> None:
+        # Patterns that indicate breaking changes
+        self.breaking_patterns = [
+            re.compile(
+                r"BREAKING\s*CHANGE[:\s]", re.IGNORECASE
+            ),  # REGEX OK: breaking change detection
+            re.compile(
+                r"^[^:\n]*!:", re.MULTILINE
+            ),  # REGEX OK: conventional commit breaking marker
+            re.compile(
+                r"\bremove\s+\w+\s+(api|function|method|class)", re.IGNORECASE
+            ),  # REGEX OK: API removal detection
+            re.compile(
+                r"\bdelete\s+\w+\s+(api|endpoint|interface)", re.IGNORECASE
+            ),  # REGEX OK: API deletion detection
+            re.compile(
+                r"\bchange\s+\w+\s+(signature|interface|api)", re.IGNORECASE
+            ),  # REGEX OK: API signature change
+        ]
+
+    def analyze(self, entries: list[ChangelogEntry]) -> tuple[bool, list[str], float]:
+        """
+        Analyze changelog entries for breaking changes.
+
+        Returns:
+            (has_breaking_changes, breaking_change_descriptions, confidence)
+        """
+        breaking_changes: list[str] = []
+
+        for entry in entries:
+            # Check if entry is already marked as breaking
+            if entry.breaking_change:
+                breaking_changes.append(entry.description)
+                continue
+
+            # Check description against breaking change patterns
+            for pattern in self.breaking_patterns:
+                if pattern.search(entry.description):
+                    breaking_changes.append(entry.description)
+                    break
+
+        has_breaking = len(breaking_changes) > 0
+        confidence = 0.9 if has_breaking else 0.0
+
+        return has_breaking, breaking_changes, confidence
+
+
+class FeatureAnalyzer:
+    """Analyzes commits for new features that require MINOR version bump."""
+
+    def __init__(self) -> None:
+        # Patterns that indicate new features
+        self.feature_patterns = [
+            re.compile(
+                r"^feat[(\[]", re.IGNORECASE
+            ),  # REGEX OK: conventional commit feat
+            re.compile(
+                r"\badd\s+(new\s+)?\w+", re.IGNORECASE
+            ),  # REGEX OK: addition detection
+            re.compile(
+                r"\bimplement\s+\w+", re.IGNORECASE
+            ),  # REGEX OK: implementation detection
+            re.compile(
+                r"\bintroduce\s+\w+", re.IGNORECASE
+            ),  # REGEX OK: introduction detection
+            re.compile(
+                r"\bcreate\s+(new\s+)?\w+", re.IGNORECASE
+            ),  # REGEX OK: creation detection
+        ]
+
+    def analyze(self, entries: list[ChangelogEntry]) -> tuple[bool, list[str], float]:
+        """
+        Analyze changelog entries for new features.
+
+        Returns:
+            (has_new_features, feature_descriptions, confidence)
+        """
+        new_features: list[str] = []
+
+        for entry in entries:
+            # Check entry type
+            if entry.type in ("Added", "feat"):
+                new_features.append(entry.description)
+                continue
+
+            # Check description against feature patterns
+            for pattern in self.feature_patterns:
+                if pattern.search(entry.description):
+                    new_features.append(entry.description)
+                    break
+
+        has_features = len(new_features) > 0
+        confidence = 0.8 if has_features else 0.0
+
+        return has_features, new_features, confidence
+
+
+class ConventionalCommitAnalyzer:
+    """Analyzes conventional commit messages for semantic versioning hints."""
+
+    def __init__(self) -> None:
+        # Commit type mappings to version bump types
+        self.commit_type_mappings = {
+            # MAJOR bump triggers
+            "breaking": VersionBumpType.MAJOR,
+            # MINOR bump triggers
+            "feat": VersionBumpType.MINOR,
+            "feature": VersionBumpType.MINOR,
+            # PATCH bump triggers
+            "fix": VersionBumpType.PATCH,
+            "bugfix": VersionBumpType.PATCH,
+            "patch": VersionBumpType.PATCH,
+            "hotfix": VersionBumpType.PATCH,
+            # No version bump (could be argued either way)
+            "docs": None,
+            "style": None,
+            "refactor": None,
+            "test": None,
+            "chore": None,
+            "build": None,
+            "ci": None,
+        }
+
+    def analyze(self, entries: list[ChangelogEntry]) -> dict[str, Any]:
+        """
+        Analyze conventional commit patterns in changelog entries.
+
+        Returns:
+            Analysis results including type counts and recommendations
+        """
+        type_counts: dict[str, int] = {}
+        recommended_bumps: list[VersionBumpType] = []
+
+        for entry in entries:
+            # Parse entry type and increment count
+            entry_type = entry.type.lower()
+            type_counts[entry_type] = type_counts.get(entry_type, 0) + 1
+
+            # Determine recommended bump type
+            if entry.breaking_change:
+                recommended_bumps.append(VersionBumpType.MAJOR)
+            elif entry_type in self.commit_type_mappings:
+                bump_type = self.commit_type_mappings[entry_type]
+                if bump_type:
+                    recommended_bumps.append(bump_type)
+
+        return {
+            "type_counts": type_counts,
+            "recommended_bumps": recommended_bumps,
+            "total_entries": len(entries),
+        }
+
+
+class VersionAnalyzer:
+    """Main service for analyzing changes and recommending version bumps."""
+
+    @depends.inject
+    def __init__(self, console: Inject[Console], git_service: GitService) -> None:
+        self.console = console
+        self.git = git_service
+
+        # Initialize specialized analyzers
+        self.breaking_analyzer = BreakingChangeAnalyzer()
+        self.feature_analyzer = FeatureAnalyzer()
+        self.commit_analyzer = ConventionalCommitAnalyzer()
+
+        # Initialize changelog generator for getting entries (ACB DI injects dependencies)
+        self.changelog_generator = ChangelogGenerator()
+
+    def _get_current_version(self) -> str | None:
+        """Get current version from pyproject.toml."""
+        pyproject_path = Path("pyproject.toml")
+        if not pyproject_path.exists():
+            return None
+
+        try:
+            from tomllib import loads
+
+            content = pyproject_path.read_text(encoding="utf-8")
+            data = loads(content)
+            version: str | None = data.get("project", {}).get("version")
+            return version
+        except Exception:
+            return None
+
+    def _calculate_next_version(self, current: str, bump_type: VersionBumpType) -> str:
+        """Calculate next version based on current version and bump type."""
+        try:
+            parts = current.split(".")
+            if len(parts) != 3:
+                msg = f"Invalid version format: {current}"
+                raise ValueError(msg)
+
+            major, minor, patch = map(int, parts)
+
+            if bump_type == VersionBumpType.MAJOR:
+                return f"{major + 1}.0.0"
+            elif bump_type == VersionBumpType.MINOR:
+                return f"{major}.{minor + 1}.0"
+            elif bump_type == VersionBumpType.PATCH:
+                return f"{major}.{minor}.{patch + 1}"
+            else:
+                # All enum cases are covered above
+                from typing import assert_never
+
+                assert_never(bump_type)
+
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Error calculating version: {e}")
+            raise
+
+    async def recommend_version_bump(
+        self, since_version: str | None = None
+    ) -> VersionBumpRecommendation:
+        """
+        Analyze changes since last version and recommend version bump.
+
+        Args:
+            since_version: Version/tag to analyze changes since (default: latest tag)
+
+        Returns:
+            VersionBumpRecommendation with analysis and recommendation
+        """
+        current_version = self._get_current_version()
+        if not current_version:
+            msg = "Could not determine current version from pyproject.toml"
+            raise ValueError(msg)
+
+        all_entries = self._collect_changelog_entries(since_version)
+
+        if not all_entries:
+            return self._create_no_changes_recommendation(current_version)
+
+        return self._analyze_entries_and_recommend(current_version, all_entries)
+
+    def _collect_changelog_entries(
+        self, since_version: str | None
+    ) -> list[ChangelogEntry]:
+        """Collect and flatten changelog entries for analysis."""
+        entries_by_type = self.changelog_generator.generate_changelog_entries(
+            since_version
+        )
+        all_entries: list[ChangelogEntry] = []
+        for entries in entries_by_type.values():
+            all_entries.extend(entries)
+        return all_entries
+
+    def _create_no_changes_recommendation(
+        self, current_version: str
+    ) -> VersionBumpRecommendation:
+        """Create recommendation when no changes are detected."""
+        return VersionBumpRecommendation(
+            bump_type=VersionBumpType.PATCH,
+            confidence=1.0,
+            reasoning=["No significant changes detected - patch bump recommended"],
+            current_version=current_version,
+            recommended_version=self._calculate_next_version(
+                current_version, VersionBumpType.PATCH
+            ),
+            breaking_changes=[],
+            new_features=[],
+            bug_fixes=[],
+            commit_analysis={
+                "type_counts": {},
+                "recommended_bumps": [],
+                "total_entries": 0,
+            },
+        )
+
+    def _analyze_entries_and_recommend(
+        self, current_version: str, all_entries: list[ChangelogEntry]
+    ) -> VersionBumpRecommendation:
+        """Analyze entries and create version bump recommendation."""
+        # Run specialized analyses
+        has_breaking, breaking_changes, breaking_confidence = (
+            self.breaking_analyzer.analyze(all_entries)
+        )
+        has_features, new_features, feature_confidence = self.feature_analyzer.analyze(
+            all_entries
+        )
+        commit_analysis = self.commit_analyzer.analyze(all_entries)
+
+        bug_fixes = [
+            entry.description
+            for entry in all_entries
+            if entry.type.lower() in ("fixed", "fix", "bugfix", "patch")
+        ]
+
+        bump_type, confidence, reasoning = self._determine_bump_type(
+            has_breaking,
+            breaking_changes,
+            breaking_confidence,
+            has_features,
+            new_features,
+            feature_confidence,
+            bug_fixes,
+            all_entries,
+        )
+
+        recommended_version = self._calculate_next_version(current_version, bump_type)
+
+        return VersionBumpRecommendation(
+            bump_type=bump_type,
+            confidence=confidence,
+            reasoning=reasoning,
+            current_version=current_version,
+            recommended_version=recommended_version,
+            breaking_changes=breaking_changes,
+            new_features=new_features,
+            bug_fixes=bug_fixes,
+            commit_analysis=commit_analysis,
+        )
+
+    def _determine_bump_type(
+        self,
+        has_breaking: bool,
+        breaking_changes: list[str],
+        breaking_confidence: float,
+        has_features: bool,
+        new_features: list[str],
+        feature_confidence: float,
+        bug_fixes: list[str],
+        all_entries: list[ChangelogEntry],
+    ) -> tuple[VersionBumpType, float, list[str]]:
+        """Determine the appropriate version bump type and reasoning."""
+        if has_breaking:
+            return (
+                VersionBumpType.MAJOR,
+                breaking_confidence,
+                [
+                    f"Breaking changes detected ({len(breaking_changes)} found)",
+                    "MAJOR version bump required to maintain semantic versioning",
+                ],
+            )
+        elif has_features:
+            return (
+                VersionBumpType.MINOR,
+                feature_confidence,
+                [
+                    f"New features detected ({len(new_features)} found)",
+                    "MINOR version bump recommended for backward-compatible functionality",
+                ],
+            )
+        elif bug_fixes:
+            return (
+                VersionBumpType.PATCH,
+                0.9,
+                [
+                    f"Bug fixes detected ({len(bug_fixes)} found)",
+                    "PATCH version bump recommended for backward-compatible fixes",
+                ],
+            )
+        return (
+            VersionBumpType.PATCH,
+            0.5,
+            [
+                f"Changes detected ({len(all_entries)} commits) with unclear impact",
+                "PATCH version bump recommended as conservative choice",
+            ],
+        )
+
+    def display_recommendation(self, recommendation: VersionBumpRecommendation) -> None:
+        """Display version bump recommendation in a user-friendly format."""
+        self._display_summary(recommendation)
+        self._display_reasoning(recommendation)
+        self._display_changes(recommendation)
+        self._display_commit_analysis(recommendation)
+
+    def _display_summary(self, recommendation: VersionBumpRecommendation) -> None:
+        """Display the main version bump summary."""
+        self.console.print("\n[cyan]📊 Version Bump Analysis[/cyan]")
+        self.console.print(
+            f"Current version: [bold]{recommendation.current_version}[/bold]"
+        )
+        self.console.print(
+            f"Recommended version: [bold green]{recommendation.recommended_version}[/bold green]"
+        )
+        self.console.print(
+            f"Bump type: [bold]{recommendation.bump_type.value.upper()}[/bold]"
+        )
+        self.console.print(f"Confidence: [bold]{recommendation.confidence:.0%}[/bold]")
+
+    def _display_reasoning(self, recommendation: VersionBumpRecommendation) -> None:
+        """Display the reasoning behind the recommendation."""
+        self.console.print("\n[yellow]💡 Reasoning:[/yellow]")
+        for reason in recommendation.reasoning:
+            self.console.print(f"  • {reason}")
+
+    def _display_changes(self, recommendation: VersionBumpRecommendation) -> None:
+        """Display breaking changes, new features, and bug fixes."""
+        self._display_change_list(
+            recommendation.breaking_changes, "[red]⚠️  Breaking Changes", "red"
+        )
+        self._display_change_list(
+            recommendation.new_features, "[green]✨ New Features", "green"
+        )
+        self._display_change_list(
+            recommendation.bug_fixes, "[blue]🔧 Bug Fixes", "blue"
+        )
+
+    def _display_change_list(self, changes: list[str], title: str, color: str) -> None:
+        """Display a list[t.Any] of changes with truncation."""
+        if changes:
+            self.console.print(f"\n{title} ({len(changes)}):[/{color}]")
+            for change in changes[:3]:
+                self.console.print(f"  • {change}")
+            if len(changes) > 3:
+                self.console.print(f"  • ... and {len(changes) - 3} more")
+
+    def _display_commit_analysis(
+        self, recommendation: VersionBumpRecommendation
+    ) -> None:
+        """Display commit analysis summary."""
+        analysis = recommendation.commit_analysis
+        if analysis.get("type_counts"):
+            self.console.print("\n[dim]📈 Commit Analysis:[/dim]")
+            total = analysis["total_entries"]
+            for commit_type, count in sorted(analysis["type_counts"].items()):
+                percentage = (count / total * 100) if total > 0 else 0
+                self.console.print(f"  {commit_type}: {count} ({percentage:.0f}%)")

crackerjack/services/version_checker.py

@@ -0,0 +1,223 @@
+import subprocess
+import typing as t
+from dataclasses import dataclass
+
+import aiohttp
+from acb.console import Console
+from acb.depends import Inject, depends
+
+from crackerjack.core.retry import retry_api_call
+
+
+@dataclass
+class VersionInfo:
+    tool_name: str
+    current_version: str
+    latest_version: str | None = None
+    update_available: bool = False
+    error: str | None = None
+
+
+class VersionChecker:
+    @depends.inject
+    def __init__(self, console: Inject[Console]) -> None:
+        self.console = console
+        self.tools_to_check = {
+            "ruff": self._get_ruff_version,
+            "pyright": self._get_pyright_version,
+            "pre-commit": self._get_precommit_version,
+            "uv": self._get_uv_version,
+        }
+
+    async def check_tool_updates(self) -> dict[str, VersionInfo]:
+        results = {}
+        for tool_name, version_getter in self.tools_to_check.items():
+            results[tool_name] = await self._check_single_tool(
+                tool_name, version_getter
+            )
+        return results
+
+    async def _check_single_tool(
+        self, tool_name: str, version_getter: t.Callable[[], str | None]
+    ) -> VersionInfo:
+        try:
+            current_version = version_getter()
+            if current_version:
+                latest_version = await self._fetch_latest_version(tool_name)
+                return self._create_installed_version_info(
+                    tool_name, current_version, latest_version
+                )
+            else:
+                return self._create_missing_tool_info(tool_name)
+        except Exception as e:
+            return self._create_error_version_info(tool_name, e)
+
+    def _create_installed_version_info(
+        self, tool_name: str, current_version: str, latest_version: str | None
+    ) -> VersionInfo:
+        update_available = (
+            latest_version is not None
+            and self._version_compare(current_version, latest_version) < 0
+        )
+
+        if update_available:
+            self.console.print(
+                f"[yellow]🔄 {tool_name} update available: "
+                f"{current_version} → {latest_version}[/ yellow]"
+            )
+
+        return VersionInfo(
+            tool_name=tool_name,
+            current_version=current_version,
+            latest_version=latest_version,
+            update_available=update_available,
+        )
+
+    def _create_missing_tool_info(self, tool_name: str) -> VersionInfo:
+        self.console.print(f"[red]⚠️ {tool_name} not installed[/ red]")
+        return VersionInfo(
+            tool_name=tool_name,
+            current_version="not installed",
+            error=f"{tool_name} not found or not installed",
+        )
+
+    def _create_error_version_info(
+        self, tool_name: str, error: Exception
+    ) -> VersionInfo:
+        self.console.print(f"[red]❌ Error checking {tool_name}: {error}[/ red]")
+        return VersionInfo(
+            tool_name=tool_name,
+            current_version="unknown",
+            error=str(error),
+        )
+
+    def _get_ruff_version(self) -> str | None:
+        return self._get_tool_version("ruff")
+
+    def _get_pyright_version(self) -> str | None:
+        return self._get_tool_version("pyright")
+
+    def _get_precommit_version(self) -> str | None:
+        return self._get_tool_version("pre-commit")
+
+    def _get_uv_version(self) -> str | None:
+        return self._get_tool_version("uv")
+
+    def _get_tool_version(self, tool_name: str) -> str | None:
+        try:
+            result = subprocess.run(
+                [tool_name, "--version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+            )
+            if result.returncode == 0:
+                version_line = result.stdout.strip()
+                return version_line.split()[-1] if version_line else None
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
+        return None
+
+    @retry_api_call(max_attempts=3, delay=1.0, backoff=2.0, max_delay=30.0)
+    async def _fetch_latest_version(self, tool_name: str) -> str | None:
+        try:
+            # Fix URLs - remove spaces that were added
+            pypi_urls = {
+                "ruff": "https://pypi.org/pypi/ruff/json",
+                "pyright": "https://pypi.org/pypi/pyright/json",
+                "pre-commit": "https://pypi.org/pypi/pre-commit/json",
+                "uv": "https://pypi.org/pypi/uv/json",
+            }
+
+            url = pypi_urls.get(tool_name)
+            if not url:
+                return None
+
+            timeout = aiohttp.ClientTimeout(total=10.0)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.get(url) as response:
+                    response.raise_for_status()
+                    data: dict[str, t.Any] = await response.json()
+                    return data.get("info", {}).get("version")
+
+        except Exception:
+            return None
+
+    def _version_compare(self, current: str, latest: str) -> int:
+        try:
+            current_parts, current_len = self._parse_version_parts(current)
+            latest_parts, latest_len = self._parse_version_parts(latest)
+
+            normalized_current, normalized_latest = self._normalize_version_parts(
+                current_parts, latest_parts
+            )
+
+            numeric_result = self._compare_numeric_parts(
+                normalized_current, normalized_latest
+            )
+            if numeric_result != 0:
+                return numeric_result
+
+            return self._handle_length_differences(
+                current_len, latest_len, normalized_current, normalized_latest
+            )
+
+        except (ValueError, AttributeError):
+            return 0
+
+    def _parse_version_parts(self, version: str) -> tuple[list[int], int]:
+        parts = [int(x) for x in version.split(".")]
+        return parts, len(parts)
+
+    def _normalize_version_parts(
+        self, current_parts: list[int], latest_parts: list[int]
+    ) -> tuple[list[int], list[int]]:
+        max_len = max(len(current_parts), len(latest_parts))
+        current_normalized = current_parts + [0] * (max_len - len(current_parts))
+        latest_normalized = latest_parts + [0] * (max_len - len(latest_parts))
+        return current_normalized, latest_normalized
+
+    def _compare_numeric_parts(
+        self, current_parts: list[int], latest_parts: list[int]
+    ) -> int:
+        for current_part, latest_part in zip(current_parts, latest_parts):
+            if current_part < latest_part:
+                return -1
+            if current_part > latest_part:
+                return 1
+        return 0
+
+    def _handle_length_differences(
+        self,
+        current_len: int,
+        latest_len: int,
+        current_parts: list[int],
+        latest_parts: list[int],
+    ) -> int:
+        if current_len == latest_len:
+            return 0
+
+        if current_len < latest_len:
+            return self._compare_when_current_shorter(
+                current_len, latest_len, latest_parts
+            )
+        return self._compare_when_latest_shorter(latest_len, current_len, current_parts)
+
+    def _compare_when_current_shorter(
+        self, current_len: int, latest_len: int, latest_parts: list[int]
+    ) -> int:
+        extra_parts = latest_parts[current_len:]
+        if any(part != 0 for part in extra_parts):
+            return -1
+
+        return -1 if current_len > 1 else 0
+
+    def _compare_when_latest_shorter(
+        self, latest_len: int, current_len: int, current_parts: list[int]
+    ) -> int:
+        extra_parts = current_parts[latest_len:]
+        if any(part != 0 for part in extra_parts):
+            return 1
+
+        return 1 if latest_len > 1 else 0