codeshift 0.2.0__py3-none-any.whl

codeshift/cli/commands/diff.py

@@ -0,0 +1,221 @@
+"""Diff command for viewing proposed changes."""
+
+import difflib
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from codeshift.cli.commands.upgrade import load_state
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(exists=True),
+    default=".",
+    help="Path to the project",
+)
+@click.option(
+    "--file",
+    "-f",
+    type=str,
+    help="Show diff for a specific file only",
+)
+@click.option(
+    "--no-color",
+    is_flag=True,
+    help="Disable colored output",
+)
+@click.option(
+    "--context",
+    "-c",
+    type=int,
+    default=3,
+    help="Number of context lines in diff (default: 3)",
+)
+@click.option(
+    "--summary",
+    is_flag=True,
+    help="Show only a summary of changes without full diff",
+)
+def diff(
+    path: str,
+    file: str | None,
+    no_color: bool,
+    context: int,
+    summary: bool,
+) -> None:
+    """View detailed diff of proposed changes.
+
+    \b
+    Examples:
+        codeshift diff
+        codeshift diff --file models.py
+        codeshift diff --summary
+    """
+    project_path = Path(path).resolve()
+    state = load_state(project_path)
+
+    if state is None:
+        console.print(
+            Panel(
+                "[yellow]No pending migration found.[/]\n\n"
+                "Run [cyan]codeshift upgrade <library> --target <version>[/] first.",
+                title="No Changes",
+            )
+        )
+        return
+
+    library = state.get("library", "unknown")
+    target_version = state.get("target_version", "unknown")
+    results = state.get("results", [])
+
+    if not results:
+        console.print("[yellow]No changes pending.[/]")
+        return
+
+    console.print(
+        Panel(
+            f"[bold]Migration: {library}[/] → v{target_version}\n"
+            f"Files: {len(results)} | Total changes: {sum(r.get('change_count', 0) for r in results)}",
+            title="Proposed Changes",
+        )
+    )
+
+    for result in results:
+        file_path = Path(result["file_path"])
+        relative_path = (
+            file_path.relative_to(project_path)
+            if file_path.is_relative_to(project_path)
+            else file_path
+        )
+
+        # Filter by file if specified
+        if file and str(relative_path) != file and file_path.name != file:
+            continue
+
+        original = result.get("original_code", "")
+        transformed = result.get("transformed_code", "")
+        changes = result.get("changes", [])
+        change_count = result.get("change_count", 0)
+
+        console.print(f"\n[bold cyan]{relative_path}[/] ({change_count} changes)")
+        console.print("─" * 60)
+
+        if summary:
+            # Just show change summaries
+            for change in changes:
+                console.print(f"  • {change['description']}")
+            continue
+
+        # Generate unified diff
+        original_lines = original.splitlines(keepends=True)
+        transformed_lines = transformed.splitlines(keepends=True)
+
+        diff_lines = list(
+            difflib.unified_diff(
+                original_lines,
+                transformed_lines,
+                fromfile=f"a/{relative_path}",
+                tofile=f"b/{relative_path}",
+                n=context,
+            )
+        )
+
+        if not diff_lines:
+            console.print("  [dim]No textual differences[/]")
+            continue
+
+        # Display diff with syntax highlighting
+        diff_text = "".join(diff_lines)
+
+        if no_color:
+            console.print(diff_text)
+        else:
+            # Color the diff manually for better visibility
+            for line in diff_lines:
+                if line.startswith("+++") or line.startswith("---"):
+                    console.print(f"[bold]{line.rstrip()}[/]")
+                elif line.startswith("@@"):
+                    console.print(f"[cyan]{line.rstrip()}[/]")
+                elif line.startswith("+"):
+                    console.print(f"[green]{line.rstrip()}[/]")
+                elif line.startswith("-"):
+                    console.print(f"[red]{line.rstrip()}[/]")
+                else:
+                    console.print(line.rstrip())
+
+        # Show change descriptions
+        console.print("\n[bold]Changes:[/]")
+        for change in changes:
+            console.print(f"  • {change['description']}")
+
+    # Show next steps
+    console.print("\n" + "─" * 60)
+    console.print("Next steps:")
+    console.print("  [cyan]codeshift apply[/]           - Apply all changes")
+    console.print("  [cyan]codeshift apply --file X[/]  - Apply changes to specific file")
+    console.print("  [cyan]codeshift apply --backup[/]  - Apply with backup files")
+
+
+@click.command(name="show")
+@click.argument("file_path", type=str)
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(exists=True),
+    default=".",
+    help="Path to the project",
+)
+@click.option(
+    "--original",
+    is_flag=True,
+    help="Show original code instead of transformed",
+)
+def show_file(file_path: str, path: str, original: bool) -> None:
+    """Show the full transformed (or original) code for a file.
+
+    \b
+    Examples:
+        codeshift show models.py
+        codeshift show models.py --original
+    """
+    project_path = Path(path).resolve()
+    state = load_state(project_path)
+
+    if state is None:
+        console.print("[yellow]No pending migration found.[/]")
+        return
+
+    results = state.get("results", [])
+
+    for result in results:
+        result_file = Path(result["file_path"])
+        relative_path = (
+            result_file.relative_to(project_path)
+            if result_file.is_relative_to(project_path)
+            else result_file
+        )
+
+        if str(relative_path) == file_path or result_file.name == file_path:
+            code = result.get("original_code" if original else "transformed_code", "")
+            label = "Original" if original else "Transformed"
+
+            console.print(
+                Panel(
+                    f"[bold]{label} code for {relative_path}[/]",
+                    title="File Content",
+                )
+            )
+
+            syntax = Syntax(code, "python", theme="monokai", line_numbers=True)
+            console.print(syntax)
+            return
+
+    console.print(f"[yellow]File not found in pending changes: {file_path}[/]")

