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

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

codeshift/health/metrics/migration_readiness.py

@@ -0,0 +1,142 @@
+"""Migration readiness metric calculator."""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from codeshift.health.metrics import BaseMetricCalculator
+from codeshift.health.models import DependencyHealth, MetricCategory, MetricResult
+from codeshift.knowledge_base import KnowledgeBaseLoader
+from codeshift.scanner.dependency_parser import DependencyParser
+
+logger = logging.getLogger(__name__)
+
+
+class MigrationReadinessCalculator(BaseMetricCalculator):
+    """Calculates migration readiness score (20% weight).
+
+    Score based on Tier 1/2 support coverage:
+    - Tier 1 (deterministic AST): 100% score contribution
+    - Tier 2 (knowledge base + LLM): 50% score contribution
+    - No support: 0% score contribution
+    """
+
+    @property
+    def category(self) -> MetricCategory:
+        return MetricCategory.MIGRATION_READINESS
+
+    @property
+    def weight(self) -> float:
+        return 0.20
+
+    def calculate(
+        self,
+        project_path: Path,
+        dependencies: list[DependencyHealth] | None = None,
+        **kwargs: Any,
+    ) -> MetricResult:
+        """Calculate the migration readiness score.
+
+        Args:
+            project_path: Path to the project
+            dependencies: Pre-populated dependency health list (optional)
+
+        Returns:
+            MetricResult with migration readiness 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=[],
+            )
+
+        tier1_count = sum(1 for d in dependencies if d.has_tier1_support)
+        tier2_count = sum(
+            1 for d in dependencies if d.has_tier2_support and not d.has_tier1_support
+        )
+        no_support_count = len(dependencies) - tier1_count - tier2_count
+
+        total = len(dependencies)
+        # Score: Tier 1 gets full points, Tier 2 gets half points
+        score = ((tier1_count * 100) + (tier2_count * 50)) / total if total > 0 else 100
+
+        # Build recommendations
+        recommendations: list[str] = []
+
+        if no_support_count > 0:
+            unsupported = [
+                d.name for d in dependencies if not d.has_tier1_support and not d.has_tier2_support
+            ]
+            recommendations.append(
+                f"Consider requesting Tier 1 support for: {', '.join(unsupported[:3])}"
+                + (f" (+{len(unsupported) - 3} more)" if len(unsupported) > 3 else "")
+            )
+
+        if tier2_count > 0:
+            tier2_deps = [
+                d.name for d in dependencies if d.has_tier2_support and not d.has_tier1_support
+            ]
+            recommendations.append(
+                f"Libraries with Tier 2 (LLM) support: {', '.join(tier2_deps[:3])}"
+            )
+
+        return self._create_result(
+            score=score,
+            description=f"{tier1_count} Tier 1, {tier2_count} Tier 2, {no_support_count} unsupported",
+            details={
+                "total_dependencies": total,
+                "tier1_count": tier1_count,
+                "tier2_count": tier2_count,
+                "unsupported_count": no_support_count,
+                "tier1_ratio": tier1_count / total if total > 0 else 0,
+                "tier2_ratio": tier2_count / total if total > 0 else 0,
+            },
+            recommendations=recommendations,
+        )
+
+    def _analyze_dependencies(self, project_path: Path) -> list[DependencyHealth]:
+        """Analyze project dependencies for migration support.
+
+        Args:
+            project_path: Path to the project
+
+        Returns:
+            List of DependencyHealth objects with tier support info
+        """
+        parser = DependencyParser(project_path)
+        dependencies = parser.parse_all()
+
+        loader = KnowledgeBaseLoader()
+        supported_libraries = loader.get_supported_libraries()
+
+        results: list[DependencyHealth] = []
+
+        # Tier 1 supported libraries (have AST transformers)
+        tier1_libraries = {"pydantic", "fastapi", "sqlalchemy", "pandas", "requests"}
+
+        for dep in dependencies:
+            dep_name_lower = dep.name.lower()
+
+            # Check Tier 1 support (deterministic AST transforms)
+            has_tier1 = dep_name_lower in tier1_libraries
+
+            # Check Tier 2 support (knowledge base exists)
+            has_tier2 = dep_name_lower in [lib.lower() for lib in supported_libraries]
+
+            results.append(
+                DependencyHealth(
+                    name=dep.name,
+                    current_version=str(dep.min_version) if dep.min_version else None,
+                    latest_version=None,
+                    is_outdated=False,
+                    has_tier1_support=has_tier1,
+                    has_tier2_support=has_tier2,
+                )
+            )
+
+        return results