round 1 complete

app/deployer.py

@@ -5,6 +5,7 @@ import base64
 from dotenv import load_dotenv
 from typing import List,Optional
 from .models import FileContext
+from .utils import retry_request
 load_dotenv()
 
 
@@ -33,84 +34,144 @@ async def create_github_repo(repo_name: str) -> dict:
             logger.error(f"Failed to create GitHub repo: {e}")
             raise RuntimeError(f"GitHub repo creation failed: {e}") from e
 
-async def get_latest_commit_sha(repo: str,):
+async def get_latest_commit_sha(repo: str):
         async with httpx.AsyncClient() as client:
             try:
-
                 ref_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/git/ref/heads/main"
                 ref_resp = await client.get(ref_url, headers=headers)
+                if ref_resp.status_code in (404, 409):
+                    return None
                 ref_resp.raise_for_status()
                 ref_data = ref_resp.json()
                 commit_sha = ref_data["object"]["sha"]
                 return commit_sha
-            
             except httpx.HTTPStatusError as http_err:
-                if http_err.response.status_code == 409:
-                    logger.warning(f"Repository {OWNER}/{repo} is empty, no commits found.")
+                if http_err.response.status_code in {404, 409}:
+                # Branch not found or repo empty --> no commits yet
                     return None
-                logger.error(f"GitHub API request failed: {http_err.response.status_code} {http_err.response.text}")
-                raise
-            except httpx.RequestError as req_err:
-                logger.error(f"Network error while calling GitHub API: {req_err}")
-                raise
-            except Exception as exc:
-                logger.error(f"Unexpected error during GitHub commit: {exc}", exc_info=True)
-                raise
+            raise
+            
+async def create_initial_commit(repo: str):
+    """
+    Create initial commit in an empty GitHub repo by adding README.md file.
+    """
+    url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/contents/README.md"
+    readme_content = "# Initial Commit\n\nThis is the initial commit."
+    encoded_content = base64.b64encode(readme_content.encode("utf-8")).decode("utf-8")
+    payload = {
+        "message": "Initial commit with README.md",
+        "content": encoded_content,
+        "branch": "main"
+    }
 
 
+    async with httpx.AsyncClient() as client:
+        resp = await retry_request(client.put, url, headers=headers, json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+async def get_tree_sha(repo: str, commit_sha: str) -> str:
+    commit_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/git/commits/{commit_sha}"
+    async with httpx.AsyncClient() as client:
+        commit_resp = await retry_request(client.get, commit_url, headers=headers)
+        commit_resp.raise_for_status()
+        return commit_resp.json()["tree"]["sha"]
+
+async def create_blob(repo: str, file: FileContext) -> str:
+    blob_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/git/blobs"
+    blob_payload = {
+        "content": file.file_content,
+        "encoding": "utf-8"
+    }
+    async with httpx.AsyncClient() as client:
+        blob_resp = await retry_request(client.post, blob_url, headers=headers, json=blob_payload)
+        blob_resp.raise_for_status()
+        return blob_resp.json()["sha"]
+    
+async def create_tree(repo: str, tree_sha: Optional[str], blob_entries: List[dict]) -> str:
+    tree_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/git/trees"
+    tree_payload = {"tree": blob_entries}
+    if tree_sha:
+        tree_payload["base_tree"] = tree_sha
+    async with httpx.AsyncClient() as client:
+        tree_resp = await retry_request(client.post, tree_url, headers=headers, json=tree_payload)
+        tree_resp.raise_for_status()
+        return tree_resp.json()["sha"]
+
+async def create_commit(repo: str, commit_message: str, new_tree_sha: str, commit_sha: Optional[str]) -> str:
+    commit_payload = {
+        "message": commit_message,
+        "tree": new_tree_sha,
+    }
+    if commit_sha:
+        commit_payload["parents"] = [commit_sha]
+
+    new_commit_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/git/commits"
+    async with httpx.AsyncClient() as client:
+        new_commit_resp = await retry_request(client.post, new_commit_url, headers=headers, json=commit_payload)
+        new_commit_resp.raise_for_status()
+        return new_commit_resp.json()["sha"]
+    
+async def update_ref(repo: str, new_commit_sha: str, commit_sha_exists: bool):
+    update_ref_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/git/refs/heads/main"
+    async with httpx.AsyncClient() as client:
+        if not commit_sha_exists:
+            # Create ref since it doesn't exist yet
+            ref_create_payload = {
+                "ref": f"refs/heads/main",
+                "sha": new_commit_sha,
+            }
+            update_resp = await retry_request(client.post, update_ref_url.replace("/git/refs/heads", "/git/refs"), headers=headers, json=ref_create_payload)
+        else:
+            update_resp = await retry_request(client.patch, update_ref_url, headers=headers, json={"sha": new_commit_sha})
+
+        update_resp.raise_for_status()
 
 async def push_files_to_github_repo(
     repo: str,
     files: List[FileContext],
-    commit_message: str = "Add generated files",
-) -> Optional[str]:
+    commit_message: str = "Add generated project files",
+):
     """
-    Pushes files individually to the GitHub repo using the 'create or update file' API endpoint.
-    Returns the SHA of the last commit made.
+    Pushes files to a GitHub repository via REST API by creating or updating blobs and commits.
     """