codeshift/cli/commands/scan.py

@@ -0,0 +1,368 @@
+"""Scan command for discovering all possible migrations in a project."""
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+import click
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
+from rich.table import Table
+
+from codeshift.knowledge import (
+    generate_knowledge_base_sync,
+    is_tier_1_library,
+)
+from codeshift.scanner import DependencyParser
+from codeshift.utils.config import ProjectConfig
+
+console = Console()
+
+
+def get_latest_version(package: str) -> str | None:
+    """Fetch the latest version of a package from PyPI.
+
+    Args:
+        package: Package name.
+
+    Returns:
+        Latest version string or None.
+    """
+    try:
+        response = httpx.get(f"https://pypi.org/pypi/{package}/json", timeout=10.0)
+        if response.status_code == 200:
+            return cast(str | None, response.json().get("info", {}).get("version"))
+    except Exception:
+        pass
+    return None
+
+
+def parse_version(version_spec: str) -> str | None:
+    """Extract a version number from a version spec.
+
+    Args:
+        version_spec: Version specification (e.g., ">=1.0,<2.0").
+
+    Returns:
+        Extracted version or None.
+    """
+    import re
+
+    match = re.search(r"(\d+\.\d+(?:\.\d+)?)", version_spec)
+    if match:
+        return match.group(1)
+    return None
+
+
+def compare_versions(current: str, latest: str) -> bool:
+    """Check if latest version is newer than current.
+
+    Args:
+        current: Current version.
+        latest: Latest version.
+
+    Returns:
+        True if latest > current.
+    """
+    from packaging.version import Version
+
+    try:
+        return bool(Version(latest) > Version(current))
+    except Exception:
+        return False
+
+
+def is_major_upgrade(current: str, latest: str) -> bool:
+    """Check if this is a major version upgrade.
+
+    Args:
+        current: Current version.
+        latest: Latest version.
+
+    Returns:
+        True if major version changed.
+    """
+    try:
+        current_major = int(current.split(".")[0])
+        latest_major = int(latest.split(".")[0])
+        return latest_major > current_major
+    except Exception:
+        return False
+
+
+@click.command()
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(exists=True),
+    default=".",
+    help="Path to the project to scan",
+)
+@click.option(
+    "--fetch-changes",
+    is_flag=True,
+    help="Fetch changelogs and detect breaking changes (slower but more detailed)",
+)
+@click.option(
+    "--major-only",
+    is_flag=True,
+    help="Only show major version upgrades",
+)
+@click.option(
+    "--json-output",
+    is_flag=True,
+    help="Output results as JSON",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show detailed output",
+)
+def scan(
+    path: str,
+    fetch_changes: bool,
+    major_only: bool,
+    json_output: bool,
+    verbose: bool,
+) -> None:
+    """Scan your project for possible dependency migrations.
+
+    This command analyzes your project dependencies, checks for newer versions,
+    and suggests which libraries could be upgraded.
+
+    \b
+    Examples:
+        codeshift scan
+        codeshift scan --fetch-changes
+        codeshift scan --major-only
+        codeshift scan --json-output
+    """
+    project_path = Path(path).resolve()
+    # Load project config (currently unused, reserved for future use)
+    _ = ProjectConfig.from_pyproject(project_path)
+
+    if not json_output:
+        console.print(
+            Panel(
+                "[bold]Scanning project for possible migrations[/]\n\n" f"Path: {project_path}",
+                title="PyResolve Scan",
+            )
+        )
+
+    # Parse dependencies
+    dep_parser = DependencyParser(project_path)
+    dependencies = dep_parser.parse_all()
+
+    if not dependencies:
+        if not json_output:
+            console.print("[yellow]No dependencies found in project.[/]")
+        return
+
+    if not json_output:
+        console.print(f"\nFound [cyan]{len(dependencies)}[/] dependencies")
+
+    # Check for updates
+    outdated = []
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+        disable=json_output,
+    ) as progress:
+        task = progress.add_task("Checking for updates...", total=len(dependencies))
+
+        for dep in dependencies:
+            progress.update(task, description=f"Checking {dep.name}...")
+
+            current_version = parse_version(dep.version_spec) if dep.version_spec else None
+            latest_version = get_latest_version(dep.name)
+
+            if latest_version and current_version:
+                if compare_versions(current_version, latest_version):
+                    is_major = is_major_upgrade(current_version, latest_version)
+
+                    if major_only and not is_major:
+                        progress.advance(task)
+                        continue
+
+                    outdated.append(
+                        {
+                            "name": dep.name,
+                            "current": current_version,
+                            "latest": latest_version,
+                            "is_major": is_major,
+                            "is_tier1": is_tier_1_library(dep.name),
+                        }
+                    )
+
+            progress.advance(task)
+
+    if not outdated:
+        if not json_output:
+            console.print("\n[green]All dependencies are up to date![/]")
+        else:
+            print(json.dumps({"outdated": [], "migrations": []}))
+        return
+
+    # Fetch breaking changes if requested
+    migrations = []
+
+    if fetch_changes:
+        if not json_output:
+            console.print(
+                f"\n[bold]Fetching changelogs for {len(outdated)} outdated packages...[/]\n"
+            )
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+            disable=json_output,
+        ) as progress:
+            task = progress.add_task("Fetching changelogs...", total=len(outdated))
+
+            for pkg in outdated:
+                progress.update(task, description=f"Analyzing {pkg['name']}...")
+
+                try:
+                    kb = generate_knowledge_base_sync(
+                        package=str(pkg["name"]),
+                        old_version=str(pkg["current"]),
+                        new_version=str(pkg["latest"]),
+                    )
+
+                    pkg["breaking_changes"] = len(kb.breaking_changes)
+                    pkg["confidence"] = kb.overall_confidence.value
+                    pkg["changes"] = [
+                        {
+                            "old_api": c.old_api,
+                            "new_api": c.new_api,
+                            "description": c.description,
+                            "confidence": c.confidence.value,
+                        }
+                        for c in kb.breaking_changes[:5]  # Limit to 5 changes
+                    ]
+
+                    if kb.has_changes or pkg["is_tier1"]:
+                        migrations.append(pkg)
+
+                except Exception as e:
+                    if verbose and not json_output:
+                        console.print(f"  [dim]Could not fetch changelog for {pkg['name']}: {e}[/]")
+                    pkg["breaking_changes"] = None
+                    pkg["confidence"] = "unknown"
+
+                progress.advance(task)
+    else:
+        # Without fetch_changes, suggest all tier1 and major upgrades
+        for pkg in outdated:
+            if pkg["is_tier1"] or pkg["is_major"]:
+                migrations.append(pkg)
+
+    # Output results
+    if json_output:
+        print(
+            json.dumps(
+                {
+                    "outdated": outdated,
+                    "migrations": migrations,
+                },
+                indent=2,
+            )
+        )
+        return
+
+    # Display results
+    console.print(f"\n[bold]Outdated Dependencies ({len(outdated)})[/]\n")
+
+    table = Table()
+    table.add_column("Package", style="cyan")
+    table.add_column("Current", justify="right")
+    table.add_column("Latest", justify="right")
+    table.add_column("Type", justify="center")
+    table.add_column("Tier", justify="center")
+
+    if fetch_changes:
+        table.add_column("Breaking Changes", justify="right")
+        table.add_column("Confidence", justify="center")
+
+    for pkg in outdated:
+        type_str = "[red]Major[/]" if pkg["is_major"] else "[yellow]Minor/Patch[/]"
+        tier_str = "[green]Tier 1[/]" if pkg["is_tier1"] else "[dim]Tier 2/3[/]"
+
+        row = [
+            pkg["name"],
+            pkg["current"],
+            pkg["latest"],
+            type_str,
+            tier_str,
+        ]
+
+        if fetch_changes:
+            changes = pkg.get("breaking_changes")
+            if changes is not None:
+                row.append(str(changes))
+                confidence = str(pkg.get("confidence", "unknown"))
+                conf_style = {
+                    "high": "[green]HIGH[/]",
+                    "medium": "[yellow]MEDIUM[/]",
+                    "low": "[dim]LOW[/]",
+                }.get(confidence, "[dim]?[/]")
+                row.append(conf_style)
+            else:
+                row.append("[dim]?[/]")
+                row.append("[dim]?[/]")
+
+        table.add_row(*[str(item) for item in row])
+
+    console.print(table)
+
+    # Show suggested migrations
+    if migrations:
+        console.print(f"\n[bold]Suggested Migrations ({len(migrations)})[/]\n")
+
+        for pkg in migrations:
+            tier_label = (
+                "[green](Tier 1 - deterministic)[/]"
+                if pkg["is_tier1"]
+                else "[yellow](Tier 2/3 - LLM-assisted)[/]"
+            )
+            console.print(
+                f"  [cyan]{pkg['name']}[/] {pkg['current']} → {pkg['latest']} {tier_label}"
+            )
+
+            if fetch_changes and pkg.get("changes"):
+                console.print("    Breaking changes:")
+                changes_list = cast(list[dict[str, Any]], pkg["changes"])
+                for change in changes_list[:3]:
+                    if change["new_api"]:
+                        console.print(
+                            f"      [dim]├──[/] {change['old_api']} → {change['new_api']}"
+                        )
+                    else:
+                        console.print(f"      [dim]├──[/] {change['old_api']} [red](removed)[/]")
+                pkg_changes = cast(list[Any], pkg.get("changes", []))
+                if len(pkg_changes) > 3:
+                    console.print(f"      [dim]└── ... and {len(pkg_changes) - 3} more[/]")
+
+            console.print()
+
+        console.print("[bold]To migrate a package, run:[/]")
+        console.print("  [cyan]codeshift upgrade <package> --target <version>[/]\n")
+
+        # Show quick commands
+        console.print("[bold]Quick commands:[/]")
+        for pkg in migrations[:3]:
+            console.print(f"  [dim]codeshift upgrade {pkg['name']} --target {pkg['latest']}[/]")
+    else:
+        console.print(
+            "\n[dim]No migrations suggested. Use --fetch-changes for detailed analysis.[/]"
+        )