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

codeshift/health/metrics/security.py

@@ -0,0 +1,225 @@
+"""Security vulnerabilities metric calculator."""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from codeshift.health.metrics import BaseMetricCalculator
+from codeshift.health.models import (
+    DependencyHealth,
+    MetricCategory,
+    MetricResult,
+    SecurityVulnerability,
+    VulnerabilitySeverity,
+)
+from codeshift.scanner.dependency_parser import DependencyParser
+
+logger = logging.getLogger(__name__)
+
+# PyPI API timeout
+PYPI_TIMEOUT = 5.0
+
+
+class SecurityCalculator(BaseMetricCalculator):
+    """Calculates security score based on known vulnerabilities (25% weight).
+
+    Penalties:
+    - Critical: -25 points
+    - High: -15 points
+    - Medium: -8 points
+    - Low: -3 points
+    """
+
+    @property
+    def category(self) -> MetricCategory:
+        return MetricCategory.SECURITY
+
+    @property
+    def weight(self) -> float:
+        return 0.25
+
+    def calculate(
+        self,
+        project_path: Path,
+        dependencies: list[DependencyHealth] | None = None,
+        **kwargs: Any,
+    ) -> MetricResult:
+        """Calculate the security score.
+
+        Args:
+            project_path: Path to the project
+            dependencies: Pre-populated dependency health list (optional)
+
+        Returns:
+            MetricResult with security 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, "vulnerability_count": 0},
+                recommendations=[],
+            )
+
+        # Collect all vulnerabilities
+        all_vulns: list[SecurityVulnerability] = []
+        vuln_counts = {
+            VulnerabilitySeverity.CRITICAL: 0,
+            VulnerabilitySeverity.HIGH: 0,
+            VulnerabilitySeverity.MEDIUM: 0,
+            VulnerabilitySeverity.LOW: 0,
+        }
+
+        for dep in dependencies:
+            for vuln in dep.vulnerabilities:
+                all_vulns.append(vuln)
+                vuln_counts[vuln.severity] += 1
+
+        # Calculate penalty
+        total_penalty = sum(count * severity.penalty for severity, count in vuln_counts.items())
+        score = max(0, 100 - total_penalty)
+
+        # Build recommendations
+        recommendations: list[str] = []
+        if vuln_counts[VulnerabilitySeverity.CRITICAL] > 0:
+            critical_pkgs = list(
+                {v.package for v in all_vulns if v.severity == VulnerabilitySeverity.CRITICAL}
+            )
+            recommendations.append(
+                f"URGENT: Fix critical vulnerabilities in: {', '.join(critical_pkgs)}"
+            )
+
+        if vuln_counts[VulnerabilitySeverity.HIGH] > 0:
+            high_pkgs = list(
+                {v.package for v in all_vulns if v.severity == VulnerabilitySeverity.HIGH}
+            )
+            recommendations.append(
+                f"Address high severity vulnerabilities in: {', '.join(high_pkgs)}"
+            )
+
+        if vuln_counts[VulnerabilitySeverity.MEDIUM] > 0:
+            recommendations.append(
+                f"Review {vuln_counts[VulnerabilitySeverity.MEDIUM]} medium severity vulnerabilities"
+            )
+
+        return self._create_result(
+            score=score,
+            description=(
+                f"{len(all_vulns)} vulnerabilities found"
+                if all_vulns
+                else "No known vulnerabilities"
+            ),
+            details={
+                "total_vulnerabilities": len(all_vulns),
+                "critical": vuln_counts[VulnerabilitySeverity.CRITICAL],
+                "high": vuln_counts[VulnerabilitySeverity.HIGH],
+                "medium": vuln_counts[VulnerabilitySeverity.MEDIUM],
+                "low": vuln_counts[VulnerabilitySeverity.LOW],
+                "total_penalty": total_penalty,
+            },
+            recommendations=recommendations,
+        )
+
+    def _analyze_dependencies(self, project_path: Path) -> list[DependencyHealth]:
+        """Analyze project dependencies for security vulnerabilities.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            List of DependencyHealth objects with vulnerability data
+        """
+        parser = DependencyParser(project_path)
+        dependencies = parser.parse_all()
+
+        results: list[DependencyHealth] = []
+
+        for dep in dependencies:
+            vulns = self._get_vulnerabilities(dep.name)
+            results.append(
+                DependencyHealth(
+                    name=dep.name,
+                    current_version=str(dep.min_version) if dep.min_version else None,
+                    latest_version=None,
+                    is_outdated=False,
+                    vulnerabilities=vulns,
+                )
+            )
+
+        return results
+
+    def _get_vulnerabilities(self, package_name: str) -> list[SecurityVulnerability]:
+        """Get known vulnerabilities for a package from PyPI.
+
+        Args:
+            package_name: Name of the package
+
+        Returns:
+            List of SecurityVulnerability objects
+        """
+        vulns: list[SecurityVulnerability] = []
+
+        try:
+            response = httpx.get(
+                f"https://pypi.org/pypi/{package_name}/json",
+                timeout=PYPI_TIMEOUT,
+            )
+            if response.status_code == 200:
+                data = response.json()
+                vulnerabilities = data.get("vulnerabilities", [])
+
+                for vuln_data in vulnerabilities:
+                    severity_str = self._parse_severity(vuln_data)
+                    try:
+                        severity = VulnerabilitySeverity(severity_str.lower())
+                    except ValueError:
+                        severity = VulnerabilitySeverity.MEDIUM
+
+                    fixed_in = None
+                    if vuln_data.get("fixed_in"):
+                        fixed_versions = vuln_data.get("fixed_in", [])
+                        if fixed_versions:
+                            fixed_in = fixed_versions[0]
+
+                    vulns.append(
+                        SecurityVulnerability(
+                            package=package_name,
+                            vulnerability_id=vuln_data.get("id", "unknown"),
+                            severity=severity,
+                            description=vuln_data.get("summary", vuln_data.get("details", ""))[
+                                :200
+                            ],
+                            fixed_in=fixed_in,
+                            url=vuln_data.get("link"),
+                        )
+                    )
+
+        except Exception as e:
+            logger.debug(f"Failed to get vulnerabilities for {package_name}: {e}")
+
+        return vulns
+
+    def _parse_severity(self, vuln_data: dict) -> str:
+        """Parse severity from vulnerability data.
+
+        Args:
+            vuln_data: Vulnerability data dictionary
+
+        Returns:
+            Severity string (critical, high, medium, low)
+        """
+        # Try to get severity from aliases (e.g., CVE data)
+        aliases = vuln_data.get("aliases", [])
+        for alias in aliases:
+            if "CRITICAL" in alias.upper():
+                return "critical"
+            elif "HIGH" in alias.upper():
+                return "high"
+
+        # Default to medium if not specified
+        return "medium"

codeshift/health/metrics/test_coverage.py

@@ -0,0 +1,191 @@
+"""Test coverage metric calculator."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from codeshift.health.metrics import BaseMetricCalculator
+from codeshift.health.models import MetricCategory, MetricResult
+
+logger = logging.getLogger(__name__)
+
+
+class TestCoverageCalculator(BaseMetricCalculator):
+    """Calculates test coverage score (15% weight).
+
+    Score is directly mapped from coverage percentage.
+    Returns 50 (neutral) if no coverage data is found.
+    """
+
+    @property
+    def category(self) -> MetricCategory:
+        return MetricCategory.TEST_COVERAGE
+
+    @property
+    def weight(self) -> float:
+        return 0.15
+
+    def calculate(self, project_path: Path, **kwargs: Any) -> MetricResult:
+        """Calculate the test coverage score.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            MetricResult with test coverage score
+        """
+        coverage, source = self._get_coverage(project_path)
+
+        if coverage is None:
+            return self._create_result(
+                score=50,  # Neutral score when no data
+                description="No coverage data found",
+                details={"coverage_found": False},
+                recommendations=[
+                    "Run tests with coverage: pytest --cov",
+                    "Generate coverage report: coverage run -m pytest && coverage report",
+                ],
+            )
+
+        # Direct mapping: coverage % = score
+        score = coverage * 100
+
+        recommendations: list[str] = []
+        if coverage < 0.5:
+            recommendations.append("Increase test coverage to at least 50%")
+        elif coverage < 0.8:
+            recommendations.append("Consider increasing test coverage to 80% or higher")
+
+        return self._create_result(
+            score=score,
+            description=f"{coverage:.0%} test coverage",
+            details={
+                "coverage_found": True,
+                "coverage_percentage": coverage * 100,
+                "source": source,
+            },
+            recommendations=recommendations,
+        )
+
+    def _get_coverage(self, project_path: Path) -> tuple[float | None, str]:
+        """Get test coverage from available sources.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            Tuple of (coverage percentage as 0-1 or None, source description)
+        """
+        # Try coverage.json first (pytest-cov JSON output)
+        coverage_json = project_path / "coverage.json"
+        if coverage_json.exists():
+            try:
+                data = json.loads(coverage_json.read_text())
+                totals = data.get("totals", {})
+                percent = totals.get("percent_covered", 0)
+                return percent / 100, "coverage.json"
+            except Exception as e:
+                logger.debug(f"Failed to parse coverage.json: {e}")
+
+        # Try .coverage SQLite database
+        coverage_db = project_path / ".coverage"
+        if coverage_db.exists():
+            coverage = self._read_coverage_db(coverage_db)
+            if coverage is not None:
+                return coverage, ".coverage database"
+
+        # Try htmlcov/index.html for percentage
+        htmlcov_index = project_path / "htmlcov" / "index.html"
+        if htmlcov_index.exists():
+            coverage = self._parse_htmlcov(htmlcov_index)
+            if coverage is not None:
+                return coverage, "htmlcov"
+
+        # Try pytest-cov XML format
+        coverage_xml = project_path / "coverage.xml"
+        if coverage_xml.exists():
+            coverage = self._parse_coverage_xml(coverage_xml)
+            if coverage is not None:
+                return coverage, "coverage.xml"
+
+        return None, ""
+
+    def _read_coverage_db(self, db_path: Path) -> float | None:
+        """Read coverage from SQLite database.
+
+        Args:
+            db_path: Path to .coverage database
+
+        Returns:
+            Coverage percentage as 0-1 or None
+        """
+        try:
+            import sqlite3
+
+            conn = sqlite3.connect(db_path)
+            cursor = conn.cursor()
+
+            # Get total lines and covered lines
+            cursor.execute(
+                """
+                SELECT SUM(num_lines), SUM(num_hits)
+                FROM line_counts
+                """
+            )
+            row = cursor.fetchone()
+            conn.close()
+
+            if row and row[0] and row[0] > 0:
+                total_lines = row[0]
+                covered_lines = row[1] or 0
+                return float(covered_lines / total_lines) if total_lines > 0 else None
+
+        except Exception as e:
+            logger.debug(f"Failed to read .coverage database: {e}")
+
+        return None
+
+    def _parse_htmlcov(self, index_path: Path) -> float | None:
+        """Parse coverage percentage from htmlcov index.
+
+        Args:
+            index_path: Path to htmlcov/index.html
+
+        Returns:
+            Coverage percentage as 0-1 or None
+        """
+        try:
+            import re
+
+            content = index_path.read_text()
+            # Look for patterns like "85%" or "coverage: 85"
+            match = re.search(r"(\d+(?:\.\d+)?)\s*%", content)
+            if match:
+                return float(match.group(1)) / 100
+        except Exception as e:
+            logger.debug(f"Failed to parse htmlcov: {e}")
+
+        return None
+
+    def _parse_coverage_xml(self, xml_path: Path) -> float | None:
+        """Parse coverage from Cobertura XML format.
+
+        Args:
+            xml_path: Path to coverage.xml
+
+        Returns:
+            Coverage percentage as 0-1 or None
+        """
+        try:
+            import re
+
+            content = xml_path.read_text()
+            # Look for line-rate="0.85" attribute
+            match = re.search(r'line-rate="(\d+(?:\.\d+)?)"', content)
+            if match:
+                return float(match.group(1))
+        except Exception as e:
+            logger.debug(f"Failed to parse coverage.xml: {e}")
+
+        return None

