codeshift 0.5.0__tar.gz → 0.7.0__tar.gz

{codeshift-0.5.0 → codeshift-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeshift
-Version: 0.5.0
+Version: 0.7.0
 Summary: AI-powered CLI tool that migrates Python code to handle breaking dependency changes
 Author: Ragab Technologies
 License: MIT

{codeshift-0.5.0 → codeshift-0.7.0}/codeshift/__init__.py

@@ -4,5 +4,5 @@ Codeshift - AI-powered CLI tool for migrating Python code to handle breaking dep
 Don't just flag the update. Fix the break.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.7.0"
 __author__ = "Codeshift Team"

codeshift-0.7.0/codeshift/cli/commands/health.py

@@ -0,0 +1,244 @@
+"""CLI command for codebase health scoring."""
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from codeshift.health.calculator import HealthCalculator
+from codeshift.health.models import HealthGrade, HealthScore, MetricCategory
+from codeshift.health.report import generate_json_report, save_html_report, save_json_report
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    default=".",
+    help="Path to the project (default: current directory)",
+)
+@click.option(
+    "--report",
+    "-r",
+    type=click.Choice(["json", "html"]),
+    help="Generate a detailed report in the specified format",
+)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(),
+    help="Output file path for the report (default: health_report.<format>)",
+)
+@click.option(
+    "--ci",
+    is_flag=True,
+    help="CI mode: exit with non-zero status if score is below threshold",
+)
+@click.option(
+    "--threshold",
+    type=int,
+    default=70,
+    help="Minimum score for CI mode (default: 70)",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show detailed output including all dependencies",
+)
+def health(
+    path: str,
+    report: str | None,
+    output: str | None,
+    ci: bool,
+    threshold: int,
+    verbose: bool,
+) -> None:
+    """Analyze codebase health and generate a score.
+
+    Evaluates your project across five dimensions:
+    - Dependency Freshness (30%): How up-to-date are your dependencies?
+    - Security (25%): Known vulnerabilities in dependencies
+    - Migration Readiness (20%): Tier 1/2 support coverage
+    - Test Coverage (15%): Percentage of code covered by tests
+    - Documentation (10%): Type hints and docstrings
+
+    \b
+    Examples:
+        codeshift health                     # Show health summary
+        codeshift health --report html       # Generate HTML report
+        codeshift health --report json -o report.json
+        codeshift health --ci --threshold 70 # CI mode
+
+    """
+    project_path = Path(path).resolve()
+
+    with console.status("[bold blue]Analyzing codebase health..."):
+        calculator = HealthCalculator()
+        score = calculator.calculate(project_path)
+
+    # Handle report generation
+    if report:
+        output_path = Path(output) if output else Path(f"health_report.{report}")
+
+        if report == "json":
+            save_json_report(score, output_path)
+            console.print(f"[green]JSON report saved to:[/] {output_path}")
+        elif report == "html":
+            save_html_report(score, output_path)
+            console.print(f"[green]HTML report saved to:[/] {output_path}")
+
+        # In CI mode with report, also output JSON to stdout
+        if ci:
+            console.print(generate_json_report(score))
+    else:
+        # Display rich table output
+        _display_health_summary(score, verbose)
+
+    # CI mode exit code handling
+    if ci:
+        if score.overall_score < threshold:
+            console.print(
+                f"\n[red]CI Check Failed:[/] Score {score.overall_score:.1f} is below threshold {threshold}"
+            )
+            sys.exit(1)
+        else:
+            console.print(
+                f"\n[green]CI Check Passed:[/] Score {score.overall_score:.1f} meets threshold {threshold}"
+            )
+            sys.exit(0)
+
+
+def _display_health_summary(score: HealthScore, verbose: bool) -> None:
+    """Display the health score summary in the terminal.
+
+    Args:
+        score: HealthScore object
+        verbose: Whether to show detailed output
+    """
+    # Grade panel
+    grade_style = _get_grade_style(score.grade)
+    console.print(
+        Panel(
+            f"[{grade_style}]Grade {score.grade.value}[/] - {score.overall_score:.1f}/100",
+            title="[bold]Codebase Health Score[/]",
+            subtitle=str(score.project_path),
+        )
+    )
+
+    # Metrics table
+    table = Table(title="Metrics Breakdown", show_header=True)
+    table.add_column("Category", style="cyan")
+    table.add_column("Score", justify="right")
+    table.add_column("Weight", justify="right", style="dim")
+    table.add_column("Details")
+
+    # Sort by score (lowest first) to highlight problem areas
+    sorted_metrics = sorted(score.metrics, key=lambda m: m.score)
+
+    for metric in sorted_metrics:
+        score_style = _get_score_style(metric.score)
+        weight_pct = f"{metric.weight * 100:.0f}%"
+        table.add_row(
+            _format_category(metric.category),
+            f"[{score_style}]{metric.score:.1f}[/]",
+            weight_pct,
+            metric.description,
+        )
+
+    console.print(table)
+
+    # Recommendations
+    if score.top_recommendations:
+        console.print("\n[bold]Top Recommendations:[/]")
+        for i, rec in enumerate(score.top_recommendations, 1):
+            console.print(f"  {i}. {rec}")
+
+    # Verbose: show dependencies
+    if verbose and score.dependencies:
+        console.print()
+        deps_table = Table(title="Dependencies", show_header=True)
+        deps_table.add_column("Package", style="cyan")
+        deps_table.add_column("Current")
+        deps_table.add_column("Latest")
+        deps_table.add_column("Status")
+        deps_table.add_column("Migration")
+        deps_table.add_column("Vulns", justify="right")
+
+        for dep in score.dependencies:
+            status = "[green]✓[/]" if not dep.is_outdated else "[yellow]↑[/]"
+            tier = (
+                "[green]Tier 1[/]"
+                if dep.has_tier1_support
+                else ("[cyan]Tier 2[/]" if dep.has_tier2_support else "[dim]-[/]")
+            )
+            vuln_count = len(dep.vulnerabilities)
+            vuln_style = "green" if vuln_count == 0 else "red"
+
+            deps_table.add_row(
+                dep.name,
+                dep.current_version or "?",
+                dep.latest_version or "?",
+                status,
+                tier,
+                f"[{vuln_style}]{vuln_count}[/]",
+            )
+
+        console.print(deps_table)
+
+    # Show vulnerabilities summary if any
+    if score.vulnerabilities:
+        console.print()
+        console.print(
+            f"[bold red]Security Alert:[/] {len(score.vulnerabilities)} vulnerabilities found"
+        )
+        for vuln in score.vulnerabilities[:3]:
+            console.print(
+                f"  - [{vuln.severity.value.upper()}] {vuln.package}: {vuln.vulnerability_id}"
+            )
+        if len(score.vulnerabilities) > 3:
+            console.print(f"  ... and {len(score.vulnerabilities) - 3} more")
+
+
+def _get_grade_style(grade: HealthGrade) -> str:
+    """Get Rich style for a grade."""
+    styles = {
+        HealthGrade.A: "bold green",
+        HealthGrade.B: "bold cyan",
+        HealthGrade.C: "bold yellow",
+        HealthGrade.D: "bold orange1",
+        HealthGrade.F: "bold red",
+    }
+    return styles.get(grade, "white")
+
+
+def _get_score_style(score: float) -> str:
+    """Get Rich style for a numeric score."""
+    if score >= 90:
+        return "green"
+    elif score >= 80:
+        return "cyan"
+    elif score >= 70:
+        return "yellow"
+    elif score >= 60:
+        return "orange1"
+    else:
+        return "red"
+
+
+def _format_category(category: MetricCategory) -> str:
+    """Format category for display."""
+    names = {
+        MetricCategory.FRESHNESS: "Freshness",
+        MetricCategory.SECURITY: "Security",
+        MetricCategory.MIGRATION_READINESS: "Migration Ready",
+        MetricCategory.TEST_COVERAGE: "Test Coverage",
+        MetricCategory.DOCUMENTATION: "Documentation",
+    }
+    return names.get(category, category.value)

