codeshift 0.4.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

codeshift/health/calculator.py

@@ -0,0 +1,217 @@
+"""Main health score calculator orchestrator."""
+
+import logging
+from pathlib import Path
+
+from codeshift.health.metrics import BaseMetricCalculator
+from codeshift.health.metrics.documentation import DocumentationCalculator
+from codeshift.health.metrics.freshness import FreshnessCalculator
+from codeshift.health.metrics.migration_readiness import MigrationReadinessCalculator
+from codeshift.health.metrics.security import SecurityCalculator
+from codeshift.health.metrics.test_coverage import TestCoverageCalculator
+from codeshift.health.models import (
+    DependencyHealth,
+    HealthGrade,
+    HealthReport,
+    HealthScore,
+    MetricResult,
+    SecurityVulnerability,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class HealthCalculator:
+    """Orchestrates health score calculation across all metrics."""
+
+    def __init__(self) -> None:
+        """Initialize the calculator with all metric calculators."""
+        self.calculators: list[BaseMetricCalculator] = [
+            FreshnessCalculator(),
+            SecurityCalculator(),
+            MigrationReadinessCalculator(),
+            TestCoverageCalculator(),
+            DocumentationCalculator(),
+        ]
+
+    def calculate(self, project_path: Path) -> HealthScore:
+        """Calculate the complete health score for a project.
+
+        Args:
+            project_path: Path to the project root
+
+        Returns:
+            HealthScore with all metrics and overall score
+        """
+        project_path = project_path.resolve()
+
+        # First, analyze dependencies once to share across calculators
+        dependencies = self._analyze_dependencies(project_path)
+
+        # Calculate each metric
+        metrics: list[MetricResult] = []
+        for calculator in self.calculators:
+            try:
+                result = calculator.calculate(
+                    project_path,
+                    dependencies=dependencies,
+                )
+                metrics.append(result)
+            except Exception as e:
+                logger.warning(f"Failed to calculate {calculator.category.value}: {e}")
+                # Add a neutral result on failure
+                metrics.append(
+                    MetricResult(
+                        category=calculator.category,
+                        score=50,
+                        weight=calculator.weight,
+                        description=f"Error: {str(e)[:50]}",
+                        details={"error": str(e)},
+                        recommendations=["Fix metric calculation error"],
+                    )
+                )
+
+        # Calculate overall weighted score
+        total_weight = sum(m.weight for m in metrics)
+        if total_weight > 0:
+            overall_score = sum(m.weighted_score for m in metrics) / total_weight
+        else:
+            overall_score = 0
+
+        # Collect all vulnerabilities
+        all_vulns: list[SecurityVulnerability] = []
+        for dep in dependencies:
+            all_vulns.extend(dep.vulnerabilities)
+
+        return HealthScore(
+            overall_score=overall_score,
+            grade=HealthGrade.from_score(overall_score),
+            metrics=metrics,
+            dependencies=dependencies,
+            vulnerabilities=all_vulns,
+            project_path=project_path,
+        )
+
+    def calculate_report(
+        self,
+        project_path: Path,
+        previous: HealthScore | None = None,
+    ) -> HealthReport:
+        """Calculate a health report with trend information.
+
+        Args:
+            project_path: Path to the project root
+            previous: Optional previous health score for comparison
+
+        Returns:
+            HealthReport with current score and trend
+        """
+        current = self.calculate(project_path)
+        return HealthReport(current=current, previous=previous)
+
+    def _analyze_dependencies(self, project_path: Path) -> list[DependencyHealth]:
+        """Analyze all dependencies for shared data.
+
+        This method runs once and provides data for multiple calculators
+        to avoid redundant API calls.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            List of DependencyHealth with all analyzable data
+        """
+        from codeshift.scanner.dependency_parser import DependencyParser
+
+        parser = DependencyParser(project_path)
+        raw_deps = parser.parse_all()
+
+        # Get knowledge base info for tier support
+        from codeshift.knowledge_base import KnowledgeBaseLoader
+
+        loader = KnowledgeBaseLoader()
+        supported_libraries = loader.get_supported_libraries()
+        tier1_libraries = {"pydantic", "fastapi", "sqlalchemy", "pandas", "requests"}
+
+        dependencies: list[DependencyHealth] = []
+
+        for dep in raw_deps:
+            dep_name_lower = dep.name.lower()
+
+            # Get latest version and vulnerabilities from PyPI
+            latest_version = None
+            vulnerabilities: list[SecurityVulnerability] = []
+
+            try:
+                import httpx
+                from packaging.version import Version
+
+                response = httpx.get(
+                    f"https://pypi.org/pypi/{dep.name}/json",
+                    timeout=5.0,
+                )
+                if response.status_code == 200:
+                    data = response.json()
+
+                    # Get latest version
+                    version_str = data.get("info", {}).get("version")
+                    if version_str:
+                        latest_version = Version(version_str)
+
+                    # Get vulnerabilities
+                    from codeshift.health.models import VulnerabilitySeverity
+
+                    for vuln_data in data.get("vulnerabilities", []):
+                        try:
+                            severity = VulnerabilitySeverity.MEDIUM
+                            vulnerabilities.append(
+                                SecurityVulnerability(
+                                    package=dep.name,
+                                    vulnerability_id=vuln_data.get("id", "unknown"),
+                                    severity=severity,
+                                    description=vuln_data.get("summary", "")[:200],
+                                    fixed_in=(
+                                        vuln_data.get("fixed_in", [None])[0]
+                                        if vuln_data.get("fixed_in")
+                                        else None
+                                    ),
+                                    url=vuln_data.get("link"),
+                                )
+                            )
+                        except Exception:
+                            pass
+
+            except Exception as e:
+                logger.debug(f"Failed to fetch PyPI data for {dep.name}: {e}")
+
+            # Calculate version lag
+            current = dep.min_version
+            is_outdated = False
+            major_behind = 0
+            minor_behind = 0
+
+            if current and latest_version:
+                is_outdated = current < latest_version
+                major_behind = max(0, latest_version.major - current.major)
+                if major_behind == 0:
+                    minor_behind = max(0, latest_version.minor - current.minor)
+
+            # Check tier support
+            has_tier1 = dep_name_lower in tier1_libraries
+            has_tier2 = dep_name_lower in [lib.lower() for lib in supported_libraries]
+
+            dependencies.append(
+                DependencyHealth(
+                    name=dep.name,
+                    current_version=str(current) if current else None,
+                    latest_version=str(latest_version) if latest_version else None,
+                    is_outdated=is_outdated,
+                    major_versions_behind=major_behind,
+                    minor_versions_behind=minor_behind,
+                    has_tier1_support=has_tier1,
+                    has_tier2_support=has_tier2,
+                    vulnerabilities=vulnerabilities,
+                )
+            )
+
+        return dependencies

codeshift/health/metrics/__init__.py

@@ -0,0 +1,63 @@
+"""Base class and utilities for health metric calculators."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+from codeshift.health.models import MetricCategory, MetricResult
+
+
+class BaseMetricCalculator(ABC):
+    """Abstract base class for health metric calculators."""
+
+    @property
+    @abstractmethod
+    def category(self) -> MetricCategory:
+        """Return the metric category."""
+        ...
+
+    @property
+    @abstractmethod
+    def weight(self) -> float:
+        """Return the weight for this metric (0.0 to 1.0)."""
+        ...
+
+    @abstractmethod
+    def calculate(self, project_path: Path, **kwargs: Any) -> MetricResult:
+        """Calculate the metric score.
+
+        Args:
+            project_path: Path to the project root
+            **kwargs: Additional arguments specific to the metric
+
+        Returns:
+            MetricResult with score and details
+        """
+        ...
+
+    def _create_result(
+        self,
+        score: float,
+        description: str,
+        details: dict | None = None,
+        recommendations: list[str] | None = None,
+    ) -> MetricResult:
+        """Helper to create a MetricResult.
+
+        Args:
+            score: Score from 0-100
+            description: Human-readable description
+            details: Optional details dictionary
+            recommendations: Optional list of recommendations
+
+        Returns:
+            MetricResult instance
+        """
+        return MetricResult(
+            category=self.category,
+            score=max(0, min(100, score)),  # Clamp to 0-100
+            weight=self.weight,
+            description=description,
+            details=details or {},
+            recommendations=recommendations or [],
+        )

codeshift/health/metrics/documentation.py

@@ -0,0 +1,209 @@
+"""Documentation quality metric calculator."""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import libcst as cst
+
+from codeshift.health.metrics import BaseMetricCalculator
+from codeshift.health.models import MetricCategory, MetricResult
+
+logger = logging.getLogger(__name__)
+
+
+class DocumentationCalculator(BaseMetricCalculator):
+    """Calculates documentation score (10% weight).
+
+    Score based on:
+    - Type hints coverage: 70% of score
+    - Docstring coverage: 30% of score
+    """
+
+    @property
+    def category(self) -> MetricCategory:
+        return MetricCategory.DOCUMENTATION
+
+    @property
+    def weight(self) -> float:
+        return 0.10
+
+    def calculate(self, project_path: Path, **kwargs: Any) -> MetricResult:
+        """Calculate the documentation score.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            MetricResult with documentation score
+        """
+        # Find all Python files
+        python_files = list(project_path.rglob("*.py"))
+
+        # Exclude common non-source directories
+        excluded_patterns = [
+            ".venv",
+            "venv",
+            ".git",
+            "__pycache__",
+            ".tox",
+            ".eggs",
+            "build",
+            "dist",
+            ".mypy_cache",
+            ".pytest_cache",
+        ]
+
+        python_files = [
+            f for f in python_files if not any(pattern in str(f) for pattern in excluded_patterns)
+        ]
+
+        if not python_files:
+            return self._create_result(
+                score=100,
+                description="No Python files to analyze",
+                details={"file_count": 0},
+                recommendations=[],
+            )
+
+        # Analyze files
+        total_functions = 0
+        typed_functions = 0
+        documented_functions = 0
+
+        for file_path in python_files:
+            try:
+                source = file_path.read_text()
+                tree = cst.parse_module(source)
+                stats = self._analyze_file(tree)
+
+                total_functions += stats["total"]
+                typed_functions += stats["typed"]
+                documented_functions += stats["documented"]
+            except Exception as e:
+                logger.debug(f"Failed to analyze {file_path}: {e}")
+
+        if total_functions == 0:
+            return self._create_result(
+                score=100,
+                description="No functions found to analyze",
+                details={"file_count": len(python_files), "function_count": 0},
+                recommendations=[],
+            )
+
+        typed_ratio = typed_functions / total_functions
+        documented_ratio = documented_functions / total_functions
+
+        # Score = (typed_ratio * 70) + (documented_ratio * 30)
+        score = (typed_ratio * 70) + (documented_ratio * 30)
+
+        recommendations: list[str] = []
+        if typed_ratio < 0.5:
+            recommendations.append(
+                f"Add type hints to functions ({typed_functions}/{total_functions} typed)"
+            )
+        if documented_ratio < 0.3:
+            recommendations.append(
+                f"Add docstrings to functions ({documented_functions}/{total_functions} documented)"
+            )
+
+        return self._create_result(
+            score=score,
+            description=f"{typed_ratio:.0%} typed, {documented_ratio:.0%} documented",
+            details={
+                "file_count": len(python_files),
+                "function_count": total_functions,
+                "typed_count": typed_functions,
+                "documented_count": documented_functions,
+                "typed_ratio": typed_ratio,
+                "documented_ratio": documented_ratio,
+            },
+            recommendations=recommendations,
+        )
+
+    def _analyze_file(self, tree: cst.Module) -> dict:
+        """Analyze a file for type hints and docstrings.
+
+        Args:
+            tree: Parsed CST module
+
+        Returns:
+            Dict with total, typed, and documented counts
+        """
+        visitor = FunctionAnalyzer()
+        # Use MetadataWrapper to walk the tree with the visitor
+        wrapper = cst.MetadataWrapper(tree)
+        wrapper.visit(visitor)
+
+        return {
+            "total": visitor.total_functions,
+            "typed": visitor.typed_functions,
+            "documented": visitor.documented_functions,
+        }
+
+
+class FunctionAnalyzer(cst.CSTVisitor):
+    """CST visitor to analyze functions for type hints and docstrings."""
+
+    def __init__(self) -> None:
+        self.total_functions = 0
+        self.typed_functions = 0
+        self.documented_functions = 0
+
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
+        self.total_functions += 1
+
+        # Check for type hints
+        if self._has_type_hints(node):
+            self.typed_functions += 1
+
+        # Check for docstring
+        if self._has_docstring(node):
+            self.documented_functions += 1
+
+        return True  # Continue visiting nested functions
+
+    def _has_type_hints(self, node: cst.FunctionDef) -> bool:
+        """Check if a function has type hints.
+
+        Args:
+            node: Function definition node
+
+        Returns:
+            True if function has return type or any parameter types
+        """
+        # Check return type
+        if node.returns is not None:
+            return True
+
+        # Check parameter types
+        for param in node.params.params:
+            if param.annotation is not None:
+                return True
+
+        return False
+
+    def _has_docstring(self, node: cst.FunctionDef) -> bool:
+        """Check if a function has a docstring.
+
+        Args:
+            node: Function definition node
+
+        Returns:
+            True if function has a docstring
+        """
+        if not node.body.body:
+            return False
+
+        first_stmt = node.body.body[0]
+
+        # Check if first statement is an expression statement with a string
+        if isinstance(first_stmt, cst.SimpleStatementLine):
+            if first_stmt.body and isinstance(first_stmt.body[0], cst.Expr):
+                expr = first_stmt.body[0].value
+                if isinstance(expr, (cst.SimpleString, cst.ConcatenatedString)):
+                    return True
+                if isinstance(expr, cst.FormattedString):
+                    return True
+
+        return False

codeshift/health/metrics/freshness.py

@@ -0,0 +1,180 @@
+"""Dependency freshness metric calculator."""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import httpx
+from packaging.version import Version
+
+from codeshift.health.metrics import BaseMetricCalculator
+from codeshift.health.models import DependencyHealth, MetricCategory, MetricResult
+from codeshift.scanner.dependency_parser import DependencyParser
+
+logger = logging.getLogger(__name__)
+
+# PyPI API timeout
+PYPI_TIMEOUT = 5.0
+
+
+class FreshnessCalculator(BaseMetricCalculator):
+    """Calculates dependency freshness score (30% weight).
+
+    Score is based on how up-to-date dependencies are:
+    - Major version behind: -15 points per dependency
+    - Minor version behind: -5 points each (up to 3 per dependency)
+    """
+
+    @property
+    def category(self) -> MetricCategory:
+        return MetricCategory.FRESHNESS
+
+    @property
+    def weight(self) -> float:
+        return 0.30
+
+    def calculate(
+        self,
+        project_path: Path,
+        dependencies: list[DependencyHealth] | None = None,
+        **kwargs: Any,
+    ) -> MetricResult:
+        """Calculate the freshness score.
+
+        Args:
+            project_path: Path to the project
+            dependencies: Pre-populated dependency health list (optional)
+
+        Returns:
+            MetricResult with freshness score
+        """
+        if dependencies is None:
+            dependencies = self._analyze_dependencies(project_path)
+
+        if not dependencies:
+            return self._create_result(
+                score=100,
+                description="No dependencies to analyze",
+                details={"dependency_count": 0},
+                recommendations=[],
+            )
+
+        # Calculate penalty
+        total_penalty = 0
+        outdated_deps: list[str] = []
+        major_outdated: list[str] = []
+
+        for dep in dependencies:
+            if dep.is_outdated:
+                outdated_deps.append(dep.name)
+                penalty = dep.version_lag_penalty
+                total_penalty += penalty
+
+                if dep.major_versions_behind > 0:
+                    major_outdated.append(
+                        f"{dep.name} ({dep.current_version} -> {dep.latest_version})"
+                    )
+
+        # Score starts at 100, subtract penalties (min 0)
+        score = max(0, 100 - total_penalty)
+
+        # Build recommendations
+        recommendations: list[str] = []
+        if major_outdated:
+            recommendations.append(
+                f"Update major versions: {', '.join(major_outdated[:3])}"
+                + (f" (+{len(major_outdated) - 3} more)" if len(major_outdated) > 3 else "")
+            )
+        if len(outdated_deps) > len(major_outdated):
+            minor_count = len(outdated_deps) - len(major_outdated)
+            recommendations.append(f"Update {minor_count} dependencies with minor version updates")
+
+        return self._create_result(
+            score=score,
+            description=f"{len(outdated_deps)}/{len(dependencies)} dependencies outdated",
+            details={
+                "total_dependencies": len(dependencies),
+                "outdated_count": len(outdated_deps),
+                "major_outdated_count": len(major_outdated),
+                "total_penalty": total_penalty,
+            },
+            recommendations=recommendations,
+        )
+
+    def _analyze_dependencies(self, project_path: Path) -> list[DependencyHealth]:
+        """Analyze project dependencies for freshness.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            List of DependencyHealth objects
+        """
+        parser = DependencyParser(project_path)
+        dependencies = parser.parse_all()
+
+        results: list[DependencyHealth] = []
+
+        for dep in dependencies:
+            try:
+                latest = self._get_latest_version(dep.name)
+                current = dep.min_version
+
+                if current and latest:
+                    is_outdated = current < latest
+                    major_behind = max(0, latest.major - current.major)
+                    minor_behind = 0
+                    if major_behind == 0:
+                        minor_behind = max(0, latest.minor - current.minor)
+                else:
+                    is_outdated = False
+                    major_behind = 0
+                    minor_behind = 0
+
+                results.append(
+                    DependencyHealth(
+                        name=dep.name,
+                        current_version=str(current) if current else None,
+                        latest_version=str(latest) if latest else None,
+                        is_outdated=is_outdated,
+                        major_versions_behind=major_behind,
+                        minor_versions_behind=minor_behind,
+                    )
+                )
+            except Exception as e:
+                logger.debug(f"Error analyzing {dep.name}: {e}")
+                # Add with unknown status
+                results.append(
+                    DependencyHealth(
+                        name=dep.name,
+                        current_version=str(dep.min_version) if dep.min_version else None,
+                        latest_version=None,
+                        is_outdated=False,
+                    )
+                )
+
+        return results
+
+    def _get_latest_version(self, package_name: str) -> Version | None:
+        """Get the latest version of a package from PyPI.
+
+        Args:
+            package_name: Name of the package
+
+        Returns:
+            Latest Version or None if not found
+        """
+        try:
+            response = httpx.get(
+                f"https://pypi.org/pypi/{package_name}/json",
+                timeout=PYPI_TIMEOUT,
+            )
+            if response.status_code == 200:
+                data = response.json()
+                version_str = data.get("info", {}).get("version")
+                if version_str:
+                    return Version(version_str)
+        except Exception as e:
+            logger.debug(f"Failed to get latest version for {package_name}: {e}")
+
+        return None