# Deployment Guide

## Quick Deployment Options

### Option 1: Replit (Easiest - FREE)

1. **Create Account**: https://replit.com/signup
2. **Create New Project**: Click "Create" → "Import from GitHub"
3. **Enter Repository URL**: Paste your GitHub repo URL
4. **Deploy**:
   ```bash
   pip install -r requirements.txt
   python web/app.py
   ```
5. **Access**: Replit will provide a live URL (e.g., `https://project-name.replit.dev`)

### Option 2: Railway (FREE tier available)

1. **Create Account**: https://railway.app
2. **Connect Repository**: Click "Create Project" → "Deploy from GitHub"
3. **Select Your Repo**: Choose the AI code generation repo
4. **Add Environment Variables** (if using LLM):
   - Key: `ANTHROPIC_API_KEY`
   - Value: Your API key
5. **Deploy**: Railway auto-deploys on push
6. **Get URL**: Check "Deployments" for live URL

### Option 3: Heroku (Paid but easy)

1. **Create Account**: https://heroku.com
2. **Install Heroku CLI**: https://devcenter.heroku.com/articles/heroku-cli
3. **Create App**:
   ```bash
   heroku login
   heroku create your-app-name
   ```
4. **Deploy**:
   ```bash
   git push heroku main
   ```
5. **Get URL**: `https://your-app-name.herokuapp.com`

### Option 4: Google Cloud Run (Pay-per-use)

1. **Setup**:
   ```bash
   gcloud auth login
   gcloud config set project your-project-id
   ```

2. **Create Dockerfile**:
   ```dockerfile
   FROM python:3.9-slim
   WORKDIR /app
   COPY . .
   RUN pip install -r requirements.txt
   EXPOSE 5000
   CMD ["python", "web/app.py"]
   ```

3. **Deploy**:
   ```bash
   gcloud run deploy code-gen \
     --source . \
     --platform managed \
     --region us-central1
   ```

4. **Get URL**: GCP will provide a live URL

---

## Local Deployment (for testing)

### Prerequisites
- Python 3.8+
- Git

### Steps

1. **Clone Repository**
   ```bash
   git clone https://github.com/your-username/ai-code-gen.git
   cd ai-code-gen
   ```

2. **Install Dependencies**
   ```bash
   pip install -r requirements.txt
   ```

3. **Set Environment Variables** (Optional)
   ```bash
   export ANTHROPIC_API_KEY="your-api-key"  # For LLM features
   ```

4. **Run Server**
   ```bash
   python web/app.py
   ```

5. **Access**
   ```
   http://localhost:5000
   ```

---

## Production Deployment (Best Practices)

### 1. Use Gunicorn

```bash
pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:8000 web.app
```

### 2. Use Environment Variables

Create `.env` file:
```
ANTHROPIC_API_KEY=your-key
FLASK_ENV=production
```

### 3. Add SSL/HTTPS

Use a reverse proxy (Nginx, Cloudflare)

### 4. Enable Logging

```python
# In web/app.py
import logging
logging.basicConfig(level=logging.INFO)
```

### 5. Add Rate Limiting

```python
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app=app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)
```

---

## Docker Deployment

### Dockerfile

```dockerfile
FROM python:3.9-slim

WORKDIR /app

# Copy requirements and install
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY . .

# Expose port
EXPOSE 5000

# Run with gunicorn for production
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "web.app"]
```

### Build and Run

```bash
# Build image
docker build -t code-gen:latest .

# Run container
docker run -p 5000:5000 code-gen:latest

# Access
open http://localhost:5000
```

### Docker Compose

```yaml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    restart: unless-stopped
```

Run with:
```bash
docker-compose up
```

---

## Monitoring & Logging

### Application Logging

```python
import logging

logger = logging.getLogger(__name__)

@app.route('/api/generate', methods=['POST'])
def generate():
    logger.info("Generation request received")
    try:
        # ... generation code ...
        logger.info("Generation successful")
    except Exception as e:
        logger.error(f"Generation failed: {e}")
    
    return jsonify(...)
```

### Health Check

The API includes a health endpoint:
```bash
curl https://your-app.com/api/health
```

Returns:
```json
{
  "status": "healthy",
  "timestamp": "2026-05-06T07:52:40.123456",
  "total_requests": 42
}
```

---

## Performance Optimization

### 1. Enable Caching

```python
from functools import lru_cache

@lru_cache(maxsize=128)
def extract_intent(prompt):
    # Intent extraction is cached
    return ...
```

### 2. Use Connection Pooling

```python
# For database connections (future)
pool = create_engine(
    'postgresql://...',
    poolclass=StaticPool,
    pool_size=20
)
```

### 3. Enable Compression

```python
from flask_compress import Compress
Compress(app)
```

### 4. Use CDN

Deploy static files to CDN (Cloudflare, AWS CloudFront)

---

## Troubleshooting

### Port Already in Use

```bash
# Windows
netstat -ano | findstr :5000
taskkill /PID <PID> /F

# Linux/Mac
lsof -i :5000
kill -9 <PID>
```

### Module Not Found

```bash
pip install --upgrade pip
pip install -r requirements.txt
```

### API Timeout

Increase timeout in production:
```python
app.config['REQUEST_TIMEOUT'] = 60  # seconds
```

### Memory Issues

Use rule-based generation:
```python
pipeline = Pipeline(use_llm=False)  # Lower memory usage
```

---

## Continuous Deployment (CD)

### GitHub Actions

Create `.github/workflows/deploy.yml`:

```yaml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-python@v2
        with:
          python-version: 3.9
      - run: pip install -r requirements.txt
      - run: pytest  # If tests exist
      - uses: AkhileshNS/heroku-deploy@v3.12.12
        with:
          heroku_api_key: ${{secrets.HEROKU_API_KEY}}
          heroku_app_name: "your-app-name"
          heroku_email: "your-email@example.com"
```

### Push to Deploy

```bash
git push origin main
# Automatically deploys!
```

---

## Monitoring Checklist

- [ ] Health endpoint working
- [ ] Error logging enabled
- [ ] Performance monitored
- [ ] API rate limits set
- [ ] SSL/HTTPS enabled (production)
- [ ] Environment variables secured
- [ ] Backups configured
- [ ] Alerts setup

---

## Cost Estimates

| Platform | Free Tier | Paid Tier |
|----------|-----------|-----------|
| Replit | ✅ Yes | $7/mo |
| Railway | ✅ Yes (10 GB) | $5/mo+ |
| Heroku | ✅ (limited) | $7-50/mo |
| Google Cloud Run | ✅ ($11 free) | $0.00002/req |
| Vercel | ✅ (serverless) | $20/mo |

**Recommendation**: Start with Replit (free, easiest)

---

## Live URL Examples

After deployment, you'll have URLs like:
- Replit: `https://ai-code-gen.replit.dev`
- Railway: `https://ai-code-gen-production.up.railway.app`
- Heroku: `https://ai-code-gen.herokuapp.com`
- Cloud Run: `https://code-gen-xyz.run.app`

---

## Testing Live Deployment

```bash
# Test health
curl https://your-app-url/api/health

# Test generation
curl -X POST https://your-app-url/api/generate \
  -H "Content-Type: application/json" \
  -d '{"prompt":"Build a todo app"}'

# Test example
curl https://your-app-url/api/example
```

---

## Support

For deployment issues:
1. Check platform-specific documentation
2. Review application logs
3. Test locally first
4. Use health endpoint for diagnostics

---

*Choose your deployment platform and go live! 🚀*