codeshift 0.2.0__py3-none-any.whl

codeshift/utils/api_client.py

@@ -0,0 +1,266 @@
+"""PyResolve API client for LLM-powered migrations.
+
+This client calls the PyResolve API instead of Anthropic directly,
+ensuring that LLM features are gated behind the subscription model.
+"""
+
+from dataclasses import dataclass
+
+import httpx
+
+from codeshift.cli.commands.auth import get_api_key, get_api_url
+
+
+@dataclass
+class APIResponse:
+    """Response from the PyResolve API."""
+
+    success: bool
+    content: str
+    error: str | None = None
+    usage: dict | None = None
+    cached: bool = False
+
+
+class PyResolveAPIClient:
+    """Client for interacting with the PyResolve API for LLM migrations.
+
+    This client routes all LLM calls through the PyResolve API,
+    which handles:
+    - Authentication and authorization
+    - Quota checking and billing
+    - Server-side Anthropic API calls
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        api_url: str | None = None,
+        timeout: int = 60,
+    ):
+        """Initialize the API client.
+
+        Args:
+            api_key: PyResolve API key. Defaults to stored credentials.
+            api_url: API base URL. Defaults to stored URL.
+            timeout: Request timeout in seconds.
+        """
+        self.api_key = api_key or get_api_key()
+        self.api_url = api_url or get_api_url()
+        self.timeout = timeout
+
+    @property
+    def is_available(self) -> bool:
+        """Check if the API client is available (has API key)."""
+        return bool(self.api_key)
+
+    def _make_request(
+        self,
+        endpoint: str,
+        payload: dict,
+    ) -> httpx.Response:
+        """Make a request to the API.
+
+        Args:
+            endpoint: API endpoint (e.g., '/migrate/code')
+            payload: Request payload
+
+        Returns:
+            HTTP response
+
+        Raises:
+            httpx.RequestError: On network errors
+        """
+        if not self.api_key:
+            raise ValueError("API key not configured. Run 'codeshift login' to authenticate.")
+
+        return httpx.post(
+            f"{self.api_url}{endpoint}",
+            headers={"X-API-Key": self.api_key},
+            json=payload,
+            timeout=self.timeout,
+        )
+
+    def migrate_code(
+        self,
+        code: str,
+        library: str,
+        from_version: str,
+        to_version: str,
+        context: str | None = None,
+    ) -> APIResponse:
+        """Migrate code using the PyResolve API.
+
+        Args:
+            code: Source code to migrate
+            library: Library being upgraded
+            from_version: Current version
+            to_version: Target version
+            context: Optional context about the migration
+
+        Returns:
+            APIResponse with the migrated code
+        """
+        if not self.is_available:
+            return APIResponse(
+                success=False,
+                content=code,
+                error="Not authenticated. Run 'codeshift login' to use LLM migrations.",
+            )
+
+        try:
+            response = self._make_request(
+                "/migrate/code",
+                {
+                    "code": code,
+                    "library": library,
+                    "from_version": from_version,
+                    "to_version": to_version,
+                    "context": context,
+                },
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                return APIResponse(
+                    success=data.get("success", False),
+                    content=data.get("migrated_code", code),
+                    error=data.get("error"),
+                    usage=data.get("usage"),
+                    cached=data.get("cached", False),
+                )
+
+            elif response.status_code == 401:
+                return APIResponse(
+                    success=False,
+                    content=code,
+                    error="Authentication failed. Run 'codeshift login' to re-authenticate.",
+                )
+
+            elif response.status_code == 402:
+                data = response.json()
+                detail = data.get("detail", {})
+                return APIResponse(
+                    success=False,
+                    content=code,
+                    error=(
+                        f"LLM quota exceeded. Current usage: {detail.get('current_usage', '?')}, "
+                        f"Limit: {detail.get('limit', '?')}. "
+                        f"Upgrade at {detail.get('upgrade_url', 'https://codeshift.dev/pricing')}"
+                    ),
+                )
+
+            elif response.status_code == 403:
+                return APIResponse(
+                    success=False,
+                    content=code,
+                    error="LLM migrations require Pro tier or higher. Run 'codeshift upgrade-plan' to upgrade.",
+                )
+
+            elif response.status_code == 503:
+                return APIResponse(
+                    success=False,
+                    content=code,
+                    error="LLM service temporarily unavailable. Please try again later.",
+                )
+
+            else:
+                return APIResponse(
+                    success=False,
+                    content=code,
+                    error=f"API error: {response.status_code}",
+                )
+
+        except httpx.RequestError as e:
+            return APIResponse(
+                success=False,
+                content=code,
+                error=f"Network error: {str(e)}",
+            )
+
+    def explain_change(
+        self,
+        original: str,
+        transformed: str,
+        library: str,
+    ) -> APIResponse:
+        """Get an explanation of a migration change.
+
+        Args:
+            original: Original code
+            transformed: Transformed code
+            library: Library being upgraded
+
+        Returns:
+            APIResponse with the explanation
+        """
+        if not self.is_available:
+            return APIResponse(
+                success=False,
+                content="",
+                error="Not authenticated. Run 'codeshift login' to use this feature.",
+            )
+
+        try:
+            response = self._make_request(
+                "/migrate/explain",
+                {
+                    "original_code": original,
+                    "transformed_code": transformed,
+                    "library": library,
+                },
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                return APIResponse(
+                    success=data.get("success", False),
+                    content=data.get("explanation", ""),
+                    error=data.get("error"),
+                )
+
+            elif response.status_code == 402:
+                return APIResponse(
+                    success=False,
+                    content="",
+                    error="LLM quota exceeded. Upgrade your plan to continue.",
+                )
+
+            elif response.status_code == 403:
+                return APIResponse(
+                    success=False,
+                    content="",
+                    error="This feature requires Pro tier or higher.",
+                )
+
+            else:
+                return APIResponse(
+                    success=False,
+                    content="",
+                    error=f"API error: {response.status_code}",
+                )
+
+        except httpx.RequestError as e:
+            return APIResponse(
+                success=False,
+                content="",
+                error=f"Network error: {str(e)}",
+            )
+
+
+# Singleton instance
+_default_client: PyResolveAPIClient | None = None
+
+
+def get_api_client() -> PyResolveAPIClient:
+    """Get the default API client instance."""
+    global _default_client
+    if _default_client is None:
+        _default_client = PyResolveAPIClient()
+    return _default_client
+
+
+def reset_api_client() -> None:
+    """Reset the API client (useful after login/logout)."""
+    global _default_client
+    _default_client = None

codeshift/utils/cache.py

@@ -0,0 +1,318 @@
+"""Cache for LLM responses and expensive operations."""
+
+import hashlib
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class CacheEntry:
+    """A cached entry with metadata."""
+
+    key: str
+    value: Any
+    created_at: float
+    expires_at: float | None = None
+    hits: int = 0
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if the entry has expired."""
+        if self.expires_at is None:
+            return False
+        return time.time() > self.expires_at
+
+
+class Cache:
+    """Simple file-based cache for PyResolve."""
+
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        default_ttl: int | None = None,
+    ):
+        """Initialize the cache.
+
+        Args:
+            cache_dir: Directory to store cache files.
+                      Defaults to ~/.codeshift/cache
+            default_ttl: Default time-to-live in seconds. None means no expiration.
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".codeshift" / "cache"
+        self.cache_dir = cache_dir
+        self.default_ttl = default_ttl
+        self._memory_cache: dict[str, CacheEntry] = {}
+
+    def _ensure_dir(self) -> None:
+        """Ensure the cache directory exists."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _make_key(self, *args: Any) -> str:
+        """Create a cache key from arguments."""
+        key_data = json.dumps(args, sort_keys=True, default=str)
+        return hashlib.sha256(key_data.encode()).hexdigest()[:16]
+
+    def _get_cache_path(self, key: str) -> Path:
+        """Get the file path for a cache key."""
+        return self.cache_dir / f"{key}.json"
+
+    def get(self, key: str) -> Any | None:
+        """Get a value from the cache.
+
+        Args:
+            key: The cache key
+
+        Returns:
+            The cached value or None if not found/expired
+        """
+        # Check memory cache first
+        if key in self._memory_cache:
+            entry = self._memory_cache[key]
+            if not entry.is_expired:
+                entry.hits += 1
+                return entry.value
+            else:
+                del self._memory_cache[key]
+
+        # Check file cache
+        cache_path = self._get_cache_path(key)
+        if cache_path.exists():
+            try:
+                data = json.loads(cache_path.read_text())
+                entry = CacheEntry(
+                    key=data["key"],
+                    value=data["value"],
+                    created_at=data["created_at"],
+                    expires_at=data.get("expires_at"),
+                    hits=data.get("hits", 0),
+                )
+
+                if entry.is_expired:
+                    cache_path.unlink()
+                    return None
+
+                # Store in memory cache
+                entry.hits += 1
+                self._memory_cache[key] = entry
+
+                # Update file with new hit count
+                data["hits"] = entry.hits
+                cache_path.write_text(json.dumps(data))
+
+                return entry.value
+
+            except (json.JSONDecodeError, KeyError):
+                # Invalid cache file, remove it
+                cache_path.unlink()
+
+        return None
+
+    def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        """Set a value in the cache.
+
+        Args:
+            key: The cache key
+            value: The value to cache
+            ttl: Time-to-live in seconds. None uses default, 0 means no expiration.
+        """
+        self._ensure_dir()
+
+        if ttl is None:
+            ttl = self.default_ttl
+
+        now = time.time()
+        expires_at = now + ttl if ttl else None
+
+        entry = CacheEntry(
+            key=key,
+            value=value,
+            created_at=now,
+            expires_at=expires_at,
+            hits=0,
+        )
+
+        # Store in memory
+        self._memory_cache[key] = entry
+
+        # Store in file
+        cache_path = self._get_cache_path(key)
+        cache_path.write_text(
+            json.dumps(
+                {
+                    "key": entry.key,
+                    "value": entry.value,
+                    "created_at": entry.created_at,
+                    "expires_at": entry.expires_at,
+                    "hits": entry.hits,
+                }
+            )
+        )
+
+    def delete(self, key: str) -> bool:
+        """Delete a value from the cache.
+
+        Args:
+            key: The cache key
+
+        Returns:
+            True if the key was found and deleted
+        """
+        found = False
+
+        if key in self._memory_cache:
+            del self._memory_cache[key]
+            found = True
+
+        cache_path = self._get_cache_path(key)
+        if cache_path.exists():
+            cache_path.unlink()
+            found = True
+
+        return found
+
+    def clear(self) -> int:
+        """Clear all cached entries.
+
+        Returns:
+            Number of entries cleared
+        """
+        count = len(self._memory_cache)
+        self._memory_cache.clear()
+
+        if self.cache_dir.exists():
+            for cache_file in self.cache_dir.glob("*.json"):
+                cache_file.unlink()
+                count += 1
+
+        return count
+
+    def cleanup_expired(self) -> int:
+        """Remove all expired entries.
+
+        Returns:
+            Number of entries removed
+        """
+        count = 0
+
+        # Clean memory cache
+        expired_keys = [k for k, v in self._memory_cache.items() if v.is_expired]
+        for key in expired_keys:
+            del self._memory_cache[key]
+            count += 1
+
+        # Clean file cache
+        if self.cache_dir.exists():
+            for cache_file in self.cache_dir.glob("*.json"):
+                try:
+                    data = json.loads(cache_file.read_text())
+                    expires_at = data.get("expires_at")
+                    if expires_at and time.time() > expires_at:
+                        cache_file.unlink()
+                        count += 1
+                except (json.JSONDecodeError, KeyError):
+                    cache_file.unlink()
+                    count += 1
+
+        return count
+
+    def stats(self) -> dict:
+        """Get cache statistics.
+
+        Returns:
+            Dictionary with cache stats
+        """
+        memory_entries = len(self._memory_cache)
+        file_entries = len(list(self.cache_dir.glob("*.json"))) if self.cache_dir.exists() else 0
+        total_hits = sum(e.hits for e in self._memory_cache.values())
+
+        return {
+            "memory_entries": memory_entries,
+            "file_entries": file_entries,
+            "total_hits": total_hits,
+            "cache_dir": str(self.cache_dir),
+        }
+
+
+class LLMCache(Cache):
+    """Specialized cache for LLM responses."""
+
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        default_ttl: int = 86400 * 7,  # 7 days default
+    ):
+        """Initialize the LLM cache.
+
+        Args:
+            cache_dir: Directory to store cache files
+            default_ttl: Default TTL in seconds (default: 7 days)
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".codeshift" / "cache" / "llm"
+        super().__init__(cache_dir, default_ttl)
+
+    def get_migration(
+        self,
+        code: str,
+        library: str,
+        from_version: str,
+        to_version: str,
+    ) -> str | None:
+        """Get a cached migration result.
+
+        Args:
+            code: The source code
+            library: Library name
+            from_version: Source version
+            to_version: Target version
+
+        Returns:
+            Cached migrated code or None
+        """
+        key = self._make_key("migrate", code, library, from_version, to_version)
+        return self.get(key)
+
+    def set_migration(
+        self,
+        code: str,
+        library: str,
+        from_version: str,
+        to_version: str,
+        result: str,
+    ) -> None:
+        """Cache a migration result.
+
+        Args:
+            code: The source code
+            library: Library name
+            from_version: Source version
+            to_version: Target version
+            result: The migrated code
+        """
+        key = self._make_key("migrate", code, library, from_version, to_version)
+        self.set(key, result)
+
+
+# Default cache instances
+_default_cache: Cache | None = None
+_llm_cache: LLMCache | None = None
+
+
+def get_cache() -> Cache:
+    """Get the default cache instance."""
+    global _default_cache
+    if _default_cache is None:
+        _default_cache = Cache()
+    return _default_cache
+
+
+def get_llm_cache() -> LLMCache:
+    """Get the LLM cache instance."""
+    global _llm_cache
+    if _llm_cache is None:
+        _llm_cache = LLMCache()
+    return _llm_cache

codeshift/utils/config.py

@@ -0,0 +1,71 @@
+"""Configuration management for Codeshift."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import toml
+
+
+@dataclass
+class ProjectConfig:
+    """Configuration loaded from pyproject.toml [tool.codeshift] section."""
+
+    exclude: list[str] = field(
+        default_factory=lambda: [".codeshift/*", "tests/*", ".venv/*", "venv/*"]
+    )
+    use_llm: bool = True
+    anthropic_api_key: str | None = None
+    cache_dir: Path = field(default_factory=lambda: Path.home() / ".codeshift" / "cache")
+
+    @classmethod
+    def from_pyproject(cls, project_path: Path) -> "ProjectConfig":
+        """Load configuration from pyproject.toml if it exists."""
+        pyproject_path = project_path / "pyproject.toml"
+        config = cls()
+
+        if pyproject_path.exists():
+            try:
+                data = toml.load(pyproject_path)
+                codeshift_config = data.get("tool", {}).get("codeshift", {})
+
+                if "exclude" in codeshift_config:
+                    config.exclude = codeshift_config["exclude"]
+                if "use_llm" in codeshift_config:
+                    config.use_llm = codeshift_config["use_llm"]
+                if "anthropic_api_key" in codeshift_config:
+                    config.anthropic_api_key = codeshift_config["anthropic_api_key"]
+                if "cache_dir" in codeshift_config:
+                    config.cache_dir = Path(codeshift_config["cache_dir"])
+            except Exception:
+                # If we can't parse the config, use defaults
+                pass
+
+        return config
+
+
+@dataclass
+class Config:
+    """Runtime configuration for a Codeshift session."""
+
+    project_path: Path
+    target_library: str
+    target_version: str
+    project_config: ProjectConfig = field(default_factory=ProjectConfig)
+    state_file: Path | None = None
+    dry_run: bool = False
+    verbose: bool = False
+
+    def __post_init__(self) -> None:
+        """Initialize derived fields."""
+        if self.state_file is None:
+            self.state_file = self.project_path / ".codeshift" / "state.json"
+
+    @property
+    def codeshift_dir(self) -> Path:
+        """Get the .codeshift directory for this project."""
+        return self.project_path / ".codeshift"
+
+    def ensure_dirs(self) -> None:
+        """Ensure required directories exist."""
+        self.codeshift_dir.mkdir(parents=True, exist_ok=True)
+        self.project_config.cache_dir.mkdir(parents=True, exist_ok=True)