.claude/skills/vercel-fastapi-link/scripts/setup.sh --github-pages https://faiqahm.github.io --test

.claude/skills/vercel-fastapi-link/scripts/setup.sh

.claude/skills/vercel-fastapi-link/scripts/setup.sh \
  --github-pages https://faiqahm.github.io \
  --extra-origins "https://staging.mysite.com,https://preview.mysite.com" \
  --test

python-3.11

# GitHub Pages URL for CORS (required for production)
GITHUB_PAGES_URL=https://faiqahm.github.io

# Additional allowed origins (comma-separated, optional)
# EXTRA_CORS_ORIGINS=https://staging.example.com,https://preview.example.com

# Logging Configuration
# LOG_LEVEL=INFO  # Options: DEBUG, INFO, WARNING, ERROR
# Set to DEBUG for verbose output when debugging with Vercel logs

# Database (if needed)
# DATABASE_URL=postgresql://user:pass@host:5432/dbname

{
  "version": 2,
  "builds": [
    {
      "src": "api/main.py",
      "use": "@vercel/python"
    }
  ],
  "routes": [
    { "src": "/api/(.*)", "dest": "api/main.py" },
    { "src": "/health", "dest": "api/main.py" },
    { "src": "/docs", "dest": "api/main.py" },
    { "src": "/openapi.json", "dest": "api/main.py" }
  ]
}

import logging

# Configure logging so agents can read Vercel logs for debugging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
logger = logging.getLogger("physical-ai-book-api")

# Adjust log level from environment (DEBUG, INFO, WARNING, ERROR)
log_level = os.getenv("LOG_LEVEL", "INFO").upper()
logger.setLevel(getattr(logging, log_level, logging.INFO))

# Usage in endpoints:
logger.info(f"Fetching chapter with id={chapter_id}")
logger.warning(f"Chapter not found: id={chapter_id}")
logger.error(f"Unhandled exception: {exc}", exc_info=True)

from pydantic import BaseModel, Field
from typing import Optional, List

class HealthResponse(BaseModel):
    """Health check response model."""
    status: str = Field(..., example="healthy")
    service: str = Field(..., example="physical-ai-book-api")
    timestamp: str = Field(..., example="2024-01-01T12:00:00Z")

class ChapterSummary(BaseModel):
    """Summary of a chapter for listing."""
    id: int = Field(..., example=1)
    title: str = Field(..., example="Introduction to Physical AI")
    slug: str = Field(..., example="intro")

class ChapterDetail(BaseModel):
    """Full chapter details."""
    id: int
    title: str
    content: str = Field(..., example="Chapter content goes here...")
    created_at: Optional[str] = None
    updated_at: Optional[str] = None

class ChapterListResponse(BaseModel):
    """Response model for chapter listing."""
    chapters: List[ChapterSummary]
    total: int = Field(..., example=3)

class ErrorResponse(BaseModel):
    """Standard error response model."""
    detail: str = Field(..., example="Resource not found")
    error_code: Optional[str] = Field(None, example="NOT_FOUND")

# Get GitHub Pages URL from environment or use default
GITHUB_PAGES_URL = os.getenv("GITHUB_PAGES_URL", "https://faiqahm.github.io")

# Base allowed origins
allowed_origins = [
    "http://localhost:3000",      # Local Docusaurus dev
    "http://localhost:8000",      # Local FastAPI dev
    GITHUB_PAGES_URL,             # Production GitHub Pages
]

# Add extra origins from environment variable (comma-separated)
extra_origins_env = os.getenv("EXTRA_CORS_ORIGINS", "")
if extra_origins_env:
    for origin in extra_origins_env.split(","):
        origin = origin.strip()
        if origin and origin not in allowed_origins:
            allowed_origins.append(origin)

app.add_middleware(
    CORSMiddleware,
    allow_origins=allowed_origins,
    allow_credentials=True,
    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
    allow_headers=["Authorization", "Content-Type", "Accept", "Origin"],
    max_age=600,
)

curl "http://localhost:8000/api/personalization/profile?user_id=user-123"

{
  "user_id": "user-123",
  "preferences": {
    "preferred_language": "en",
    "difficulty_level": "beginner",
    "topics_of_interest": [],
    "learning_style": "visual",
    "session_duration_minutes": 30
  },
  "created_at": "2024-01-01T12:00:00Z",
  "updated_at": "2024-01-01T12:00:00Z"
}

curl -X POST "http://localhost:8000/api/personalization/profile" \
  -H "Content-Type: application/json" \
  -d '{"user_id": "user-123", "preferences": {"difficulty_level": "intermediate"}}'