+    commit_sha = await get_latest_commit_sha(repo)
+    # Create initial commit if repo is empty
+    if commit_sha is None:
+        logger.info(f"No commits found in {repo}. Creating initial commit.")
+        await create_initial_commit(repo)
+        commit_sha = await get_latest_commit_sha(repo)
+        if commit_sha is None:
+            raise RuntimeError("Failed to create initial commit")
 
-    last_commit_sha = None
+    commit_sha_exists = bool(commit_sha)
 
     async with httpx.AsyncClient() as client:
-        for file in files:
-            try:
-                url = f"https://api.github.com/repos/{OWNER}/{repo}/contents/{file.file_name}"
-
-                # Check if the file exists to get its sha (required for updates)
-                get_resp = await client.get(url, headers=headers, params={"ref": "main"})
-                if get_resp.status_code == 200:
-                    sha = get_resp.json()["sha"]
-                elif get_resp.status_code == 404:
-                    sha = None  # File doesn't exist, create new
-                else:
-                    get_resp.raise_for_status()  # Raise for other HTTP errors
-
-                payload = {
-                    "message": commit_message,
-                    "content": base64.b64encode(file.file_content.encode("utf-8")).decode("utf-8"),
-                    "branch": "main",
-                }
-                if sha:
-                    payload["sha"] = sha
-
-                resp = await client.put(url, headers=headers, json=payload)
-                resp.raise_for_status()
-
-                last_commit_sha = resp.json()["commit"]["sha"]
-                logger.info(f"Committed {file.file_name} (sha: {last_commit_sha})")
-
-            except httpx.HTTPStatusError as http_err:
-                logger.error(f"GitHub API HTTP error for file {file.file_name}: {http_err.response.status_code} {http_err.response.text}")
-                raise
-            except httpx.RequestError as req_err:
-                logger.error(f"Network error while pushing file {file.file_name}: {req_err}")
-                raise
-            except Exception as exc:
-                logger.error(f"Unexpected error for file {file.file_name}: {exc}", exc_info=True)
-                raise
-
-    return last_commit_sha
+        try:
+            tree_sha = None
+            if commit_sha_exists:
+                tree_sha = await get_tree_sha(repo, commit_sha)
+
+            blob_entries = []
+            for file in files:
+                blob_sha = await create_blob(repo, file)
+                blob_entries.append({
+                    "path": file.file_name,
+                    "mode": "100644",
+                    "type": "blob",
+                    "sha": blob_sha,
+                })
+
+            new_tree_sha = await create_tree(repo, tree_sha, blob_entries)
+            new_commit_sha = await create_commit(repo, commit_message, new_tree_sha, commit_sha)
+            await update_ref(repo, new_commit_sha, commit_sha_exists)
+
+            logger.info(f"Committed files to {OWNER}/{repo}@main with commit SHA {new_commit_sha}")
+            return  new_commit_sha
 
+        except Exception as e:
+            logger.error(f"Error pushing files to GitHub repo: {e}", exc_info=True)
+            raise
 
 async def enable_github_pages(repo: str):
     url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/pages"
@@ -123,13 +184,29 @@ async def enable_github_pages(repo: str):
 
     async with httpx.AsyncClient() as client:
         try:
-            response = await client.post(url, json=payload, headers=headers)
+            response = await retry_request(client.post, url, json=payload, headers=headers)
             response.raise_for_status()
