Upload 15 files

.gitignore

@@ -0,0 +1,61 @@
+# Environment variables
+.env
+.env.local
+.env.production
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs
+logs/
+*.log
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Docker
+.dockerignore
+
+# Temporary files
+*.tmp
+*.temp

Dockerfile

@@ -27,8 +27,8 @@ USER app
 EXPOSE 8000
 
 # Health check
-HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
-    CMD python -c "import requests; requests.get('http://localhost:8000/health')"
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"
 
 # Start command
 CMD ["python", "main.py"]

README.md

@@ -1,11 +1,272 @@
----
-title: Prj1
-emoji: 👀
-colorFrom: purple
-colorTo: indigo
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LLM Code Deployment
+
+A full-stack backend system that automates app building and deployment using LLMs and GitHub Pages. This system receives task briefs, generates minimal working web applications using Groq API with Llama models, and automatically deploys them to GitHub Pages.
+
+## 🚀 Features
+
+- **Automated App Generation**: Uses Groq API with Llama models to generate complete HTML/CSS/JS applications
+- **GitHub Integration**: Automatically creates repositories and enables GitHub Pages
+- **Round-based Development**: Supports initial creation and revision rounds
+- **Evaluation API Integration**: Posts deployment metadata to external evaluation systems
+- **Production-ready**: Built with FastAPI, includes proper error handling and logging
+- **Security**: Shared secret authentication and input validation
+
+## 🏗️ Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Client        │    │   FastAPI       │    │   Groq API      │
+│   Request       │───▶│   Backend       │───▶│   (Llama)       │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+                                │
+                                ▼
+                       ┌─────────────────┐    ┌─────────────────┐
+                       │   GitHub        │    │   Evaluation    │
+                       │   API           │───▶│   API           │
+                       └─────────────────┘    └─────────────────┘
+```
+
+## 📋 Prerequisites
+
+- Python 3.8+
+- Groq API key
+- GitHub Personal Access Token
+- GitHub account with Pages enabled
+
+## 🛠️ Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone <repository-url>
+   cd llm-code-deployment
+   ```
+
+2. **Create virtual environment**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set up environment variables**
+   ```bash
+   cp env.template .env
+   ```
+   
+   Edit `.env` with your actual values:
+   ```env
+   # OpenAI/OpenRouter Configuration
+   OPENAI_API_KEY=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
+   OPENAI_MODEL=gpt-4o-mini
+   
+   # GitHub Configuration
+   GITHUB_TOKEN=your_github_personal_access_token_here
+   GITHUB_USERNAME=your_github_username_here
+   
+   # Security
+   SHARED_SECRET=your_shared_secret_here
+   
+   # Server Configuration
+   HOST=0.0.0.0
+   PORT=8000
+   DEBUG=false
+   ```
+
+## 🔧 Configuration
+
+### OpenRouter Setup
+1. Get an API key from `https://openrouter.ai/`
+2. Set `OPENAI_API_KEY` in your `.env` file
+3. Choose your model (default: `gpt-4o-mini`)
+
+### GitHub Setup
+1. Create a Personal Access Token:
+   - Go to GitHub Settings → Developer settings → Personal access tokens
+   - Generate new token with `repo` and `pages` scopes
+2. Set `GITHUB_TOKEN` and `GITHUB_USERNAME` in your `.env` file
+
+### Security
+- Set a strong `SHARED_SECRET` for API authentication
+- Configure CORS origins appropriately for production
+
+## 🚀 Running the Application
+
+### Development Mode
+```bash
+python main.py
+```
+
+### Production Mode
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+The API will be available at:
+- **API Documentation**: http://localhost:8000/docs
+- **Alternative Docs**: http://localhost:8000/redoc
+- **Health Check**: http://localhost:8000/health
+
+## 📡 API Endpoints
+
+### POST `/api/request`
+Main endpoint for processing app generation requests.
+
+**Request Body:**
+```json
+{
+  "email": "[email protected]",
+  "secret": "your_shared_secret",
+  "task": "Create a todo app",
+  "round": 1,
+  "nonce": "unique_request_id",
+  "brief": "A simple todo application with add, edit, delete functionality",
+  "evaluation_url": "https://evaluation-api.example.com/notify",
+  "attachments": []
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Application generated and deployed successfully",
+  "deployment": {
+    "repo_name": "llm-app-todo-20241201120000",
+    "repo_url": "https://github.com/username/llm-app-todo-20241201120000",
+    "commit_sha": "abc123def456",
+    "pages_url": "https://username.github.io/llm-app-todo-20241201120000"
+  },
+  "evaluation_notification": {
+    "sent": true,
+    "status_code": 200
+  },
+  "metadata": {
+    "round": 1,
+    "nonce": "unique_request_id",
+    "timestamp": "2024-12-01T12:00:00Z"
+  }
+}
+```
+
+### POST `/api/evaluate`
+Endpoint for receiving evaluation data.
+
+**Request Body:**
+```json
+{
+  "email": "[email protected]",
+  "task": "Create a todo app",
+  "round": 1,
+  "nonce": "unique_request_id",
+  "evaluation_data": {
+    "score": 85,
+    "feedback": "Good functionality, needs better styling"
+  }
+}
+```
+
+### GET `/health`
+Health check endpoint.
+
+## 🔄 Workflow
+
+1. **Receive Request**: API validates secret and request format
+2. **Generate App**: OpenRouter/OpenAI-compatible API creates HTML/CSS/JS based on task brief
+3. **Create Repository**: GitHub repo is created with generated files
+4. **Enable Pages**: GitHub Pages is automatically enabled
+5. **Notify Evaluation**: Deployment metadata is sent to evaluation API
+6. **Return Response**: Client receives repo URLs and deployment info
+
+## 🔧 Development
+
+### Project Structure
+```
+llm-code-deployment/
+├── main.py              # FastAPI application
+├── llm_helper.py        # Groq API integration
+├── github_helper.py     # GitHub API integration
+├── deploy_helper.py     # Evaluation API communication
+├── requirements.txt     # Python dependencies
+├── env.template         # Environment variables template
+└── README.md           # This file
+```
+
+### Adding New Features
+
+1. **New LLM Models**: Modify `llm_helper.py` to support additional Groq models
+2. **Database Integration**: Add SQLAlchemy models for request logging
+3. **Authentication**: Implement JWT or OAuth for enhanced security
+4. **Monitoring**: Add metrics and health checks
+
+### Testing
+
+```bash
+# Install test dependencies
+pip install pytest pytest-asyncio httpx
+
+# Run tests
+pytest
+```
+
+## 🚨 Error Handling
+
+The system includes comprehensive error handling:
+
+- **Validation Errors**: Invalid request format or missing fields
+- **Authentication Errors**: Invalid shared secret
+- **LLM Errors**: API failures or invalid responses
+- **GitHub Errors**: Repository creation or Pages setup failures
+- **Network Errors**: Evaluation API communication failures
+
+All errors are logged and return appropriate HTTP status codes.
+
+## 🔒 Security Considerations
+
+- **Shared Secret**: Required for all API requests
+- **Input Validation**: All inputs are validated using Pydantic
+- **CORS**: Configurable CORS settings for production
+- **Rate Limiting**: Consider implementing rate limiting for production
+- **HTTPS**: Use HTTPS in production environments
+
+## 📊 Monitoring and Logging
+
+The application includes structured logging:
+
+- **Request Logging**: All API requests are logged
+- **Error Logging**: Detailed error information
+- **Deployment Logging**: GitHub operations and results
+- **Performance Logging**: Request processing times
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🆘 Support
+
+For issues and questions:
+
+1. Check the logs for error details
+2. Verify environment variables are set correctly
+3. Ensure GitHub token has required permissions
+4. Check OpenRouter API key and quota
+
+## 🔮 Future Enhancements
+
+- [ ] Database integration for request history
+- [ ] Webhook support for deployment status
+- [ ] Multiple LLM provider support
+- [ ] Custom domain support for GitHub Pages
+- [ ] Request queuing for high-volume usage
+- [ ] Metrics and analytics dashboard