codeshift/health/models.py

@@ -0,0 +1,284 @@
+"""Data models for the health score feature."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+
+class MetricCategory(Enum):
+    """Categories of health metrics."""
+
+    FRESHNESS = "freshness"
+    SECURITY = "security"
+    MIGRATION_READINESS = "migration_readiness"
+    TEST_COVERAGE = "test_coverage"
+    DOCUMENTATION = "documentation"
+
+
+class HealthGrade(Enum):
+    """Letter grade for overall health score."""
+
+    A = "A"  # 90-100
+    B = "B"  # 80-89
+    C = "C"  # 70-79
+    D = "D"  # 60-69
+    F = "F"  # Below 60
+
+    @classmethod
+    def from_score(cls, score: float) -> "HealthGrade":
+        """Convert a numeric score to a letter grade.
+
+        Args:
+            score: Numeric score from 0-100
+
+        Returns:
+            Corresponding letter grade
+        """
+        if score >= 90:
+            return cls.A
+        elif score >= 80:
+            return cls.B
+        elif score >= 70:
+            return cls.C
+        elif score >= 60:
+            return cls.D
+        else:
+            return cls.F
+
+    @property
+    def color(self) -> str:
+        """Get the display color for this grade."""
+        colors = {
+            HealthGrade.A: "green",
+            HealthGrade.B: "cyan",
+            HealthGrade.C: "yellow",
+            HealthGrade.D: "orange1",
+            HealthGrade.F: "red",
+        }
+        return colors.get(self, "white")
+
+    @property
+    def emoji(self) -> str:
+        """Get the emoji for this grade."""
+        emojis = {
+            HealthGrade.A: "🟢",
+            HealthGrade.B: "🔵",
+            HealthGrade.C: "🟡",
+            HealthGrade.D: "🟠",
+            HealthGrade.F: "🔴",
+        }
+        return emojis.get(self, "⚪")
+
+
+class VulnerabilitySeverity(Enum):
+    """Severity levels for security vulnerabilities."""
+
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+
+    @property
+    def penalty(self) -> int:
+        """Get the score penalty for this severity level."""
+        penalties = {
+            VulnerabilitySeverity.CRITICAL: 25,
+            VulnerabilitySeverity.HIGH: 15,
+            VulnerabilitySeverity.MEDIUM: 8,
+            VulnerabilitySeverity.LOW: 3,
+        }
+        return penalties.get(self, 0)
+
+
+@dataclass
+class SecurityVulnerability:
+    """Represents a security vulnerability in a dependency."""
+
+    package: str
+    vulnerability_id: str
+    severity: VulnerabilitySeverity
+    description: str
+    fixed_in: str | None = None
+    url: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "package": self.package,
+            "vulnerability_id": self.vulnerability_id,
+            "severity": self.severity.value,
+            "description": self.description,
+            "fixed_in": self.fixed_in,
+            "url": self.url,
+        }
+
+
+@dataclass
+class DependencyHealth:
+    """Health information for a single dependency."""
+
+    name: str
+    current_version: str | None
+    latest_version: str | None
+    is_outdated: bool
+    major_versions_behind: int = 0
+    minor_versions_behind: int = 0
+    has_tier1_support: bool = False
+    has_tier2_support: bool = False
+    vulnerabilities: list[SecurityVulnerability] = field(default_factory=list)
+
+    @property
+    def version_lag_penalty(self) -> int:
+        """Calculate the penalty for version lag."""
+        # Major version lag: -15 points each
+        # Minor version lag: -5 points each (max 3)
+        major_penalty = self.major_versions_behind * 15
+        minor_penalty = min(self.minor_versions_behind, 3) * 5
+        return major_penalty + minor_penalty
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "current_version": self.current_version,
+            "latest_version": self.latest_version,
+            "is_outdated": self.is_outdated,
+            "major_versions_behind": self.major_versions_behind,
+            "minor_versions_behind": self.minor_versions_behind,
+            "has_tier1_support": self.has_tier1_support,
+            "has_tier2_support": self.has_tier2_support,
+            "vulnerabilities": [v.to_dict() for v in self.vulnerabilities],
+        }
+
+
+@dataclass
+class MetricResult:
+    """Result from a single metric calculation."""
+
+    category: MetricCategory
+    score: float  # 0-100
+    weight: float  # 0.0-1.0
+    description: str
+    details: dict[str, Any] = field(default_factory=dict)
+    recommendations: list[str] = field(default_factory=list)
+
+    @property
+    def weighted_score(self) -> float:
+        """Calculate the weighted score contribution."""
+        return self.score * self.weight
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "category": self.category.value,
+            "score": self.score,
+            "weight": self.weight,
+            "weighted_score": self.weighted_score,
+            "description": self.description,
+            "details": self.details,
+            "recommendations": self.recommendations,
+        }
+
+
+@dataclass
+class HealthScore:
+    """Complete health score for a project."""
+
+    overall_score: float  # 0-100
+    grade: HealthGrade
+    metrics: list[MetricResult] = field(default_factory=list)
+    dependencies: list[DependencyHealth] = field(default_factory=list)
+    vulnerabilities: list[SecurityVulnerability] = field(default_factory=list)
+    calculated_at: datetime = field(default_factory=datetime.now)
+    project_path: Path = field(default_factory=lambda: Path("."))
+
+    @property
+    def summary(self) -> str:
+        """Get a summary string of the health score."""
+        return f"{self.grade.emoji} Grade {self.grade.value} ({self.overall_score:.1f}/100)"
+
+    @property
+    def top_recommendations(self) -> list[str]:
+        """Get the top 5 recommendations across all metrics."""
+        all_recs: list[tuple[float, str]] = []
+        for metric in self.metrics:
+            # Weight recommendations by how much improvement they could provide
+            improvement_potential = 100 - metric.score
+            for rec in metric.recommendations:
+                all_recs.append((improvement_potential * metric.weight, rec))
+
+        # Sort by improvement potential and return top 5
+        all_recs.sort(key=lambda x: x[0], reverse=True)
+        seen: set[str] = set()
+        unique_recs: list[str] = []
+        for _, rec in all_recs:
+            if rec not in seen:
+                seen.add(rec)
+                unique_recs.append(rec)
+                if len(unique_recs) >= 5:
+                    break
+        return unique_recs
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "overall_score": self.overall_score,
+            "grade": self.grade.value,
+            "metrics": [m.to_dict() for m in self.metrics],
+            "dependencies": [d.to_dict() for d in self.dependencies],
+            "vulnerabilities": [v.to_dict() for v in self.vulnerabilities],
+            "calculated_at": self.calculated_at.isoformat(),
+            "project_path": str(self.project_path),
+            "recommendations": self.top_recommendations,
+        }
+
+
+@dataclass
+class HealthReport:
+    """Health report comparing current score to previous."""
+
+    current: HealthScore
+    previous: HealthScore | None = None
+
+    @property
+    def trend(self) -> str:
+        """Get the trend direction."""
+        if self.previous is None:
+            return "new"
+
+        diff = self.current.overall_score - self.previous.overall_score
+        if diff > 2:
+            return "improving"
+        elif diff < -2:
+            return "declining"
+        else:
+            return "stable"
+
+    @property
+    def trend_emoji(self) -> str:
+        """Get the trend emoji."""
+        emojis = {
+            "improving": "📈",
+            "declining": "📉",
+            "stable": "➡️",
+            "new": "🆕",
+        }
+        return emojis.get(self.trend, "")
+
+    @property
+    def score_delta(self) -> float | None:
+        """Get the score change from previous."""
+        if self.previous is None:
+            return None
+        return self.current.overall_score - self.previous.overall_score
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "current": self.current.to_dict(),
+            "previous": self.previous.to_dict() if self.previous else None,
+            "trend": self.trend,
+            "score_delta": self.score_delta,
+        }