codeshift 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

codeshift/api/config.py

@@ -1,73 +0,0 @@
-"""API configuration settings."""
-
-from functools import lru_cache
-
-from pydantic_settings import BaseSettings
-
-
-class APISettings(BaseSettings):
-    """Configuration settings for the Codeshift API."""
-
-    # Supabase
-    supabase_url: str = ""
-    supabase_anon_key: str = ""
-    supabase_service_role_key: str = ""
-
-    # Stripe
-    stripe_secret_key: str = ""
-    stripe_webhook_secret: str = ""
-    stripe_price_id_pro: str = ""
-    stripe_price_id_unlimited: str = ""
-
-    # Anthropic (for server-side LLM calls)
-    anthropic_api_key: str = ""
-
-    # API settings
-    codeshift_api_url: str = "https://py-resolve.replit.app"
-    api_key_prefix: str = "cs_"
-
-    # Tier quotas
-    tier_free_files: int = 100
-    tier_free_llm_calls: int = 50
-    tier_pro_files: int = 1000
-    tier_pro_llm_calls: int = 500
-    tier_unlimited_files: int = 999999999
-    tier_unlimited_llm_calls: int = 999999999
-
-    # Environment
-    environment: str = "development"
-
-    model_config = {
-        "env_prefix": "",
-        "env_file": ".env",
-        "extra": "ignore",
-    }
-
-    @property
-    def is_production(self) -> bool:
-        """Check if running in production."""
-        return self.environment == "production"
-
-    def get_tier_limits(self, tier: str) -> dict[str, int]:
-        """Get quota limits for a tier."""
-        limits = {
-            "free": {
-                "files_per_month": self.tier_free_files,
-                "llm_calls_per_month": self.tier_free_llm_calls,
-            },
-            "pro": {
-                "files_per_month": self.tier_pro_files,
-                "llm_calls_per_month": self.tier_pro_llm_calls,
-            },
-            "unlimited": {
-                "files_per_month": self.tier_unlimited_files,
-                "llm_calls_per_month": self.tier_unlimited_llm_calls,
-            },
-        }
-        return limits.get(tier, limits["free"])
-
-
-@lru_cache
-def get_settings() -> APISettings:
-    """Get cached API settings."""
-    return APISettings()

codeshift/api/database.py