+            json_data = response.json()
             logger.info(f"GitHub Pages enabled for {OWNER}/{repo}@main/")
-            return response.json()
+            return {
+                "repo_url": f"https://github.com/{OWNER}/{repo}",
+                "pages_url": json_data.get("html_url")
+            }
         except httpx.HTTPStatusError as exc:
-            logger.error(f"Failed to enable GitHub Pages: {exc.response.status_code} - {exc.response.text}")
-            raise
+            if exc.response.status_code == 409:
+                # Pages already enabled, fetch existing pages info instead of error
+                info_url = f"{GITHUB_API_URL}repos/{OWNER}/{repo}/pages"
+                info_resp = await client.get(info_url, headers=headers)
+                info_resp.raise_for_status()
+                data = info_resp.json()
+                logger.info(f"GitHub Pages already enabled for {OWNER}/{repo}@main/")
+                return {
+                    "repo_url": f"https://github.com/{OWNER}/{repo}",
+                    "pages_url": data.get("html_url")
+                }
+            else:
+                logger.error(f"Failed to enable GitHub Pages: {exc.response.status_code} - {exc.response.text}")
+                raise
         except Exception as e:
             logger.error(f"Unexpected error enabling GitHub Pages: {str(e)}")
             raise

app/llm.py

@@ -10,12 +10,30 @@ logging.basicConfig(level=logging.INFO)
 
 
 async def genereate_code_with_llm(request: TaskRequest) -> List[FileContext]:
+
+     # Prepare brief and attachment context
+    attachments_text = ""
+    if request.attachments and len(request.attachments) > 0:
+        attachments_text = "\nAttachments:\n" + "\n".join([f"- {att.name}: {att.url[:80]}..." for att in request.attachments])
+    else:
+        attachments_text = "\n(No attachments were provided with the request)"
+
     prompt = f"""
 Generate a complete static website project that is deployable on GitHub Pages.
 
 Brief: {request.brief}
 
+attachments (if any): {attachments_text}
+
+Checks to be satisfied:
+{f"{request.checks}" if getattr(request, "checks", None) else "(No explicit checks provided)"}
+
+
 Requirements:
+- Use the attachments provided (if any). For example, if a CSV file, image, or data file is attached,
+  the generated site should correctly reference and use it in the codebase.
+- Use data URIs as the source for attachments when embedding or referencing them (e.g., <img src="data:image/png;base64,..."> or fetch inline encoded data directly from JS).
+- If attachments are present, they should be used within the project logically matching the task description.
 - Provide all files necessary for deployment including at least an index.html.
 - Write a thorough README.md that includes:
   - Project summary
@@ -23,6 +41,13 @@ Requirements:
   - Usage guide
   - Explanation of the main code/files
   - License information (use MIT)
+- Carefully read the provided "checks" section. Each listed check represents a requirement that must be fulfilled by the project files and behavior. 
+- Checks can include both human-readable and programmatic JavaScript expressions.
+- Implement all behaviors required so that JavaScript-based checks evaluate as true when tested.
+- For checks beginning with `js:`:
+  - Ensure your HTML, CSS, and JavaScript code produces behavior consistent with the JS expressions listed.
+  - Implement any specified DOM updates, calculations, links, or asynchronous logic needed.
+- Produce the project in such a way that every listed check passes successfully when evaluated automatically by test scripts or human reviewers.
 - The project must follow industry standards for static GitHub Pages hosting.
 - Return the project as a list of files with filenames and file contents.
 - All code should be modern and ready to deploy without modification.
@@ -35,29 +60,48 @@ Return only a JSON array of objects where each object has:
     system_prompt = """
 You are a highly experienced senior developer specializing in creating GitHub Pages-ready static websites.
 
-Your task is to generate a production-ready, modern, and industry-standard static website project based on the user’s brief.
+Your goal is to produce a production-ready project based on the provided task brief and optional attachments.
+The user may include one or more attachments, such as images, CSV data files, or other static assets encoded as Data URIs.
+
 
 Specifically, ensure you do the following:
 
