codeshift 0.2.0__py3-none-any.whl

codeshift/cli/main.py

@@ -0,0 +1,221 @@
+"""Main CLI entry point for PyResolve."""
+
+import click
+from rich.console import Console
+
+from codeshift import __version__
+from codeshift.cli.commands.apply import apply
+from codeshift.cli.commands.auth import (
+    billing,
+    login,
+    logout,
+    quota,
+    register,
+    upgrade_plan,
+    whoami,
+)
+from codeshift.cli.commands.diff import diff
+from codeshift.cli.commands.scan import scan
+from codeshift.cli.commands.upgrade import upgrade
+from codeshift.cli.commands.upgrade_all import upgrade_all
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="codeshift")
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """PyResolve - AI-powered Python dependency migration tool.
+
+    Don't just flag the update. Fix the break.
+
+    \b
+    Examples:
+        codeshift upgrade pydantic --target 2.5.0
+        codeshift diff
+        codeshift apply
+    """
+    # Ensure context object exists
+    ctx.ensure_object(dict)
+
+
+# Register commands
+cli.add_command(scan)
+cli.add_command(upgrade)
+cli.add_command(upgrade_all)
+cli.add_command(diff)
+cli.add_command(apply)
+
+# Auth commands
+cli.add_command(register)
+cli.add_command(login)
+cli.add_command(logout)
+cli.add_command(whoami)
+cli.add_command(quota)
+cli.add_command(upgrade_plan)
+cli.add_command(billing)
+
+
+@cli.command()
+def libraries() -> None:
+    """List supported libraries and their migration paths."""
+    from rich.table import Table
+
+    from codeshift.knowledge_base import KnowledgeBaseLoader
+
+    loader = KnowledgeBaseLoader()
+    supported = loader.get_supported_libraries()
+
+    table = Table(title="Supported Libraries")
+    table.add_column("Library", style="cyan")
+    table.add_column("Migration Path", style="green")
+    table.add_column("Description", style="dim")
+
+    for lib_name in supported:
+        try:
+            knowledge = loader.load(lib_name)
+            for from_v, to_v in knowledge.supported_migrations:
+                table.add_row(
+                    knowledge.display_name,
+                    f"v{from_v} → v{to_v}",
+                    (
+                        knowledge.description[:50] + "..."
+                        if len(knowledge.description) > 50
+                        else knowledge.description
+                    ),
+                )
+        except Exception:
+            continue
+
+    console.print(table)
+
+
+@cli.command()
+@click.option("--path", "-p", type=click.Path(exists=True), default=".", help="Project path")
+def status(path: str) -> None:
+    """Show current migration status, pending changes, and quota info."""
+    from pathlib import Path
+
+    import httpx
+    from rich.panel import Panel
+    from rich.table import Table
+
+    from codeshift.cli.commands.auth import get_api_key, get_api_url, load_credentials
+    from codeshift.cli.commands.upgrade import load_state
+
+    project_path = Path(path).resolve()
+    state = load_state(project_path)
+
+    # Show migration status
+    if state is None:
+        console.print(
+            Panel(
+                "[yellow]No pending migration found.[/]\n\n"
+                "Run [cyan]codeshift upgrade <library> --target <version>[/] to start a migration.",
+                title="Migration Status",
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                f"[green]Migration in progress[/]\n\n"
+                f"Library: [cyan]{state.get('library', 'unknown')}[/]\n"
+                f"Target version: [cyan]{state.get('target_version', 'unknown')}[/]\n"
+                f"Files to modify: [cyan]{len(state.get('results', []))}[/]\n"
+                f"Total changes: [cyan]{sum(r.get('change_count', 0) for r in state.get('results', []))}[/]\n\n"
+                "Use [cyan]codeshift diff[/] to view changes\n"
+                "Use [cyan]codeshift apply[/] to apply changes",
+                title="Migration Status",
+            )
+        )
+
+    # Show authentication and quota status
+    console.print()
+
+    creds = load_credentials()
+    api_key = get_api_key()
+
+    if not creds and not api_key:
+        console.print(
+            Panel(
+                "[yellow]Not logged in[/]\n\n"
+                "Run [cyan]codeshift login[/] to authenticate and unlock cloud features.\n"
+                "[dim]Free tier: 100 files/month, 50 LLM calls/month[/]",
+                title="Account Status",
+            )
+        )
+        return
+
+    # Try to fetch quota from API
+    try:
+        api_url = get_api_url()
+        headers: dict[str, str] = {}
+        if api_key:
+            headers["X-API-Key"] = api_key
+        response = httpx.get(
+            f"{api_url}/usage/quota",
+            headers=headers,
+            timeout=10,
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+
+            # Build quota table
+            table = Table(show_header=False, box=None)
+            table.add_column("Label", style="dim")
+            table.add_column("Value")
+
+            table.add_row("Tier", f"[cyan]{data['tier'].title()}[/]")
+            table.add_row("Billing Period", data["billing_period"])
+            table.add_row(
+                "File Migrations",
+                f"{data['files_migrated']}/{data['files_limit']} ({data['files_remaining']} remaining)",
+            )
+            table.add_row(
+                "LLM Calls",
+                f"{data['llm_calls']}/{data['llm_calls_limit']} ({data['llm_calls_remaining']} remaining)",
+            )
+
+            email_display = creds.get("email", "Authenticated") if creds else "Authenticated"
+            console.print(
+                Panel(
+                    table,
+                    title=f"Account Status - {email_display}",
+                )
+            )
+
+            # Show warning if near limit
+            if data["files_percentage"] > 80 or data["llm_calls_percentage"] > 80:
+                console.print(
+                    "[yellow]Running low on quota![/] "
+                    "Run [cyan]codeshift upgrade-plan[/] to see upgrade options."
+                )
+        else:
+            # Fall back to cached info
+            cached_email = creds.get("email", "unknown") if creds else "unknown"
+            cached_tier = creds.get("tier", "free") if creds else "free"
+            console.print(
+                Panel(
+                    f"[green]Logged in[/] [dim](offline)[/]\n"
+                    f"Email: [cyan]{cached_email}[/]\n"
+                    f"Tier: [cyan]{cached_tier}[/]",
+                    title="Account Status",
+                )
+            )
+    except httpx.RequestError:
+        # Offline - show cached info
+        if creds:
+            console.print(
+                Panel(
+                    f"[green]Logged in[/] [dim](offline)[/]\n"
+                    f"Email: [cyan]{creds.get('email', 'unknown')}[/]\n"
+                    f"Tier: [cyan]{creds.get('tier', 'free')}[/]",
+                    title="Account Status",
+                )
+            )
+
+
+if __name__ == "__main__":
+    cli()

codeshift/cli/quota.py

@@ -0,0 +1,210 @@
+"""Quota checking and usage logging utilities for CLI commands."""
+
+from typing import cast
+
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+
+from codeshift.cli.commands.auth import get_api_key, get_api_url, load_credentials
+
+console = Console()
+
+
+class QuotaError(Exception):
+    """Exception raised when quota is exceeded."""
+
+    def __init__(self, message: str, current: int, limit: int, remaining: int):
+        super().__init__(message)
+        self.current = current
+        self.limit = limit
+        self.remaining = remaining
+
+
+def check_quota(
+    event_type: str,
+    quantity: int = 1,
+    allow_offline: bool = True,
+) -> bool:
+    """Check if the user has quota for an operation.
+
+    Args:
+        event_type: Type of event ('file_migrated', 'llm_call', 'scan', 'apply')
+        quantity: Number of events to check
+        allow_offline: If True, allow operation when offline (default True)
+
+    Returns:
+        True if operation is allowed, raises QuotaError otherwise
+
+    Raises:
+        QuotaError: If quota would be exceeded
+    """
+    api_key = get_api_key()
+
+    # If no API key, use default free tier limits (offline mode)
+    if not api_key:
+        if allow_offline:
+            # No quota enforcement without authentication
+            return True
+        else:
+            console.print(
+                Panel(
+                    "[yellow]Authentication required for this operation.[/]\n\n"
+                    "Run [cyan]codeshift login[/] to authenticate.",
+                    title="Authentication Required",
+                )
+            )
+            raise SystemExit(1)
+
+    try:
+        api_url = get_api_url()
+        response = httpx.post(
+            f"{api_url}/usage/check",
+            headers={"X-API-Key": api_key},
+            json={"event_type": event_type, "quantity": quantity},
+            timeout=10,
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+
+            if not data["allowed"]:
+                raise QuotaError(
+                    data.get("message", "Quota exceeded"),
+                    data["current_usage"],
+                    data["limit"],
+                    data["remaining"],
+                )
+
+            return True
+
+        elif response.status_code == 401:
+            # Invalid credentials
+            console.print(
+                "[yellow]Invalid credentials. Run [cyan]codeshift login[/] to re-authenticate.[/]"
+            )
+            if allow_offline:
+                return True
+            raise SystemExit(1)
+
+        else:
+            # API error, allow operation in offline mode
+            if allow_offline:
+                return True
+            raise SystemExit(1)
+
+    except httpx.RequestError:
+        # Network error, allow operation in offline mode
+        if allow_offline:
+            return True
+        console.print("[yellow]Cannot connect to API. Working in offline mode.[/]")
+        return True
+
+
+def record_usage(
+    event_type: str,
+    library: str | None = None,
+    quantity: int = 1,
+    metadata: dict | None = None,
+) -> bool:
+    """Record a usage event after an operation completes.
+
+    Args:
+        event_type: Type of event ('file_migrated', 'llm_call', 'scan', 'apply')
+        library: Library being migrated (optional)
+        quantity: Number of events
+        metadata: Additional metadata (optional)
+
+    Returns:
+        True if recording succeeded, False otherwise
+    """
+    api_key = get_api_key()
+
+    if not api_key:
+        # Can't record without authentication
+        return False
+
+    try:
+        api_url = get_api_url()
+        response = httpx.post(
+            f"{api_url}/usage/",
+            headers={"X-API-Key": api_key},
+            json={
+                "event_type": event_type,
+                "library": library,
+                "quantity": quantity,
+                "metadata": metadata or {},
+            },
+            timeout=10,
+        )
+
+        return bool(response.status_code == 200)
+
+    except httpx.RequestError:
+        # Network error, don't fail the operation
+        return False
+
+
+def show_quota_exceeded_message(error: QuotaError) -> None:
+    """Display a helpful message when quota is exceeded."""
+    creds = load_credentials()
+    tier = creds.get("tier", "free") if creds else "free"
+
+    console.print(
+        Panel(
+            f"[red]Quota exceeded![/]\n\n"
+            f"You have used [cyan]{error.current}[/] of your [cyan]{error.limit}[/] "
+            f"monthly allowance.\n\n"
+            f"Current tier: [cyan]{tier.title()}[/]\n\n"
+            "Options:\n"
+            "  • Upgrade your plan: [cyan]codeshift upgrade-plan[/]\n"
+            "  • Wait until next billing period\n"
+            "  • Contact support for enterprise options",
+            title="Quota Exceeded",
+        )
+    )
+
+
+def get_remaining_quota(event_type: str) -> int | None:
+    """Get remaining quota for an event type.
+
+    Returns:
+        Number of remaining events, or None if offline/unauthenticated
+    """
+    api_key = get_api_key()
+
+    if not api_key:
+        return None
+
+    try:
+        api_url = get_api_url()
+        response = httpx.get(
+            f"{api_url}/usage/quota",
+            headers={"X-API-Key": api_key},
+            timeout=10,
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+
+            if event_type == "file_migrated":
+                return cast(int, data.get("files_remaining", 0))
+            elif event_type == "llm_call":
+                return cast(int, data.get("llm_calls_remaining", 0))
+            else:
+                return None
+
+    except httpx.RequestError:
+        pass
+
+    return None
+
+
+def is_tier1_migration(library: str) -> bool:
+    """Check if this is a Tier 1 (free) migration.
+
+    Tier 1 libraries have AST-based transforms and don't require LLM calls.
+    """
+    from codeshift.knowledge import is_tier_1_library
+
+    return is_tier_1_library(library)

codeshift/knowledge/__init__.py

@@ -0,0 +1,50 @@
+"""Knowledge acquisition pipeline for auto-generated knowledge bases."""
+
+from codeshift.knowledge.cache import KnowledgeCache, get_knowledge_cache
+from codeshift.knowledge.generator import (
+    TIER_1_LIBRARIES,
+    KnowledgeGenerator,
+    generate_knowledge_base,
+    generate_knowledge_base_sync,
+    get_knowledge_generator,
+    is_tier_1_library,
+)
+from codeshift.knowledge.models import (
+    BreakingChange,
+    ChangeCategory,
+    ChangelogSource,
+    Confidence,
+    GeneratedKnowledgeBase,
+)
+from codeshift.knowledge.parser import ChangelogParser, get_changelog_parser
+from codeshift.knowledge.sources import (
+    PackageInfo,
+    SourceFetcher,
+    get_source_fetcher,
+)
+
+__all__ = [
+    # Models
+    "BreakingChange",
+    "ChangeCategory",
+    "ChangelogSource",
+    "Confidence",
+    "GeneratedKnowledgeBase",
+    # Sources
+    "PackageInfo",
+    "SourceFetcher",
+    "get_source_fetcher",
+    # Parser
+    "ChangelogParser",
+    "get_changelog_parser",
+    # Cache
+    "KnowledgeCache",
+    "get_knowledge_cache",
+    # Generator
+    "KnowledgeGenerator",
+    "generate_knowledge_base",
+    "generate_knowledge_base_sync",
+    "get_knowledge_generator",
+    "is_tier_1_library",
+    "TIER_1_LIBRARIES",
+]

codeshift/knowledge/cache.py

@@ -0,0 +1,167 @@
+"""Cache for generated knowledge bases."""
+
+import json
+import time
+from pathlib import Path
+
+from codeshift.knowledge.models import GeneratedKnowledgeBase
+
+
+class KnowledgeCache:
+    """Cache for storing generated knowledge bases."""
+
+    DEFAULT_TTL = 86400 * 7  # 7 days
+
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        ttl: int = DEFAULT_TTL,
+    ):
+        """Initialize the cache.
+
+        Args:
+            cache_dir: Directory to store cache files.
+            ttl: Time-to-live in seconds.
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".codeshift" / "cache" / "knowledge"
+        self.cache_dir = cache_dir
+        self.ttl = ttl
+
+    def _ensure_dir(self) -> None:
+        """Ensure cache directory exists."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_cache_key(self, package: str, old_version: str, new_version: str) -> str:
+        """Generate cache key for a knowledge base."""
+        return f"{package}_{old_version}_to_{new_version}".replace(".", "_")
+
+    def _get_cache_path(self, key: str) -> Path:
+        """Get file path for a cache key."""
+        return self.cache_dir / f"{key}.json"
+
+    def get(
+        self,
+        package: str,
+        old_version: str,
+        new_version: str,
+    ) -> GeneratedKnowledgeBase | None:
+        """Get a cached knowledge base.
+
+        Args:
+            package: Package name.
+            old_version: Starting version.
+            new_version: Target version.
+
+        Returns:
+            Cached GeneratedKnowledgeBase or None if not found/expired.
+        """
+        key = self._get_cache_key(package, old_version, new_version)
+        cache_path = self._get_cache_path(key)
+
+        if not cache_path.exists():
+            return None
+
+        try:
+            data = json.loads(cache_path.read_text())
+
+            # Check expiration
+            created_at = data.get("_created_at", 0)
+            if time.time() - created_at > self.ttl:
+                cache_path.unlink()
+                return None
+
+            return GeneratedKnowledgeBase.from_dict(data["knowledge_base"])
+
+        except (json.JSONDecodeError, KeyError):
+            # Invalid cache, remove it
+            cache_path.unlink(missing_ok=True)
+            return None
+
+    def set(self, kb: GeneratedKnowledgeBase) -> None:
+        """Store a knowledge base in cache.
+
+        Args:
+            kb: GeneratedKnowledgeBase to cache.
+        """
+        self._ensure_dir()
+
+        key = self._get_cache_key(kb.package, kb.old_version, kb.new_version)
+        cache_path = self._get_cache_path(key)
+
+        data = {
+            "_created_at": time.time(),
+            "knowledge_base": kb.to_dict(),
+        }
+
+        cache_path.write_text(json.dumps(data, indent=2))
+
+    def delete(self, package: str, old_version: str, new_version: str) -> bool:
+        """Delete a cached knowledge base.
+
+        Args:
+            package: Package name.
+            old_version: Starting version.
+            new_version: Target version.
+
+        Returns:
+            True if deleted, False if not found.
+        """
+        key = self._get_cache_key(package, old_version, new_version)
+        cache_path = self._get_cache_path(key)
+
+        if cache_path.exists():
+            cache_path.unlink()
+            return True
+        return False
+
+    def clear(self) -> int:
+        """Clear all cached knowledge bases.
+
+        Returns:
+            Number of entries cleared.
+        """
+        count = 0
+        if self.cache_dir.exists():
+            for cache_file in self.cache_dir.glob("*.json"):
+                cache_file.unlink()
+                count += 1
+        return count
+
+    def list_cached(self) -> list[tuple[str, str, str]]:
+        """List all cached knowledge bases.
+
+        Returns:
+            List of (package, old_version, new_version) tuples.
+        """
+        cached: list[tuple[str, str, str]] = []
+        if not self.cache_dir.exists():
+            return cached
+
+        for cache_file in self.cache_dir.glob("*.json"):
+            try:
+                data = json.loads(cache_file.read_text())
+                kb_data = data.get("knowledge_base", {})
+                cached.append(
+                    (
+                        kb_data.get("package", ""),
+                        kb_data.get("old_version", ""),
+                        kb_data.get("new_version", ""),
+                    )
+                )
+            except Exception:
+                continue
+
+        return cached
+
+
+# Singleton instance
+_default_cache: KnowledgeCache | None = None
+
+
+def get_knowledge_cache() -> KnowledgeCache:
+    """Get the default knowledge cache instance."""
+    global _default_cache
+    if _default_cache is None:
+        _default_cache = KnowledgeCache()
+    return _default_cache