docker-compose.yml

@@ -18,8 +18,8 @@ services:
       - ./logs:/app/logs
     restart: unless-stopped
     healthcheck:
-      test: ["CMD", "python", "-c", "import requests; requests.get('http://localhost:8000/health')"]
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
       interval: 30s
       timeout: 10s
       retries: 3
-      start_period: 40s
+      start_period: 10s

main.py

@@ -11,7 +11,7 @@ from datetime import datetime
 from fastapi import FastAPI, HTTPException, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 from dotenv import load_dotenv
 
 from llm_helper import LLMHelper, AppGenerationRequest
@@ -87,7 +87,8 @@ class TaskRequest(BaseModel):
     attachments: Optional[list] = Field(default=None, description="Additional attachments or context")
     return_code: Optional[bool] = Field(default=False, description="If true, include generated code in response")
 
-    @validator('secret', always=True)
+    @field_validator('secret', mode='before')
+    @classmethod
     def validate_secret(cls, v):
         # Soft validation: if SHARED_SECRET is set and mismatched, log but do not block
         expected_secret = os.getenv("SHARED_SECRET")
@@ -98,7 +99,8 @@ class TaskRequest(BaseModel):
             pass
         return v
 
-    @validator('evaluation_url', always=True)
+    @field_validator('evaluation_url', mode='before')
+    @classmethod
     def validate_evaluation_url(cls, v):
         # Soft validation: return as-is; invalid URLs will skip notification later
         return v

requirements.txt

@@ -10,3 +10,4 @@ jinja2==3.1.2
 aiofiles==23.2.1
 sqlalchemy==2.0.23
 alembic==1.13.1