@@ -1,215 +0,0 @@
-"""Supabase database client and operations."""
-
-from datetime import datetime, timezone
-from typing import Any, Optional, cast
-
-from codeshift.api.config import get_settings
-from supabase import Client as SupabaseClient
-from supabase import create_client
-
-
-def get_supabase_client() -> "SupabaseClient":
-    """Get a Supabase client instance."""
-    settings = get_settings()
-    return create_client(
-        settings.supabase_url,
-        settings.supabase_service_role_key,
-    )
-
-
-def get_supabase_anon_client() -> "SupabaseClient":
-    """Get a Supabase client with anon key (for user-facing operations)."""
-    settings = get_settings()
-    return create_client(
-        settings.supabase_url,
-        settings.supabase_anon_key,
-    )
-
-
-class Database:
-    """Database operations wrapper."""
-
-    def __init__(self, client: Optional["SupabaseClient"] = None):
-        """Initialize with optional client, otherwise use service role client."""
-        self._client = client
-
-    @property
-    def client(self) -> "SupabaseClient":
-        """Get or create the Supabase client."""
-        if self._client is None:
-            self._client = get_supabase_client()
-        return self._client
-
-    # Profile operations
-    def get_profile_by_id(self, user_id: str) -> dict | None:
-        """Get a user profile by ID."""
-        result = self.client.table("profiles").select("*").eq("id", user_id).execute()
-        return result.data[0] if result.data else None
-
-    def get_profile_by_email(self, email: str) -> dict | None:
-        """Get a user profile by email."""
-        result = self.client.table("profiles").select("*").eq("email", email).execute()
-        return result.data[0] if result.data else None
-
-    def update_profile(self, user_id: str, data: dict) -> dict | None:
-        """Update a user profile."""
-        result = self.client.table("profiles").update(data).eq("id", user_id).execute()
-        return result.data[0] if result.data else None
-
-    def update_profile_tier(
-        self, user_id: str, tier: str, stripe_customer_id: str | None = None
-    ) -> dict | None:
-        """Update a user's tier and optionally their Stripe customer ID."""
-        data = {"tier": tier, "updated_at": datetime.now(timezone.utc).isoformat()}
-        if stripe_customer_id:
-            data["stripe_customer_id"] = stripe_customer_id
-        return self.update_profile(user_id, data)
-
-    # API key operations
-    def get_api_key_by_hash(self, key_hash: str) -> dict | None:
-        """Get an API key by its hash."""
-        result = (
-            self.client.table("api_keys")
-            .select("*, profiles(*)")
-            .eq("key_hash", key_hash)
-            .eq("revoked", False)
-            .execute()
-        )
-        return result.data[0] if result.data else None
-
-    def get_api_key_by_prefix(self, key_prefix: str) -> dict | None:
-        """Get an API key by its prefix."""
-        result = (
-            self.client.table("api_keys")
-            .select("*, profiles(*)")
-            .eq("key_prefix", key_prefix)
-            .eq("revoked", False)
-            .execute()
-        )
-        return result.data[0] if result.data else None
-
-    def create_api_key(
-        self,
-        user_id: str,
-        key_prefix: str,
-        key_hash: str,
-        name: str = "CLI Key",
-        scopes: list[str] | None = None,
-    ) -> dict[str, Any]:
-        """Create a new API key."""
-        data = {
-            "user_id": user_id,
-            "key_prefix": key_prefix,
-            "key_hash": key_hash,
-            "name": name,
-            "scopes": scopes or ["read", "write"],
-        }
-        result = self.client.table("api_keys").insert(data).execute()
-        return cast(dict[str, Any], result.data[0])
-
-    def revoke_api_key(self, key_id: str) -> bool:
-        """Revoke an API key."""
-        result = (
-            self.client.table("api_keys")
-            .update({"revoked": True, "revoked_at": datetime.now(timezone.utc).isoformat()})
-            .eq("id", key_id)
-            .execute()
-        )
-        return bool(result.data)
-
-    def update_api_key_last_used(self, key_id: str) -> None:
-        """Update the last_used_at timestamp for an API key."""
-        self.client.table("api_keys").update(
-            {"last_used_at": datetime.now(timezone.utc).isoformat()}
-        ).eq("id", key_id).execute()
-
-    # Usage event operations
-    def record_usage_event(
-        self,
-        user_id: str,
-        event_type: str,
-        library: str | None = None,
-        quantity: int = 1,
-        metadata: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Record a usage event."""
-        now = datetime.now(timezone.utc)
-        data = {
-            "user_id": user_id,
-            "event_type": event_type,
-            "library": library,
-            "quantity": quantity,
-            "metadata": metadata or {},
-            "billing_period": now.strftime("%Y-%m"),
-            "created_at": now.isoformat(),
-        }
-        result = self.client.table("usage_events").insert(data).execute()
-        return cast(dict[str, Any], result.data[0])
-
-    def get_usage_for_period(
-        self, user_id: str, billing_period: str | None = None
-    ) -> dict[str, int]:
-        """Get usage summary for a billing period."""
-        if billing_period is None:
-            billing_period = datetime.now(timezone.utc).strftime("%Y-%m")
-
-        result = (
-            self.client.table("usage_events")
-            .select("event_type, quantity")
-            .eq("user_id", user_id)
-            .eq("billing_period", billing_period)
-            .execute()
-        )
-
-        # Aggregate by event type
-        usage: dict[str, int] = {}
-        for event in result.data:
-            event_type = event["event_type"]
-            usage[event_type] = usage.get(event_type, 0) + event["quantity"]
-
-        return usage
-
-    def get_usage_events(
-        self,
-        user_id: str,
-        billing_period: str | None = None,
-        event_type: str | None = None,
-        limit: int = 100,
-    ) -> list[dict[str, Any]]:
-        """Get detailed usage events."""
-        if billing_period is None:
-            billing_period = datetime.now(timezone.utc).strftime("%Y-%m")
-
-        query = (
-            self.client.table("usage_events")
-            .select("*")
-            .eq("user_id", user_id)
-            .eq("billing_period", billing_period)
-        )
-
-        if event_type:
-            query = query.eq("event_type", event_type)
-
-        result = query.order("created_at", desc=True).limit(limit).execute()
-        return cast(list[dict[str, Any]], result.data)
-
-    def get_user_quota(self, user_id: str) -> dict[str, int] | None:
-        """Get quota information for a user.
-
-        Returns:
-            Dict with llm_calls and file_migrated counts, or None if error.
-        """
-        billing_period = datetime.now(timezone.utc).strftime("%Y-%m")
-        return self.get_usage_for_period(user_id, billing_period)
-
-
-# Singleton instance
-_db: Database | None = None
-
-
-def get_database() -> Database:
-    """Get the database singleton."""
-    global _db
-    if _db is None:
-        _db = Database()
-    return _db

codeshift/api/main.py

@@ -1,103 +0,0 @@
-"""FastAPI application for Codeshift billing API."""
-
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-
-from codeshift import __version__
-from codeshift.api.config import get_settings
-from codeshift.api.routers import auth, billing, migrate, usage, webhooks
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-    """Application lifespan handler."""
-    # Startup
-    settings = get_settings()
-    print(f"Codeshift API starting (environment: {settings.environment})")
-    yield
-    # Shutdown
-    print("Codeshift API shutting down")
-
-
-app = FastAPI(
-    title="Codeshift API",
-    description="Billing and authentication API for Codeshift CLI",
-    version=__version__,
-    lifespan=lifespan,
-    docs_url="/docs" if not get_settings().is_production else None,
-    redoc_url="/redoc" if not get_settings().is_production else None,
-)
-
-# CORS configuration
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "https://codeshift.dev",
-        "https://www.codeshift.dev",
-        "http://localhost:3000",  # Local development
-    ],
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-    allow_headers=["*"],
-)
-
-
-# Include routers
-app.include_router(auth.router, prefix="/auth", tags=["Authentication"])
-app.include_router(billing.router, prefix="/billing", tags=["Billing"])
-app.include_router(migrate.router, tags=["Migration"])
-app.include_router(usage.router, prefix="/usage", tags=["Usage"])
-app.include_router(webhooks.router, prefix="/webhooks", tags=["Webhooks"])
-
-
-@app.get("/")
-async def root() -> dict:
-    """API root endpoint."""
-    return {
-        "name": "Codeshift API",
-        "version": __version__,
-        "status": "healthy",
-    }
-
-
-@app.get("/health")
-async def health_check() -> dict:
-    """Health check endpoint."""
-    return {"status": "healthy", "version": __version__}
-
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception) -> JSONResponse:
-    """Global exception handler."""
-    settings = get_settings()
-
-    # Log the error
-    print(f"Unhandled exception: {exc}")
-
-    # Return appropriate response based on environment
-    if settings.is_production:
-        return JSONResponse(
-            status_code=500,
-            content={"detail": "Internal server error"},
-        )
-    else:
-        return JSONResponse(
-            status_code=500,
-            content={"detail": str(exc), "type": type(exc).__name__},
-        )
-
-
-# For running with uvicorn directly
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(
-        "codeshift.api.main:app",
-        host="0.0.0.0",
-        port=8000,
-        reload=True,
-    )

codeshift/api/models/__init__.py

@@ -1,55 +0,0 @@
-"""Pydantic models for the PyResolve API."""
-
-from codeshift.api.models.auth import (
-    APIKey,
-    APIKeyCreate,
-    APIKeyResponse,
-    TokenResponse,
-    UserInfo,
-)
-from codeshift.api.models.billing import (
-    CheckoutSessionRequest,
-    CheckoutSessionResponse,
-    PortalSessionResponse,
-    SubscriptionInfo,
-    TierInfo,
-)
-from codeshift.api.models.migrate import (
-    ExplainChangeRequest,
-    ExplainChangeResponse,
-    MigrateCodeRequest,
-    MigrateCodeResponse,
-)
-from codeshift.api.models.usage import (
-    QuotaInfo,
-    UsageEvent,
-    UsageEventCreate,
-    UsageResponse,
-    UsageSummary,
-)
-
-__all__ = [
-    # Auth models
-    "APIKey",
-    "APIKeyCreate",
-    "APIKeyResponse",
-    "TokenResponse",
-    "UserInfo",
-    # Billing models
-    "CheckoutSessionRequest",
-    "CheckoutSessionResponse",
-    "PortalSessionResponse",
-    "SubscriptionInfo",
-    "TierInfo",
-    # Migrate models
-    "ExplainChangeRequest",
-    "ExplainChangeResponse",
-    "MigrateCodeRequest",
-    "MigrateCodeResponse",
-    # Usage models
-    "QuotaInfo",
-    "UsageEvent",
-    "UsageEventCreate",
-    "UsageResponse",
-    "UsageSummary",
-]

codeshift/api/models/auth.py

@@ -1,108 +0,0 @@
-"""Authentication models for the PyResolve API."""
-
-from datetime import datetime
-
-from pydantic import BaseModel, EmailStr, Field
-
-
-class UserInfo(BaseModel):
-    """User profile information."""
-
-    id: str
-    email: EmailStr
-    full_name: str | None = None
-    tier: str = "free"
-    stripe_customer_id: str | None = None
-    created_at: datetime
-
-    class Config:
-        from_attributes = True
-
-
-class APIKeyCreate(BaseModel):
-    """Request to create a new API key."""
-
-    name: str = Field(default="CLI Key", min_length=1, max_length=100)
-    scopes: list[str] = Field(default=["read", "write"])
-
-
-class APIKey(BaseModel):
-    """API key information (without the secret)."""
-
-    id: str
-    name: str
-    key_prefix: str
-    scopes: list[str]
-    revoked: bool = False
-    last_used_at: datetime | None = None
-    expires_at: datetime | None = None
-    created_at: datetime
-
-    class Config:
-        from_attributes = True
-
-
-class APIKeyResponse(BaseModel):
-    """Response when creating a new API key (includes full key once)."""
-
-    id: str
-    name: str
-    key: str  # Full API key - only shown once
-    key_prefix: str
-    scopes: list[str]
-    created_at: datetime
-
-
-class TokenResponse(BaseModel):
-    """Response for authentication token."""
-
-    access_token: str
-    token_type: str = "bearer"
-    expires_in: int
-    refresh_token: str | None = None
-
-
-class LoginRequest(BaseModel):
-    """Request for CLI login."""
-
-    email: EmailStr
-    password: str = Field(min_length=6)
-
-
-class LoginResponse(BaseModel):
-    """Response for CLI login."""
-
-    api_key: str
-    user: UserInfo
-    message: str = "Login successful"
-
-
-class DeviceCodeRequest(BaseModel):
-    """Request to initiate device code flow."""
-
-    client_id: str = "codeshift-cli"
-
-
-class DeviceCodeResponse(BaseModel):
-    """Response with device code for authentication."""
-
-    device_code: str
-    user_code: str
-    verification_uri: str
-    expires_in: int = 900  # 15 minutes
-    interval: int = 5  # Polling interval in seconds
-
-
-class DeviceTokenRequest(BaseModel):
-    """Request to exchange device code for token."""
-
-    device_code: str
-    client_id: str = "codeshift-cli"
-
-
-class RegisterRequest(BaseModel):
-    """Request for new user registration."""
-
-    email: EmailStr
-    password: str = Field(min_length=8, description="Password must be at least 8 characters")
-    full_name: str | None = Field(default=None, max_length=100)

codeshift/api/models/billing.py

@@ -1,92 +0,0 @@
-"""Billing models for the PyResolve API."""
-
-from datetime import datetime
-
-from pydantic import BaseModel, Field
-
-
-class TierInfo(BaseModel):
-    """Information about a pricing tier."""
-
-    name: str
-    display_name: str
-    price_monthly: int  # In cents
-    files_per_month: int
-    llm_calls_per_month: int
-    features: list[str]
-
-
-class SubscriptionInfo(BaseModel):
-    """Current subscription information."""
-
-    tier: str
-    status: str  # active, canceled, past_due, etc.
-    stripe_subscription_id: str | None = None
-    current_period_start: datetime | None = None
-    current_period_end: datetime | None = None
-    cancel_at_period_end: bool = False
-
-
-class CheckoutSessionRequest(BaseModel):
-    """Request to create a Stripe checkout session."""
-
-    tier: str = Field(..., pattern="^(pro|unlimited)$")
-    success_url: str | None = None
-    cancel_url: str | None = None
-
-
-class CheckoutSessionResponse(BaseModel):
-    """Response with Stripe checkout session."""
-
-    checkout_url: str
-    session_id: str
-
-
-class PortalSessionResponse(BaseModel):
-    """Response with Stripe billing portal URL."""
-
-    portal_url: str
-
-
-class PriceInfo(BaseModel):
-    """Stripe price information."""
-
-    id: str
-    product_id: str
-    unit_amount: int
-    currency: str
-    recurring_interval: str
-
-
-class InvoiceInfo(BaseModel):
-    """Invoice information."""
-
-    id: str
-    status: str
-    amount_due: int
-    amount_paid: int
-    currency: str
-    created: datetime
-    due_date: datetime | None = None
-    hosted_invoice_url: str | None = None
-    pdf_url: str | None = None
-
-
-class PaymentMethodInfo(BaseModel):
-    """Payment method information."""
-
-    id: str
-    type: str  # card, bank_account, etc.
-    card_brand: str | None = None
-    card_last4: str | None = None
-    card_exp_month: int | None = None
-    card_exp_year: int | None = None
-
-
-class BillingOverview(BaseModel):
-    """Complete billing overview for a user."""
-
-    subscription: SubscriptionInfo
-    tier_info: TierInfo
-    payment_method: PaymentMethodInfo | None = None
-    upcoming_invoice: InvoiceInfo | None = None

codeshift/api/models/migrate.py

@@ -1,42 +0,0 @@
-"""Migration models for the PyResolve API."""
-
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class MigrateCodeRequest(BaseModel):
-    """Request to migrate code using LLM."""
-
-    code: str = Field(..., description="Source code to migrate")
-    library: str = Field(..., description="Library being upgraded (e.g., 'pydantic')")
-    from_version: str = Field(..., description="Current version (e.g., '1.10.0')")
-    to_version: str = Field(..., description="Target version (e.g., '2.5.0')")
-    context: str | None = Field(None, description="Optional context about the migration")
-
-
-class MigrateCodeResponse(BaseModel):
-    """Response from LLM migration."""
-
-    success: bool
-    migrated_code: str
-    original_code: str
-    error: str | None = None
-    usage: dict[str, Any] = Field(default_factory=dict)
-    cached: bool = False
-
-
-class ExplainChangeRequest(BaseModel):
-    """Request to explain a migration change."""
-
-    original_code: str = Field(..., description="Original code before migration")
-    transformed_code: str = Field(..., description="Transformed code after migration")
-    library: str = Field(..., description="Library being upgraded")
-
-
-class ExplainChangeResponse(BaseModel):
-    """Response with explanation of changes."""
-
-    success: bool
-    explanation: str | None = None
-    error: str | None = None