repr-cli 0.1.0__py3-none-any.whl

repr/api.py

@@ -0,0 +1,263 @@
+"""
+REST API client for repr.dev endpoints.
+"""
+
+import hashlib
+from typing import Any
+
+import httpx
+
+from .auth import require_auth, AuthError
+from .config import get_api_base
+
+
+def _get_profile_url() -> str:
+    return f"{get_api_base()}/profile"
+
+
+def _get_repo_profile_url() -> str:
+    return f"{get_api_base()}/repo-profile"
+
+
+def _get_user_url() -> str:
+    return f"{get_api_base()}/user"
+
+
+class APIError(Exception):
+    """API request error."""
+    pass
+
+
+def _get_headers() -> dict[str, str]:
+    """Get headers with authentication."""
+    token = require_auth()
+    return {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "User-Agent": "repr-cli/0.1.0",
+    }
+
+
+def compute_content_hash(content: str) -> str:
+    """Compute SHA256 hash of content."""
+    return hashlib.sha256(content.encode('utf-8')).hexdigest()
+
+
+async def push_profile(content: str, profile_name: str, analyzed_repos: list[dict[str, Any] | str] | None = None) -> dict[str, Any]:
+    """
+    Push a profile to repr.dev.
+    
+    Args:
+        content: Markdown content of the profile
+        profile_name: Name/identifier of the profile
+        analyzed_repos: Optional list of repository metadata (dicts) or names (strings for backward compat)
+    
+    Returns:
+        Response data with profile URL
+    
+    Raises:
+        APIError: If upload fails
+        AuthError: If not authenticated
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            # Compute content hash
+            content_hash = compute_content_hash(content)
+            
+            payload = {
+                "content": content,
+                "name": profile_name,
+                "content_hash": content_hash,
+            }
+            if analyzed_repos is not None:
+                payload["analyzed_repos"] = analyzed_repos
+            
+            response = await client.post(
+                _get_profile_url(),
+                headers=_get_headers(),
+                json=payload,
+                timeout=60,
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthError("Session expired. Please run 'repr login' again.")
+            elif e.response.status_code == 413:
+                raise APIError("Profile too large to upload.")
+            else:
+                raise APIError(f"Upload failed: {e.response.status_code}")
+        except httpx.RequestError as e:
+            raise APIError(f"Network error: {str(e)}")
+
+
+async def get_user_profile() -> dict[str, Any] | None:
+    """
+    Get the user's current profile from the server.
+    
+    Returns:
+        Profile data or None if not found
+    
+    Raises:
+        APIError: If request fails
+        AuthError: If not authenticated
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(
+                _get_profile_url(),
+                headers=_get_headers(),
+                timeout=30,
+            )
+            
+            if response.status_code == 404:
+                return None
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthError("Session expired. Please run 'repr login' again.")
+            raise APIError(f"Failed to get profile: {e.response.status_code}")
+        except httpx.RequestError as e:
+            raise APIError(f"Network error: {str(e)}")
+
+
+async def get_user_info() -> dict[str, Any]:
+    """
+    Get current user information.
+    
+    Returns:
+        User info dict
+    
+    Raises:
+        APIError: If request fails
+        AuthError: If not authenticated
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(
+                _get_user_url(),
+                headers=_get_headers(),
+                timeout=30,
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthError("Session expired. Please run 'repr login' again.")
+            raise APIError(f"Failed to get user info: {e.response.status_code}")
+        except httpx.RequestError as e:
+            raise APIError(f"Network error: {str(e)}")
+
+
+async def delete_profile() -> bool:
+    """
+    Delete the user's profile from the server.
+    
+    Returns:
+        True if deleted successfully
+    
+    Raises:
+        APIError: If request fails
+        AuthError: If not authenticated
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.delete(
+                _get_profile_url(),
+                headers=_get_headers(),
+                timeout=30,
+            )
+            response.raise_for_status()
+            return True
+            
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthError("Session expired. Please run 'repr login' again.")
+            elif e.response.status_code == 404:
+                return True  # Already deleted
+            raise APIError(f"Failed to delete profile: {e.response.status_code}")
+        except httpx.RequestError as e:
+            raise APIError(f"Network error: {str(e)}")
+
+
+async def push_repo_profile(
+    content: str,
+    repo_name: str,
+    repo_metadata: dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Push a single repository profile to repr.dev.
+    
+    Args:
+        content: Markdown content of the profile
+        repo_name: Name of the repository
+        repo_metadata: Repository metadata (commit_count, languages, etc.)
+    
+    Returns:
+        Response data with profile URL
+    
+    Raises:
+        APIError: If upload fails
+        AuthError: If not authenticated
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            content_hash = compute_content_hash(content)
+            
+            payload = {
+                "repo_name": repo_name,
+                "content": content,
+                "content_hash": content_hash,
+                **repo_metadata,
+            }
+            
+            response = await client.post(
+                _get_repo_profile_url(),
+                headers=_get_headers(),
+                json=payload,
+                timeout=60,
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthError("Session expired. Please run 'repr login' again.")
+            elif e.response.status_code == 413:
+                raise APIError("Profile too large to upload.")
+            else:
+                raise APIError(f"Upload failed: {e.response.status_code}")
+        except httpx.RequestError as e:
+            raise APIError(f"Network error: {str(e)}")
+
+
+def sync_push_profile(content: str, profile_name: str, analyzed_repos: list[str] | None = None) -> dict[str, Any]:
+    """
+    Synchronous wrapper for push_profile.
+    
+    Args:
+        content: Markdown content of the profile
+        profile_name: Name/identifier of the profile
+        analyzed_repos: Optional list of repository names analyzed
+    
+    Returns:
+        Response data with profile URL
+    """
+    import asyncio
+    return asyncio.run(push_profile(content, profile_name, analyzed_repos))
+
+
+def sync_get_user_info() -> dict[str, Any]:
+    """
+    Synchronous wrapper for get_user_info.
+    
+    Returns:
+        User info dict
+    """
+    import asyncio
+    return asyncio.run(get_user_info())

repr/auth.py

@@ -0,0 +1,300 @@
+"""
+Authentication via device code flow.
+"""
+
+import asyncio
+import time
+from dataclasses import dataclass
+
+import httpx
+
+from .config import set_auth, clear_auth, get_auth, is_authenticated, get_api_base
+
+
+def _get_device_code_url() -> str:
+    return f"{get_api_base()}/device-code"
+
+
+def _get_token_url() -> str:
+    return f"{get_api_base()}/token"
+
+# Polling configuration
+POLL_INTERVAL = 5  # seconds
+MAX_POLL_TIME = 600  # 10 minutes
+
+
+@dataclass
+class DeviceCodeResponse:
+    """Response from device code request."""
+    device_code: str
+    user_code: str
+    verification_url: str
+    expires_in: int
+    interval: int
+
+
+@dataclass
+class TokenResponse:
+    """Response from token request."""
+    access_token: str
+    user_id: str
+    email: str
+    litellm_api_key: str | None = None  # rf_* token for LLM proxy authentication
+
+
+class AuthError(Exception):
+    """Authentication error."""
+    pass
+
+
+async def request_device_code() -> DeviceCodeResponse:
+    """
+    Request a new device code for authentication.
+    
+    Returns:
+        DeviceCodeResponse with user code to display
+    
+    Raises:
+        AuthError: If request fails
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                _get_device_code_url(),
+                json={"client_id": "repr-cli"},
+                timeout=30,
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            return DeviceCodeResponse(
+                device_code=data["device_code"],
+                user_code=data["user_code"],
+                verification_url=data.get("verification_url", "https://repr.dev/device"),
+                expires_in=data.get("expires_in", 600),
+                interval=data.get("interval", 5),
+            )
+        except httpx.HTTPStatusError as e:
+            raise AuthError(f"Failed to get device code: {e.response.status_code}")
+        except httpx.RequestError as e:
+            raise AuthError(f"Network error: {str(e)}")
+
+
+async def poll_for_token(device_code: str, interval: int = POLL_INTERVAL) -> TokenResponse:
+    """
+    Poll for access token after user authorizes.
+    
+    Args:
+        device_code: The device code from initial request
+        interval: Polling interval in seconds
+    
+    Returns:
+        TokenResponse with access token
+    
+    Raises:
+        AuthError: If polling fails or times out
+    """
+    start_time = time.time()
+    
+    async with httpx.AsyncClient() as client:
+        while time.time() - start_time < MAX_POLL_TIME:
+            try:
+                response = await client.post(
+                    _get_token_url(),
+                    json={
+                        "device_code": device_code,
+                        "client_id": "repr-cli",
+                    },
+                    timeout=30,
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    return TokenResponse(
+                        access_token=data["access_token"],
+                        user_id=data["user_id"],
+                        email=data["email"],
+                        litellm_api_key=data.get("litellm_api_key"),
+                    )
+                
+                if response.status_code == 400:
+                    data = response.json()
+                    error = data.get("error", "unknown")
+                    
+                    if error == "authorization_pending":
+                        # User hasn't authorized yet, continue polling
+                        await asyncio.sleep(interval)
+                        continue
+                    elif error == "slow_down":
+                        # Increase interval
+                        interval = min(interval + 5, 30)
+                        await asyncio.sleep(interval)
+                        continue
+                    elif error == "expired_token":
+                        raise AuthError("Device code expired. Please try again.")
+                    elif error == "access_denied":
+                        raise AuthError("Authorization denied by user.")
+                    else:
+                        raise AuthError(f"Authorization failed: {error}")
+                
+                response.raise_for_status()
+                
+            except httpx.RequestError as e:
+                # Network error, retry
+                await asyncio.sleep(interval)
+                continue
+        
+        raise AuthError("Authorization timed out. Please try again.")
+
+
+def save_token(token_response: TokenResponse) -> None:
+    """
+    Save authentication token to config.
+    
+    Args:
+        token_response: Token response from successful auth
+    """
+    set_auth(
+        access_token=token_response.access_token,
+        user_id=token_response.user_id,
+        email=token_response.email,
+        litellm_api_key=token_response.litellm_api_key,
+    )
+
+
+def logout() -> None:
+    """Clear authentication and logout."""
+    clear_auth()
+
+
+def get_current_user() -> dict | None:
+    """
+    Get current authenticated user info.
+    
+    Returns:
+        User info dict or None if not authenticated
+    """
+    return get_auth()
+
+
+def require_auth() -> str:
+    """
+    Get access token, raising error if not authenticated.
+    
+    Returns:
+        Access token
+    
+    Raises:
+        AuthError: If not authenticated
+    """
+    auth = get_auth()
+    if not auth or not auth.get("access_token"):
+        raise AuthError("Not authenticated. Run 'repr login' first.")
+    return auth["access_token"]
+
+
+class AuthFlow:
+    """
+    Manages the device code authentication flow with progress callbacks.
+    """
+    
+    def __init__(
+        self,
+        on_code_received: callable = None,
+        on_progress: callable = None,
+        on_success: callable = None,
+        on_error: callable = None,
+    ):
+        self.on_code_received = on_code_received
+        self.on_progress = on_progress
+        self.on_success = on_success
+        self.on_error = on_error
+        self._cancelled = False
+    
+    def cancel(self) -> None:
+        """Cancel the authentication flow."""
+        self._cancelled = True
+    
+    async def run(self) -> TokenResponse | None:
+        """
+        Run the full authentication flow.
+        
+        Returns:
+            TokenResponse if successful, None if cancelled
+        """
+        try:
+            # Request device code
+            device_code_response = await request_device_code()
+            
+            if self.on_code_received:
+                self.on_code_received(device_code_response)
+            
+            # Poll for token
+            start_time = time.time()
+            interval = device_code_response.interval
+            
+            async with httpx.AsyncClient() as client:
+                while not self._cancelled:
+                    elapsed = time.time() - start_time
+                    remaining = device_code_response.expires_in - elapsed
+                    
+                    if remaining <= 0:
+                        raise AuthError("Device code expired. Please try again.")
+                    
+                    if self.on_progress:
+                        self.on_progress(remaining)
+                    
+                    try:
+                        response = await client.post(
+                            _get_token_url(),
+                            json={
+                                "device_code": device_code_response.device_code,
+                                "client_id": "repr-cli",
+                            },
+                            timeout=30,
+                        )
+                        
+                        if response.status_code == 200:
+                            data = response.json()
+                            user_data = data.get("user", {})
+                            token = TokenResponse(
+                                access_token=data["access_token"],
+                                user_id=user_data.get("id", ""),
+                                email=user_data.get("email", ""),
+                                litellm_api_key=data.get("litellm_api_key"),
+                            )
+                            save_token(token)
+                            
+                            if self.on_success:
+                                self.on_success(token)
+                            
+                            return token
+                        
+                        if response.status_code == 400:
+                            data = response.json()
+                            error = data.get("error", "unknown")
+                            
+                            if error == "authorization_pending":
+                                await asyncio.sleep(interval)
+                                continue
+                            elif error == "slow_down":
+                                interval = min(interval + 5, 30)
+                                await asyncio.sleep(interval)
+                                continue
+                            elif error == "expired_token":
+                                raise AuthError("Device code expired. Please try again.")
+                            elif error == "access_denied":
+                                raise AuthError("Authorization denied by user.")
+                        
+                    except httpx.RequestError:
+                        await asyncio.sleep(interval)
+                        continue
+                    
+                    await asyncio.sleep(interval)
+            
+            return None  # Cancelled
+            
+        except AuthError as e:
+            if self.on_error:
+                self.on_error(e)
+            raise