+requests==2.32.5

server.err

@@ -0,0 +1 @@
+ERROR:    Error loading ASGI app. Attribute "app" not found in module "main".

start.py

@@ -0,0 +1,101 @@
+"""
+Startup script for LLM Code Deployment
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def check_python_version():
+    """Check if Python version is compatible"""
+    if sys.version_info < (3, 8):
+        print("❌ Python 3.8 or higher is required")
+        print(f"Current version: {sys.version}")
+        return False
+    print(f"✅ Python version: {sys.version.split()[0]}")
+    return True
+
+def check_env_file():
+    """Check if .env file exists"""
+    env_file = Path(".env")
+    if not env_file.exists():
+        print("❌ .env file not found")
+        print("Please copy env.template to .env and configure your settings")
+        return False
+    print("✅ .env file found")
+    return True
+
+def install_dependencies():
+    """Install required dependencies"""
+    try:
+        print("📦 Installing dependencies...")
+        subprocess.run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], 
+                      check=True, capture_output=True)
+        print("✅ Dependencies installed successfully")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to install dependencies: {e}")
+        return False
+
+def run_setup_test():
+    """Run the setup test"""
+    try:
+        print("🧪 Running setup test...")
+        result = subprocess.run([sys.executable, "test_setup.py"], 
+                              capture_output=True, text=True)
+        if result.returncode == 0:
+            print("✅ Setup test passed")
+            return True
+        else:
+            print("❌ Setup test failed:")
+            print(result.stdout)
+            print(result.stderr)
+            return False
+    except Exception as e:
+        print(f"❌ Setup test error: {e}")
+        return False
+
+def start_server():
+    """Start the FastAPI server"""
+    try:
+        print("🚀 Starting LLM Code Deployment server...")
+        print("Server will be available at: http://localhost:8000")
+        print("API documentation: http://localhost:8000/docs")
+        print("Press Ctrl+C to stop the server")
+        print("-" * 50)
+        
+        subprocess.run([sys.executable, "main.py"])
+    except KeyboardInterrupt:
+        print("\n👋 Server stopped")
+    except Exception as e:
+        print(f"❌ Server error: {e}")
+
+def main():
+    """Main startup function"""
+    print("🚀 LLM Code Deployment Startup")
+    print("=" * 40)
+    
+    # Check prerequisites
+    if not check_python_version():
+        sys.exit(1)
+    
+    if not check_env_file():
+        sys.exit(1)
+    
+    # Install dependencies
+    if not install_dependencies():
+        sys.exit(1)
+    
+    # Run setup test
+    if not run_setup_test():
+        print("\n⚠️  Setup test failed, but continuing...")
+        print("You may need to configure your .env file properly")
+    
+    print("\n" + "=" * 40)
+    
+    # Start server
+    start_server()
+
+if __name__ == "__main__":
+    main()

test_setup.py

@@ -0,0 +1,92 @@
+"""
+Simple test script to verify the LLM Code Deployment setup
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+def test_environment_variables():
+    """Test if all required environment variables are set"""
+    load_dotenv()
+    
+    required_vars = [
+        "OPENAI_API_KEY",
+        "GITHUB_TOKEN", 
+        "GITHUB_USERNAME",
+        "SHARED_SECRET"
+    ]
+    
+    missing_vars = []
+    for var in required_vars:
+        if not os.getenv(var):
+            missing_vars.append(var)
+    
+    if missing_vars:
+        print(f"Missing environment variables: {', '.join(missing_vars)}")
+        print("Please set these in your .env file")
+        return False
+    else:
+        print("All required environment variables are set")
+        return True
+
+def test_imports():
+    """Test if all required modules can be imported"""
+    try:
+        import fastapi
+        import uvicorn
+        import openai  # Still using openai package for Groq API
+        import github
+        import httpx
+        import pydantic
+        print("All required packages are installed")
+        return True
+    except ImportError as e:
+        print(f"Missing package: {e}")
+        print("Please run: pip install -r requirements.txt")
+        return False
+
+def test_module_imports():
+    """Test if our custom modules can be imported"""
+    try:
+        from llm_helper import LLMHelper
+        from github_helper import GitHubHelper
+        from deploy_helper import DeployHelper
+        print("All custom modules can be imported")
+        return True
+    except ImportError as e:
+        print(f"Error importing custom modules: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("Testing LLM Code Deployment Setup")
+    print("=" * 40)
+    
+    tests = [
+        test_imports,
+        test_environment_variables,
+        test_module_imports
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test in tests:
+        if test():
+            passed += 1
+        print()
+    
+    print("=" * 40)
+    if passed == total:
+        print(f"All tests passed! ({passed}/{total})")
+        print("Your LLM Code Deployment system is ready to use!")
+        print("\nTo start the server, run:")
+        print("python main.py")
+    else:
+        print(f"{passed}/{total} tests passed")
+        print("Please fix the issues above before running the server")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()