{codeshift-0.5.0 → codeshift-0.7.0}/codeshift/cli/main.py

@@ -15,6 +15,7 @@ from codeshift.cli.commands.auth import (
     whoami,
 )
 from codeshift.cli.commands.diff import diff
+from codeshift.cli.commands.health import health
 from codeshift.cli.commands.scan import scan
 from codeshift.cli.commands.upgrade import upgrade
 from codeshift.cli.commands.upgrade_all import upgrade_all
@@ -46,6 +47,7 @@ cli.add_command(upgrade)
 cli.add_command(upgrade_all)
 cli.add_command(diff)
 cli.add_command(apply)
+cli.add_command(health)
 
 # Auth commands
 cli.add_command(register)

codeshift-0.7.0/codeshift/health/__init__.py

@@ -0,0 +1,50 @@
+"""Codebase health scoring module.
+
+This module provides health scoring capabilities for Python projects,
+analyzing dependency freshness, security, migration readiness, test
+coverage, and documentation quality.
+
+Example:
+    >>> from codeshift.health import HealthCalculator
+    >>> calculator = HealthCalculator()
+    >>> score = calculator.calculate(Path("."))
+    >>> print(score.summary)
+    🟢 Grade A (92.5/100)
+"""
+
+from codeshift.health.calculator import HealthCalculator
+from codeshift.health.models import (
+    DependencyHealth,
+    HealthGrade,
+    HealthReport,
+    HealthScore,
+    MetricCategory,
+    MetricResult,
+    SecurityVulnerability,
+    VulnerabilitySeverity,
+)
+from codeshift.health.report import (
+    generate_html_report,
+    generate_json_report,
+    save_html_report,
+    save_json_report,
+)
+
+__all__ = [
+    # Main calculator
+    "HealthCalculator",
+    # Models
+    "DependencyHealth",
+    "HealthGrade",
+    "HealthReport",
+    "HealthScore",
+    "MetricCategory",
+    "MetricResult",
+    "SecurityVulnerability",
+    "VulnerabilitySeverity",
+    # Report functions
+    "generate_html_report",
+    "generate_json_report",
+    "save_html_report",
+    "save_json_report",
+]

codeshift-0.7.0/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-0.7.0/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 [],
+        )