-1. Create all necessary files to fully deploy a static website on GitHub Pages, including but not limited to:
+1. Process the task brief carefully to understand the required site behavior and structure.
+2. If attachments are provided:
+   - Treat them as first-class project assets.
+   - Use `data:` URLs where appropriate (for images, CSV, JSON, etc.).
+   - If a CSV or data file is attached, the project should load and use it accordingly in the site logic.
+   - If images are attached, include them visually or reference them as part of the static content.
+3. Create all necessary files to fully deploy a static website on GitHub Pages, including but not limited to:
    - index.html (the homepage)
    - any required CSS, JS, or asset files
    - configuration files (e.g., CNAME, if needed)
-2. Write a complete, professional README.md file containing:
+4. Write a complete, professional README.md file containing:
    - A clear project summary describing what the site does
    - Setup instructions to deploy the project on GitHub Pages step-by-step
    - Usage instructions, explaining how to use the website
    - Explanation of the key code files and their purpose
    - License information, applying the MIT license in standard format
-3. Ensure all source code and resources are clean, properly structured, and follow modern best practices
-4. Format your output as a list of files, with each containing a file_name and file_content field
-5. Do not include text explanations in the output; only return the code files and README as specified
-6. Output format:
+5. Ensure all source code and resources are clean, properly structured, and follow modern best practices
+6. Ensure the code Strictly fulfills every check listed in "checks" section . "checks" = explicit criteria the generated site will be tested against (either human-readable or
+     programmatic checks such as JavaScript expressions beginning with `js:`).
+     - Behavior and compliance:
+   - Implement code so that all **JavaScript-based checks (`js:`)** evaluate to `true` 
+     when the resulting page runs in a browser.
+   - Satisfy any conditions mentioned in the `checks` — including DOM structure,
+     CSS links (like `<link href*='bootstrap'>`), and computed dynamic values.
+   - If a check includes formulas, like 
+     `Math.abs(parseFloat(document.querySelector('#total-sales').textContent) - ${result}) < 0.01`,
+     ensure your JavaScript logic dynamically computes matching values at runtime.
+   - Include any required scripts or libraries (e.g., Bootstrap 5 from jsDelivr).
+7. Format your output as a list of files, with each containing a file_name and file_content field
+8. Do not include text explanations in the output; only return the code files and README as specified
+9. Output format:
 Return only a JSON array of objects where each object has:
 - "file_name": string
 - "file_content": string
 
-The user will provide a brief describing the site functionality. Use that to guide your file generation.
+The user will provide a brief describing the site functionality along with attachments (optional). Use these to guide your file generation.
 
 Focus on quality, clarity, and correctness to deliver a ready-to-use GitHub Pages static website project.
 """

app/models.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Optional,Any
 from pydantic import BaseModel
 class Attachment(BaseModel):
     name: str
@@ -11,7 +11,7 @@ class TaskRequest(BaseModel):
     round: int
     nonce: str
     brief: str
-    checks: List[str]
+    checks: Any
     evaluation_url: str
     attachments: Optional[List[Attachment]] = None
 

app/rounds.py

@@ -16,8 +16,8 @@ async def  round1(request: TaskRequest):
         commit_sha = await push_files_to_github_repo(repo=request.task,files=files)
         # commit_sha = await push_files_to_github_repo(repo=request.task)
         
-        pages_response = await enable_github_pages(repo=request.task)
-        pages_url = pages_response.get("html_url")
+        pages_reponse = await enable_github_pages(repo=request.task)
+        pages_url = pages_reponse.get("pages_url")
 
         # Prepare payload
         payload = {

app/utils.py

@@ -1,7 +1,30 @@
 import os
+import httpx
+import logging
+import asyncio
 API_SECRET = os.getenv("API_SECRET", "shamil")
 
+
+logger = logging.getLogger(__name__)
+
 def validate_secret(secret: str) -> bool:
     # Constant-time comparison to prevent timing attacks
     from hmac import compare_digest
     return compare_digest(secret, API_SECRET)
+
+
+async def retry_request(func, *args, retries=3, delay=3, **kwargs):
+    last_exc = None
+    for attempt in range(retries):
+        try:
+            return await func(*args, **kwargs)
+        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+            last_exc = e
+            logger.warning(f"Request failed on attempt {attempt + 1}/{retries}: {e}")
+            if attempt < retries - 1:
+                await asyncio.sleep(delay)
+            else:
+                logger.error("Max retries reached.")
+                raise last_exc
+    if last_exc:
+        raise last_exc