Added Files to HF space

Contains all the required files

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -0,0 +1,20 @@
+# Use Python base image
+FROM python:3.12-slim-trixie
+
+# Copy UV directly from official image
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+# Set working directory
+WORKDIR /app
+
+# Copy only dependency files first
+COPY pyproject.toml ./
+
+# Install dependencies using UV sync
+RUN /bin/uv sync
+
+# Now copy application files
+COPY main.py llm_utils.py ./
+
+# Run the application using UV
+CMD ["/bin/uv", "run", "main.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 22f3000730
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,70 @@
----
-title: CodeGen
-emoji: 🦀
-colorFrom: pink
-colorTo: red
-sdk: docker
-pinned: false
-license: mit
-short_description: This is the space created for TDS project 1
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CodeGen
+
+A FastAPI service that generates single-page web applications using AI. This service takes natural language descriptions and automatically generates web applications, creates GitHub repositories, and handles deployments.
+
+## Features
+
+-  AI-powered web application generation
+-  Automatic GitHub repository creation and management
+-  GitHub Pages hosting setup
+-  Built-in evaluation submission handling
+-  Support for multi-round updates
+-  Secure API with secret key authentication
+
+## Requirements
+
+- Python 3.10 or higher
+- GitHub account with API access
+- AI API key (OpenRouter)
+
+## Setup
+
+1. Clone the repository:
+   ```bash
+   git clone <repo url or ssh>
+   cd codegen
+   ```
+
+2. Create a virtual environment:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. Create a `.env` file with your credentials:
+   ```
+   SECRET_KEY=your_secret
+   GITHUB_TOKEN=your_github_token
+   AI_API_KEY=your_ai_key
+   ```
+
+4. Install dependencies:
+   ```bash
+   uv sync
+   ```
+
+5. Install development dependencies:
+   ```bash
+   uv sync -G dev
+   ```
+
+## Usage
+
+Start the development server:
+```bash
+uvicorn main:app --reload
+```
+
+The server will listen on `http://localhost:8000` for incoming task requests.
+
+### API Endpoints
+
+- `GET /`: Health check endpoint
+- `POST /task1`: Main endpoint for task processing
+  - Requires authentication via `secret` field
+  - Handles both initial creation (round 1) and updates (round > 1)
+  - Returns repository and GitHub Pages URLs
+
+## License
+
+MIT License - See LICENSE file for details

docker-compose.yml

@@ -0,0 +1,11 @@
+services:
+  web:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - SECRET_KEY=${SECRET_KEY}
+      - GITHUB_TOKEN=${GITHUB_TOKEN}
+      - AI_API_KEY=${AI_API_KEY}
+    volumes:
+      - .:/app

llm_utils.py

@@ -0,0 +1,135 @@
+# llm_utils.py
+import os
+import requests
+import re
+import json
+from typing import Optional, List, Dict, Any
+from github import Github
+
+def generate_app_files(brief: str, checks: List[str], attachments: Optional[List[Dict[str, str]]] = None, round: int = 1, task: str = None) -> Dict[str, Any]:
+    api_key = os.getenv("AI_API_KEY")
+    github_token = os.getenv("GITHUB_TOKEN")
+    if not api_key:
+        raise RuntimeError("AI_API_KEY environment variable is required")
+
+    # Get existing code for rounds > 1
+    existing_files = {}
+    if round > 1 and github_token and task:
+        try:
+            g = Github(github_token)
+            user = g.get_user()
+            # Just use the task name as repo name, don't include user login
+            repo = g.get_repo(f"{user.login}/{task}")
+            for filename in ["index.html", "README.md"]:
+                try:
+                    file_content = repo.get_contents(filename)
+                    existing_files[filename] = file_content.decoded_content.decode('utf-8')
+                except Exception as e:
+                    print(f"Failed to fetch {filename}: {str(e)}")
+        except Exception as e:
+            print(f"Failed to access repository: {str(e)}")
+
+    # Modify system message to include context for updates
+    system_msg = (
+        'Create a single-page web application that implements the requirements.\n\n'
+        'Output format - JSON object with:\n'
+        '- "index": Complete HTML file with implementation\n'
+        '- "README": Documentation markdown file\n\n'
+        'Technical requirements:\n'
+        '1. Process data client-side\n'
+        '2. Use CDN libraries when needed\n'
+        '3. Base64 handling:\n'
+        '   - Keep ${...} strings in data URIs as-is\n'
+        '   - Do not try to decode template literals\n'
+        '   - Example: data:text/csv;base64,${someBase64} should be used directly\n'
+        '4. Match exact IDs from brief\n'
+        '5. Handle all test conditions\n\n'
+        'Best practices:\n'
+        '- Process encoded data at runtime\n'
+        '- Keep template literals intact\n'
+        '- Include error handling\n'
+        '- Verify all test checks pass'
+    )
+
+    if round > 1 and existing_files:
+        system_msg += (
+            '\n\nUpdate mode:\n'
+            '- Use existing files as base\n'
+            '- Preserve working features\n'
+            '- Add new requirements\n'
+            '- Maintain code structure\n'
+            '- Use the attachments if provided\n'
+        )
+
+    # Prepare messages and make direct request to OpenRouter
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+
+    # Prepare user message with clearer context
+    user_payload = {
+        "brief": brief,
+        "checks": checks,
+        "attachments": attachments,
+        "round": round,
+        "note": "Important: Keep ${...} template literals intact in data URIs"
+    }
+    if existing_files:
+        user_payload["existing_files"] = existing_files
+
+    payload = {
+        "model": "qwen/qwen3-coder",
+        "messages": [
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": json.dumps(user_payload, ensure_ascii=False, indent=2)}
+        ]
+    }
+
+    resp = requests.post(
+        "https://aipipe.org/openrouter/v1/chat/completions",
+        headers=headers,
+        json=payload
+    )
+
+    if not resp.ok:
+        raise RuntimeError(f"API request failed: {resp.status_code} {resp.text}")
+
+    # Extract content from OpenRouter response format
+    try:
+        content = resp.json()["choices"][0]["message"]["content"]
+    except Exception as e:
+        content = str(resp.text)
+
+    # Attempt to extract JSON substring if wrapped in markdown or extra text
+    json_obj = None
+    try:
+        json_obj = json.loads(content)
+    except Exception:
+        # Try to find the first {...} JSON block (non-greedy to avoid trailing text)
+        m = re.search(r"\{(?:[^{}]|(?R))*\}", content, re.S) if hasattr(re, 'R') else re.search(r"\{.*\}", content, re.S)
+        if m:
+            try:
+                json_obj = json.loads(m.group(0))
+            except Exception:
+                json_obj = None
+
+    # If parsing succeeded and has required keys, normalize and return it
+    if isinstance(json_obj, dict) and "index" in json_obj and "README" in json_obj:
+        result = {"index": json_obj["index"], "README": json_obj["README"]}
+        assets = json_obj.get("assets")
+        if isinstance(assets, dict):
+            # Ensure asset keys and values are strings
+            sanitized_assets: Dict[str, str] = {}
+            for k, v in assets.items():
+                if isinstance(k, str) and (isinstance(v, str) or v is None):
+                    sanitized_assets[k] = v or ""
+            if sanitized_assets:
+                result["assets"] = sanitized_assets
+        return result
+
+    # Fallback: return the assistant output as the index.html and a basic README
+    return {
+        "index": content,
+        "README": f"# {brief}\n\n{content}",
+    }

main.py

@@ -0,0 +1,149 @@
+# main.py
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from pydantic import BaseModel
+import requests,time, os
+from dotenv import load_dotenv
+from github import Github  # from PyGithub
+from llm_utils import generate_app_files  # your LLM logic
+from typing import Optional, List, Dict
+
+app = FastAPI()
+load_dotenv()  # take environment variables from .env
+
+SHARED_SECRET = os.getenv("SECRET_KEY")
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+
+class TaskRequest(BaseModel):
+    email: str
+    task: str
+    brief: str
+    checks: List[str]
+    round: int
+    nonce: str
+    secret: str
+    evaluation_url: str
+    attachments: Optional[List[Dict[str, str]]] = None  # added to accept attachments like data URIs
+
+@app.get("/")
+def root():
+    return {"status": "ok"}
+
+async def process_task_in_background(req: TaskRequest):
+    # 2. Generate files and handle repo based on round
+    app_files = generate_app_files(
+        brief=req.brief, 
+        checks=req.checks, 
+        attachments=req.attachments,
+        round=req.round,
+        task=req.task
+    )
+
+    # Validate LLM output
+    if not isinstance(app_files, dict) or "index" not in app_files or "README" not in app_files:
+        raise HTTPException(status_code=500, detail="LLM did not return expected file structure")
+
+    # Initialize GitHub client
+    g = Github(GITHUB_TOKEN)
+    user = g.get_user()
+    repo_name = f"{req.task}"
+
+    if req.round == 1:
+        # Round 1: Create new repo
+        try:
+            repo = user.create_repo(repo_name, private=False, auto_init=False, license_template="mit")
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to create repo: {e}")
+    else:
+        # Round >1: Get existing repo and update
+        try:
+            # Use get_repo with full path
+            repo = g.get_repo(f"{user.login}/{repo_name}")
+        except Exception as e:
+            raise HTTPException(status_code=404, detail=f"Repository not found: {e}")
+
+    # Prepare files to commit
+    files_to_commit = {
+        "index.html": app_files["index"],
+        "README.md": app_files["README"],
+    }
+    if isinstance(app_files.get("assets"), dict):
+        files_to_commit.update(app_files["assets"])
+
+    # Add/Update files & commit
+    for path, content in files_to_commit.items():
+        try:
+            if req.round == 1:
+                # Create new file for round 1
+                repo.create_file(path, f"add {path}", content)
+            else:
+                # Update existing file for later rounds
+                try:
+                    # Get current file content
+                    file = repo.get_contents(path)
+                    # Update file
+                    repo.update_file(path, f"update {path} for round {req.round}", content, file.sha)
+                except Exception:
+                    # File doesn't exist, create it
+                    repo.create_file(path, f"add {path} for round {req.round}", content)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to handle file {path}: {e}")
+
+    # Enable GitHub Pages only for round 1
+    if req.round == 1:
+        try:
+            requests.post(
+                f"https://api.github.com/repos/{user.login}/{repo_name}/pages",
+                headers={
+                    "Authorization": f"token {GITHUB_TOKEN}",
+                    "Accept": "application/vnd.github.v3+json",
+                },
+                json={"source": {"branch": "main", "path": "/"}}
+            )
+        except Exception:
+            pass
+
+    # Get latest commit SHA
+    commit_sha = repo.get_commits()[0].sha
+
+    # Prepare evaluation JSON
+    payload = {
+        "email": req.email,
+        "task": req.task,
+        "round": req.round,
+        "nonce": req.nonce,
+        "repo_url": repo.html_url,
+        "commit_sha": commit_sha,
+        "pages_url": f"https://{user.login}.github.io/{repo_name}/",
+    }
+
+
+    time.sleep(60)
+
+    # 8. POST to evaluation URL (with exponential backoff) — include JSON Content-Type & try up to 5 times
+    delay = 1
+    headers = {"Content-Type": "application/json"}
+    for _ in range(5):
+        try:
+            r = requests.post(req.evaluation_url, json=payload, headers=headers, timeout=10)
+            if r.status_code == 200:
+                break
+        except Exception:
+            pass
+        time.sleep(delay)
+        delay *= 2
+
+@app.post("/task1")
+async def handle_task(req: TaskRequest, background_tasks: BackgroundTasks):
+    # 1. Secret verification
+    if req.secret != SHARED_SECRET:
+        raise HTTPException(status_code=403, detail="Invalid secret")
+
+    # Add the processing to background tasks
+    background_tasks.add_task(process_task_in_background, req)
+
+    # Return simple acknowledgment
+    return {"status": "accepted", "message": "Request received and processing"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "codegen"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "dotenv>=0.9.9",
+    "fastapi>=0.119.0",
+    "openai>=2.3.0",
+    "pygithub>=2.8.1",
+    "requests>=2.32.5",
+    "uvicorn>=0.37.0",
+]