curl "http://localhost:8000/api/personalization/recommendations?user_id=user-123"

{
  "user_id": "user-123",
  "recommendations": [
    {
      "id": "rec-001",
      "title": "Introduction to Physical AI",
      "description": "Start your journey into Physical AI and robotics",
      "chapter_id": 1,
      "relevance_score": 0.95,
      "reason": "Recommended starting point for all learners"
    }
  ],
  "generated_at": "2024-01-01T12:00:00Z"
}

curl "http://localhost:8000/api/personalization/learning-path?user_id=user-123"

{
  "user_id": "user-123",
  "path_id": "path-user-123",
  "title": "Physical AI Learning Journey",
  "items": [
    {
      "order": 1,
      "chapter_id": 1,
      "title": "Introduction to Physical AI & ROS 2",
      "status": "not_started",
      "progress_percent": 0,
      "estimated_duration_minutes": 60
    }
  ],
  "overall_progress_percent": 0,
  "created_at": "2024-01-01T12:00:00Z",
  "updated_at": "2024-01-01T12:00:00Z"
}

curl -X POST "http://localhost:8000/api/personalization/apply" \
  -H "Content-Type: application/json" \
  -d '{
    "user_id": "user-123",
    "preferences": {
      "preferred_language": "en",
      "difficulty_level": "intermediate",
      "topics_of_interest": ["robotics", "ai"],
      "learning_style": "hands-on"
    },
    "notifications_enabled": true,
    "theme": "dark"
  }'

{
  "success": true,
  "message": "Personalization settings applied successfully for user user-123",
  "applied_at": "2024-01-01T12:00:00Z"
}

.claude/skills/vercel-fastapi-link/scripts/setup.sh --test

project/
├── api/
│   ├── __init__.py
│   └── main.py          # FastAPI application
├── vercel.json          # Vercel configuration
├── runtime.txt          # Python version
├── requirements.txt     # Python dependencies
├── .env.example         # Environment template
├── .env                 # Local environment (gitignored)
└── .gitignore           # Updated with .env

# Install dependencies
pip install -r requirements.txt

# Run locally
uvicorn api.main:app --reload --port 8000

# Test endpoints
curl http://localhost:8000/health
curl http://localhost:8000/docs

# Install Vercel CLI
npm i -g vercel

# Deploy
vercel

# Set environment variables
vercel env add GITHUB_PAGES_URL
vercel env add EXTRA_CORS_ORIGINS  # Optional

// src/config.js
export const API_URL = process.env.NODE_ENV === 'production'
  ? 'https://your-project.vercel.app'
  : 'http://localhost:8000';

# Health check
curl http://localhost:8000/health

# Get user profile
curl "http://localhost:8000/api/personalization/profile?user_id=test-user"

# Get recommendations
curl "http://localhost:8000/api/personalization/recommendations?user_id=test-user"

# Get learning path
curl "http://localhost:8000/api/personalization/learning-path?user_id=test-user"

# Apply personalization
curl -X POST "http://localhost:8000/api/personalization/apply" \
  -H "Content-Type: application/json" \
  -d '{"user_id":"test-user","preferences":{"difficulty_level":"intermediate"},"notifications_enabled":true,"theme":"dark"}'

# tests/test_personalization.py
import pytest
from fastapi.testclient import TestClient
from api.main import app

client = TestClient(app)

def test_health():
    response = client.get("/health")
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

def test_get_profile():
    response = client.get("/api/personalization/profile?user_id=test-user")
    assert response.status_code == 200
    assert response.json()["user_id"] == "test-user"

def test_get_recommendations():
    response = client.get("/api/personalization/recommendations?user_id=test-user")
    assert response.status_code == 200
    assert "recommendations" in response.json()

def test_get_learning_path():
    response = client.get("/api/personalization/learning-path?user_id=test-user")
    assert response.status_code == 200
    assert "items" in response.json()

def test_apply_personalization():
    response = client.post(
        "/api/personalization/apply",
        json={
            "user_id": "test-user",
            "preferences": {"difficulty_level": "intermediate"},
            "notifications_enabled": True,
            "theme": "dark"
        }
    )
    assert response.status_code == 200
    assert response.json()["success"] == True

# In Vercel Dashboard > Settings > Environment Variables:
GITHUB_PAGES_URL=https://username.github.io
EXTRA_CORS_ORIGINS=https://staging.example.com,https://preview.example.com

# Run with test
.claude/skills/vercel-fastapi-link/scripts/setup.sh --test

# Expected output:
# ✓ Health check passed: {"status":"healthy","service":"physical-ai-book-api"}
# ✓ All tests passed! Your API is ready.