Spaces:

ruslanmv
/

autoapp-builder

Sleeping

App Files Files Community

ruslanmv commited on Mar 31

Commit

2c304fc

verified ·

1 Parent(s): 83ccd6c

feat: complete AutoApp Builder - AI-powered HF Space generator

Browse files

Files changed (20) hide show

.gitignore +12 -0
Dockerfile +20 -0
README.md +27 -6
app/__init__.py +0 -0
app/codegen/__init__.py +0 -0
app/codegen/docker_generator.py +367 -0
app/codegen/gradio_generator.py +444 -0
app/codegen/readme_generator.py +216 -0
app/codegen/repo_generator.py +333 -0
app/engine/__init__.py +0 -0
app/engine/app_planner.py +279 -0
app/engine/model_recommender.py +192 -0
app/main.py +326 -0
app/static/app.js +211 -0
app/templates/base.html +187 -0
app/templates/home.html +236 -0
app/templates/result.html +217 -0
app/validators/__init__.py +0 -0
app/validators/code_checker.py +191 -0
requirements.txt +6 -0

.gitignore ADDED Viewed

	@@ -0,0 +1,12 @@

+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.env
+.venv/
+venv/
+generated/
+*.zip
+.DS_Store

Dockerfile ADDED Viewed

	@@ -0,0 +1,20 @@

+FROM python:3.11-slim
+WORKDIR /app
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN useradd -m -u 1000 appuser
+RUN mkdir -p /app/generated && chown -R appuser:appuser /app
+USER appuser
+EXPOSE 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md CHANGED Viewed

@@ -1,10 +1,31 @@
 ---
-title: Autoapp Builder
-emoji: 🐨
-colorFrom: indigo
-colorTo: yellow
 sdk: docker
-pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
+title: AutoApp Builder
+emoji: "\U0001F3D7\uFE0F"
+colorFrom: blue
+colorTo: blue
 sdk: docker
+app_port: 7860
+pinned: true
+license: mit
+short_description: Generate HF Spaces from natural language
 ---
+# AutoApp Builder
+Generate complete, working Hugging Face Space repositories from natural language descriptions.
+## Features
+- **Smart SDK Selection** - Automatically chooses Gradio, Docker, or Static based on your app description
+- **LLM-Powered Code Generation** - Uses state-of-the-art models to generate real, working code
+- **Model Recommendations** - Suggests the best HF models for your use case
+- **Code Preview** - Syntax-highlighted preview of all generated files
+- **ZIP Download** - Download the complete repo ready to upload to HF Spaces
+- **Iterative Editing** - Refine your generated app with follow-up prompts
+## How It Works
+1. Describe your app idea in natural language
+2. AutoApp Builder analyzes your prompt and plans the architecture
+3. Working code is generated for every file in the repo
+4. Preview, edit, and download your complete Space

app/__init__.py ADDED Viewed

File without changes

app/codegen/__init__.py ADDED Viewed

File without changes

app/codegen/docker_generator.py ADDED Viewed

	@@ -0,0 +1,367 @@

+"""
+Generate Docker-based (FastAPI) Space code using LLM with template fallbacks.
+"""
+import os
+import re
+from huggingface_hub import InferenceClient
+LLM_MODEL = "Qwen/Qwen2.5-72B-Instruct"
+DOCKER_TEMPLATES = {
+    "rest_api": {
+        "app.py": '''from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from huggingface_hub import InferenceClient
+import os
+app = FastAPI(
+    title="{title}",
+    description="{description}",
+    version="1.0.0",
+)
+client = InferenceClient("{model_id}", token=os.environ.get("HF_TOKEN"))
+class TextRequest(BaseModel):
+    text: str
+    max_tokens: int = 512
+    temperature: float = 0.7
+class TextResponse(BaseModel):
+    result: str
+    model: str
+class SummarizeRequest(BaseModel):
+    text: str
+    max_length: int = 150
+    min_length: int = 30
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    return """
+    <html>
+    <head><title>{title}</title></head>
+    <body style="font-family: system-ui; max-width: 800px; margin: 50px auto; padding: 20px;">
+        <h1>{title}</h1>
+        <p>{description}</p>
+        <h2>Endpoints</h2>
+        <ul>
+            <li><code>POST /generate</code> - Generate text</li>
+            <li><code>POST /summarize</code> - Summarize text</li>
+            <li><code>GET /health</code> - Health check</li>
+            <li><code>GET /docs</code> - API documentation</li>
+        </ul>
+    </body>
+    </html>
+    """
+@app.post("/generate", response_model=TextResponse)
+async def generate_text(request: TextRequest):
+    try:
+        messages = [{{"role": "user", "content": request.text}}]
+        response = client.chat_completion(
+            messages,
+            max_tokens=request.max_tokens,
+            temperature=request.temperature,
+        )
+        return TextResponse(
+            result=response.choices[0].message.content,
+            model="{model_id}",
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+@app.post("/summarize")
+async def summarize_text(request: SummarizeRequest):
+    try:
+        prompt = f"Summarize the following text in a concise way:\\n\\n{{request.text}}"
+        messages = [{{"role": "user", "content": prompt}}]
+        response = client.chat_completion(messages, max_tokens=request.max_length)
+        return {{"summary": response.choices[0].message.content, "model": "{model_id}"}}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+@app.get("/health")
+async def health_check():
+    return {{"status": "healthy", "model": "{model_id}"}}
+''',
+        "Dockerfile": '''FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN useradd -m -u 1000 appuser
+USER appuser
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+''',
+        "requirements.txt": "fastapi==0.115.6\nuvicorn[standard]==0.34.0\nhuggingface-hub==0.27.1\n",
+    },
+    "generic_docker": {
+        "app.py": '''from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from huggingface_hub import InferenceClient
+import os
+app = FastAPI(title="{title}", version="1.0.0")
+client = InferenceClient("{model_id}", token=os.environ.get("HF_TOKEN"))
+class QueryRequest(BaseModel):
+    query: str
+    max_tokens: int = 512
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    return """
+    <html>
+    <head><title>{title}</title>
+    <style>
+        body {{ font-family: system-ui; max-width: 900px; margin: 50px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }}
+        h1 {{ color: #38bdf8; }}
+        code {{ background: #1e293b; padding: 2px 8px; border-radius: 4px; }}
+        a {{ color: #38bdf8; }}
+    </style>
+    </head>
+    <body>
+        <h1>{title}</h1>
+        <p>{description}</p>
+        <h2>API Documentation</h2>
+        <p>Visit <a href="/docs">/docs</a> for interactive API documentation.</p>
+        <h2>Endpoints</h2>
+        <ul>
+            <li><code>POST /query</code> - Process a query</li>
+            <li><code>GET /health</code> - Health check</li>
+        </ul>
+    </body>
+    </html>
+    """
+@app.post("/query")
+async def process_query(request: QueryRequest):
+    try:
+        messages = [{{"role": "user", "content": request.query}}]
+        response = client.chat_completion(messages, max_tokens=request.max_tokens)
+        return {{
+            "response": response.choices[0].message.content,
+            "model": "{model_id}",
+        }}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+@app.get("/health")
+async def health():
+    return {{"status": "healthy"}}
+''',
+        "Dockerfile": '''FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN useradd -m -u 1000 appuser
+USER appuser
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+''',
+        "requirements.txt": "fastapi==0.115.6\nuvicorn[standard]==0.34.0\nhuggingface-hub==0.27.1\n",
+    },
+}
+class DockerGenerator:
+    """Generate Docker-based Space files."""
+    def __init__(self):
+        self._client = None
+    @property
+    def client(self) -> InferenceClient:
+        if self._client is None:
+            token = os.environ.get("HF_TOKEN", None)
+            self._client = InferenceClient(LLM_MODEL, token=token)
+        return self._client
+    def generate(self, plan: dict, prompt: str) -> dict:
+        """
+        Generate all files for a Docker-based Space.
+        Returns dict of {filename: content}.
+        """
+        model_id = self._get_model_id(plan)
+        title = plan.get("title", "My API")
+        description = plan.get("description", "")
+        template_key = plan.get("template_key", "generic_docker")
+        # Try LLM generation first
+        try:
+            files = self._generate_with_llm(plan, prompt, model_id, title, description)
+            if files and "app.py" in files and len(files["app.py"]) > 100:
+                # Ensure required files exist
+                if "Dockerfile" not in files:
+                    files["Dockerfile"] = DOCKER_TEMPLATES["generic_docker"]["Dockerfile"]
+                if "requirements.txt" not in files:
+                    files["requirements.txt"] = DOCKER_TEMPLATES["generic_docker"]["requirements.txt"]
+                return files
+        except Exception:
+            pass
+        # Fallback to templates
+        template = DOCKER_TEMPLATES.get(template_key, DOCKER_TEMPLATES["generic_docker"])
+        files = {}
+        for filename, content in template.items():
+            files[filename] = content.format(
+                model_id=model_id,
+                title=title,
+                description=description,
+            )
+        return files
+    def _generate_with_llm(
+        self, plan: dict, prompt: str, model_id: str, title: str, description: str
+    ) -> dict:
+        """Use LLM to generate custom Docker app files."""
+        system_prompt = """You are an expert Python developer specializing in FastAPI applications for Hugging Face Docker Spaces.
+Generate complete, production-ready code files.
+Rules:
+1. Output files in this exact format - each file delimited by markers:
+   === FILENAME: app.py ===
+   (file content)
+   === FILENAME: requirements.txt ===
+   (file content)
+   === FILENAME: Dockerfile ===
+   (file content)
+2. Use FastAPI for the web framework.
+3. Use `huggingface_hub.InferenceClient` for model inference.
+4. Include a root GET endpoint that returns an HTML page describing the API.
+5. Include a /health endpoint.
+6. Include proper error handling.
+7. The Dockerfile should use python:3.11-slim, create a non-root user, and expose port 7860.
+8. Use uvicorn to serve the app on 0.0.0.0:7860.
+9. Do NOT use transformers, torch, or tensorflow."""
+        user_prompt = f"""Generate a complete Docker-based HF Space for this request:
+USER REQUEST: {prompt}
+APP PLAN:
+- Type: {plan.get('app_type', 'custom')}
+- Model: {model_id}
+- Model Task: {plan.get('model_task', 'text-generation')}
+- Title: {title}
+- Description: {description}
+- Extra Features: {', '.join(plan.get('extra_features', []))}
+Generate the files (app.py, requirements.txt, Dockerfile):"""
+        response = self.client.chat_completion(
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            max_tokens=4096,
+            temperature=0.3,
+        )
+        raw = response.choices[0].message.content
+        return self._parse_files(raw)
+    def _parse_files(self, text: str) -> dict:
+        """Parse LLM output into a dict of filename -> content."""
+        files = {}
+        # Try marker-based parsing first
+        parts = re.split(r"===\s*FILENAME:\s*(.+?)\s*===", text)
+        if len(parts) >= 3:
+            for i in range(1, len(parts), 2):
+                filename = parts[i].strip()
+                content = parts[i + 1].strip() if i + 1 < len(parts) else ""
+                # Remove markdown code fences if present
+                content = re.sub(r"^```\w*\n?", "", content)
+                content = re.sub(r"\n?```$", "", content)
+                files[filename] = content.strip() + "\n"
+        # Try code block parsing as fallback
+        if not files:
+            blocks = re.findall(
+                r"(?:#|//)\s*(\S+\.(?:py|txt|dockerfile))\s*\n```\w*\n(.*?)```",
+                text, re.DOTALL | re.IGNORECASE,
+            )
+            for name, content in blocks:
+                files[name.strip()] = content.strip() + "\n"
+        return files
+    def _get_model_id(self, plan: dict) -> str:
+        models = plan.get("recommended_models", [])
+        if models:
+            return models[0]["id"]
+        return "Qwen/Qwen2.5-7B-Instruct"
+    def edit(self, plan: dict, current_files: dict, edit_prompt: str) -> dict:
+        """Edit existing Docker app files."""
+        try:
+            app_code = current_files.get("app.py", "")
+            system_prompt = """You are an expert Python developer. Modify the existing FastAPI app code according to the edit request.
+Output ONLY the updated Python code for app.py, no explanations or markdown fences.
+Keep all existing functionality unless explicitly asked to remove something.
+Use huggingface_hub.InferenceClient for model inference."""
+            user_prompt = f"""EXISTING app.py:
+```python
+{app_code}
+```
+EDIT REQUEST: {edit_prompt}
+Return the complete updated app.py:"""
+            response = self.client.chat_completion(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                max_tokens=4096,
+                temperature=0.2,
+            )
+            raw = response.choices[0].message.content
+            code = re.sub(r"^```\w*\n?", "", raw.strip())
+            code = re.sub(r"\n?```$", "", code)
+            if code and len(code) > 50:
+                updated = dict(current_files)
+                updated["app.py"] = code.strip() + "\n"
+                return updated
+        except Exception:
+            pass
+        return current_files

app/codegen/gradio_generator.py ADDED Viewed

	@@ -0,0 +1,444 @@

+"""
+Generate Gradio app code using the HF Inference API (LLM-powered).
+Falls back to template-based generation if the API is unavailable.
+"""
+import os
+import re
+from huggingface_hub import InferenceClient
+LLM_MODEL = "Qwen/Qwen2.5-72B-Instruct"
+# Pre-built templates for common app types (used as fallback and as LLM context)
+GRADIO_TEMPLATES = {
+    "chatbot": '''import gradio as gr
+from huggingface_hub import InferenceClient
+client = InferenceClient("{model_id}")
+def respond(message, history, system_message, max_tokens, temperature, top_p):
+    messages = [{"role": "system", "content": system_message}]
+    for user_msg, bot_msg in history:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if bot_msg:
+            messages.append({"role": "assistant", "content": bot_msg})
+    messages.append({"role": "user", "content": message})
+    response = ""
+    for chunk in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = chunk.choices[0].delta.content or ""
+        response += token
+        yield response
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a helpful assistant.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max tokens"),
+        gr.Slider(minimum=0.1, maximum=2.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p"),
+    ],
+    title="{title}",
+    description="{description}",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+    "image_classifier": '''import gradio as gr
+from huggingface_hub import InferenceClient
+import json
+client = InferenceClient("{model_id}")
+def classify_image(image):
+    if image is None:
+        return {{}}
+    result = client.image_classification(image)
+    return {{item["label"]: round(item["score"], 4) for item in result}}
+demo = gr.Interface(
+    fn=classify_image,
+    inputs=gr.Image(type="filepath", label="Upload Image"),
+    outputs=gr.Label(num_top_classes=5, label="Predictions"),
+    title="{title}",
+    description="{description}",
+    examples=[],
+    allow_flagging="never",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+    "text_summarizer": '''import gradio as gr
+from huggingface_hub import InferenceClient
+client = InferenceClient("{model_id}")
+def summarize(text, max_length, min_length):
+    if not text.strip():
+        return "Please enter some text to summarize."
+    result = client.summarization(
+        text,
+        parameters={{"max_length": int(max_length), "min_length": int(min_length)}},
+    )
+    return result["summary_text"] if isinstance(result, dict) else result[0]["summary_text"]
+demo = gr.Interface(
+    fn=summarize,
+    inputs=[
+        gr.Textbox(lines=10, placeholder="Paste your text here...", label="Input Text"),
+        gr.Slider(50, 500, value=150, step=10, label="Max Summary Length"),
+        gr.Slider(10, 100, value=30, step=5, label="Min Summary Length"),
+    ],
+    outputs=gr.Textbox(lines=5, label="Summary"),
+    title="{title}",
+    description="{description}",
+    allow_flagging="never",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+    "sentiment_analyzer": '''import gradio as gr
+from huggingface_hub import InferenceClient
+client = InferenceClient("{model_id}")
+def analyze_sentiment(text):
+    if not text.strip():
+        return {{}}, ""
+    result = client.text_classification(text)
+    scores = {{item["label"]: round(item["score"], 4) for item in result}}
+    top_label = max(scores, key=scores.get)
+    explanation = f"The text is predominantly **{{top_label}}** (confidence: {{scores[top_label]:.1%}})"
+    return scores, explanation
+demo = gr.Interface(
+    fn=analyze_sentiment,
+    inputs=gr.Textbox(lines=5, placeholder="Enter text to analyze...", label="Input Text"),
+    outputs=[
+        gr.Label(label="Sentiment Scores"),
+        gr.Markdown(label="Analysis"),
+    ],
+    title="{title}",
+    description="{description}",
+    allow_flagging="never",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+    "text_generator": '''import gradio as gr
+from huggingface_hub import InferenceClient
+client = InferenceClient("{model_id}")
+def generate_text(prompt, max_tokens, temperature, top_p):
+    if not prompt.strip():
+        return "Please enter a prompt."
+    messages = [{{"role": "user", "content": prompt}}]
+    response = ""
+    for chunk in client.chat_completion(
+        messages, max_tokens=int(max_tokens), stream=True,
+        temperature=temperature, top_p=top_p,
+    ):
+        token = chunk.choices[0].delta.content or ""
+        response += token
+        yield response
+demo = gr.Interface(
+    fn=generate_text,
+    inputs=[
+        gr.Textbox(lines=3, placeholder="Enter your prompt...", label="Prompt"),
+        gr.Slider(50, 2048, value=512, step=50, label="Max Tokens"),
+        gr.Slider(0.1, 2.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(0.1, 1.0, value=0.95, step=0.05, label="Top-p"),
+    ],
+    outputs=gr.Textbox(lines=10, label="Generated Text"),
+    title="{title}",
+    description="{description}",
+    allow_flagging="never",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+    "translator": '''import gradio as gr
+from huggingface_hub import InferenceClient
+client = InferenceClient("{model_id}")
+def translate(text, target_language):
+    if not text.strip():
+        return "Please enter text to translate."
+    prompt = f"Translate the following text to {{target_language}}:\\n\\n{{text}}"
+    messages = [{{"role": "user", "content": prompt}}]
+    result = client.chat_completion(messages, max_tokens=1024)
+    return result.choices[0].message.content
+LANGUAGES = ["French", "Spanish", "German", "Italian", "Portuguese",
+             "Chinese", "Japanese", "Korean", "Arabic", "Hindi", "Russian"]
+demo = gr.Interface(
+    fn=translate,
+    inputs=[
+        gr.Textbox(lines=5, placeholder="Enter text to translate...", label="Input Text"),
+        gr.Dropdown(choices=LANGUAGES, value="French", label="Target Language"),
+    ],
+    outputs=gr.Textbox(lines=5, label="Translation"),
+    title="{title}",
+    description="{description}",
+    allow_flagging="never",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+    "question_answering": '''import gradio as gr
+from huggingface_hub import InferenceClient
+client = InferenceClient("{model_id}")
+def answer_question(context, question):
+    if not context.strip() or not question.strip():
+        return "Please provide both context and a question."
+    result = client.question_answering(question=question, context=context)
+    answer = result["answer"]
+    score = result["score"]
+    return f"**Answer:** {{answer}}\\n\\n**Confidence:** {{score:.1%}}"
+demo = gr.Interface(
+    fn=answer_question,
+    inputs=[
+        gr.Textbox(lines=8, placeholder="Paste the context here...", label="Context"),
+        gr.Textbox(lines=2, placeholder="Ask a question...", label="Question"),
+    ],
+    outputs=gr.Markdown(label="Answer"),
+    title="{title}",
+    description="{description}",
+    allow_flagging="never",
+)
+if __name__ == "__main__":
+    demo.launch()
+''',
+}
+class GradioGenerator:
+    """Generate Gradio app.py code for a given plan."""
+    def __init__(self):
+        self._client = None
+    @property
+    def client(self) -> InferenceClient:
+        if self._client is None:
+            token = os.environ.get("HF_TOKEN", None)
+            self._client = InferenceClient(LLM_MODEL, token=token)
+        return self._client
+    def generate(self, plan: dict, prompt: str) -> str:
+        """Generate app.py content for a Gradio Space."""
+        template_key = plan.get("template_key")
+        model_id = self._get_model_id(plan)
+        title = plan.get("title", "My App")
+        description = plan.get("description", "")
+        # First try LLM generation for best results
+        try:
+            code = self._generate_with_llm(plan, prompt, model_id, title, description)
+            if code and len(code) > 100:
+                return code
+        except Exception:
+            pass
+        # Fallback to template-based generation
+        if template_key and template_key in GRADIO_TEMPLATES:
+            return GRADIO_TEMPLATES[template_key].format(
+                model_id=model_id,
+                title=title,
+                description=description,
+            )
+        # Final fallback: generic Gradio app
+        return self._generate_generic(plan, model_id, title, description)
+    def _generate_with_llm(
+        self, plan: dict, prompt: str, model_id: str, title: str, description: str
+    ) -> str:
+        """Use the LLM to generate custom Gradio app code."""
+        template_key = plan.get("template_key")
+        reference_code = ""
+        if template_key and template_key in GRADIO_TEMPLATES:
+            reference_code = GRADIO_TEMPLATES[template_key].format(
+                model_id=model_id, title=title, description=description,
+            )
+        system_prompt = """You are an expert Python developer specializing in Gradio applications for Hugging Face Spaces.
+You generate complete, working app.py files that are production-ready.
+Rules:
+1. Output ONLY the Python code, no explanations or markdown.
+2. Use `huggingface_hub.InferenceClient` for model inference (NOT transformers or pipeline).
+3. Always include proper error handling.
+4. The app must use `demo.launch()` at the end.
+5. Include descriptive title and description in the interface.
+6. Use appropriate Gradio components for the use case.
+7. Code must be complete and runnable as-is.
+8. Do NOT use `transformers`, `torch`, or `tensorflow` imports - use only `huggingface_hub.InferenceClient`.
+9. For streaming text generation, use `client.chat_completion(..., stream=True)`.
+10. For image tasks, use `client.image_classification()`, `client.object_detection()`, etc.
+11. For text tasks, use `client.text_classification()`, `client.summarization()`, etc."""
+        user_prompt = f"""Generate a complete Gradio app.py for this request:
+USER REQUEST: {prompt}
+APP PLAN:
+- SDK: gradio
+- Type: {plan.get('app_type', 'custom')}
+- Model: {model_id}
+- Model Task: {plan.get('model_task', 'text-generation')}
+- Components: {', '.join(plan.get('components', []))}
+- Title: {title}
+- Description: {description}
+- Extra Features: {', '.join(plan.get('extra_features', []))}
+"""
+        if reference_code:
+            user_prompt += f"""
+REFERENCE TEMPLATE (adapt and improve this based on the user's specific request):
+```python
+{reference_code}
+```
+"""
+        user_prompt += "\nGenerate the complete app.py code now:"
+        response = self.client.chat_completion(
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            max_tokens=4096,
+            temperature=0.3,
+        )
+        raw = response.choices[0].message.content
+        return self._extract_code(raw)
+    def _extract_code(self, text: str) -> str:
+        """Extract Python code from LLM response."""
+        # Try to find code blocks
+        code_blocks = re.findall(r"```(?:python)?\s*\n(.*?)```", text, re.DOTALL)
+        if code_blocks:
+            # Return the longest code block
+            return max(code_blocks, key=len).strip()
+        # If no code blocks, check if the whole response looks like Python code
+        lines = text.strip().split("\n")
+        if lines and (lines[0].startswith("import ") or lines[0].startswith("from ")):
+            return text.strip()
+        return text.strip()
+    def _get_model_id(self, plan: dict) -> str:
+        """Get the best model ID from the plan."""
+        models = plan.get("recommended_models", [])
+        if models:
+            return models[0]["id"]
+        # Fallback defaults by task
+        task_defaults = {
+            "text-generation": "Qwen/Qwen2.5-7B-Instruct",
+            "text-classification": "cardiffnlp/twitter-roberta-base-sentiment-latest",
+            "summarization": "facebook/bart-large-cnn",
+            "translation": "Qwen/Qwen2.5-7B-Instruct",
+            "image-classification": "google/vit-base-patch16-224",
+            "object-detection": "facebook/detr-resnet-50",
+            "text-to-image": "stabilityai/stable-diffusion-xl-base-1.0",
+            "automatic-speech-recognition": "openai/whisper-base",
+            "question-answering": "deepset/roberta-base-squad2",
+        }
+        return task_defaults.get(plan.get("model_task", ""), "Qwen/Qwen2.5-7B-Instruct")
+    def _generate_generic(self, plan: dict, model_id: str, title: str, description: str) -> str:
+        """Generate a generic Gradio app when no template matches."""
+        task = plan.get("model_task", "text-generation")
+        if task in ("text-generation",):
+            return GRADIO_TEMPLATES["text_generator"].format(
+                model_id=model_id, title=title, description=description,
+            )
+        elif task in ("text-classification",):
+            return GRADIO_TEMPLATES["sentiment_analyzer"].format(
+                model_id=model_id, title=title, description=description,
+            )
+        elif task in ("summarization",):
+            return GRADIO_TEMPLATES["text_summarizer"].format(
+                model_id=model_id, title=title, description=description,
+            )
+        elif task in ("image-classification",):
+            return GRADIO_TEMPLATES["image_classifier"].format(
+                model_id=model_id, title=title, description=description,
+            )
+        elif task in ("question-answering",):
+            return GRADIO_TEMPLATES["question_answering"].format(
+                model_id=model_id, title=title, description=description,
+            )
+        else:
+            return GRADIO_TEMPLATES["text_generator"].format(
+                model_id=model_id, title=title, description=description,
+            )
+    def edit(self, plan: dict, current_code: str, edit_prompt: str) -> str:
+        """Edit existing Gradio code based on user instructions."""
+        try:
+            system_prompt = """You are an expert Python developer. You will receive existing Gradio app code and an edit request.
+Modify the code according to the request and return the COMPLETE updated code.
+Output ONLY the Python code, no explanations or markdown fences.
+Keep all existing functionality unless the user explicitly asks to remove something.
+Use huggingface_hub.InferenceClient for model inference."""
+            user_prompt = f"""EXISTING CODE:
+```python
+{current_code}
+```
+EDIT REQUEST: {edit_prompt}
+Return the complete updated app.py code:"""
+            response = self.client.chat_completion(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                max_tokens=4096,
+                temperature=0.2,
+            )
+            raw = response.choices[0].message.content
+            code = self._extract_code(raw)
+            if code and len(code) > 50:
+                return code
+        except Exception:
+            pass
+        return current_code

app/codegen/readme_generator.py ADDED Viewed

	@@ -0,0 +1,216 @@

+"""
+Generate beautiful README.md files for generated HF Spaces.
+"""
+from typing import Optional
+EMOJI_MAP = {
+    "chatbot": "💬",
+    "image_classifier": "🖼️",
+    "text_summarizer": "📝",
+    "sentiment_analyzer": "😊",
+    "text_generator": "✍️",
+    "translator": "🌐",
+    "object_detector": "🔍",
+    "speech_to_text": "🎤",
+    "image_generator": "🎨",
+    "question_answering": "❓",
+    "rest_api": "🔌",
+    "portfolio": "💼",
+}
+COLOR_MAP = {
+    "chatbot": ("blue", "purple"),
+    "image_classifier": ("green", "yellow"),
+    "text_summarizer": ("indigo", "blue"),
+    "sentiment_analyzer": ("pink", "red"),
+    "text_generator": ("purple", "indigo"),
+    "translator": ("cyan", "blue"),
+    "object_detector": ("orange", "red"),
+    "speech_to_text": ("green", "cyan"),
+    "image_generator": ("purple", "pink"),
+    "question_answering": ("yellow", "orange"),
+    "rest_api": ("gray", "blue"),
+    "portfolio": ("blue", "cyan"),
+}
+class ReadmeGenerator:
+    """Generate HF Space README.md with proper frontmatter."""
+    def generate(self, plan: dict, sdk: str) -> str:
+        """Generate a complete README.md for the Space."""
+        app_type = plan.get("app_type", "custom")
+        title = plan.get("title", "My App")
+        description = plan.get("description", "A Hugging Face Space")
+        app_name = plan.get("app_name", "my-app")
+        models = plan.get("recommended_models", [])
+        components = plan.get("components", [])
+        emoji = EMOJI_MAP.get(app_type, "🚀")
+        color_from, color_to = COLOR_MAP.get(app_type, ("blue", "cyan"))
+        # Build frontmatter
+        frontmatter = self._build_frontmatter(
+            title=title,
+            emoji=emoji,
+            color_from=color_from,
+            color_to=color_to,
+            sdk=sdk,
+            models=models,
+        )
+        # Build body
+        body = self._build_body(
+            title=title,
+            description=description,
+            app_type=app_type,
+            sdk=sdk,
+            models=models,
+            components=components,
+            plan=plan,
+        )
+        return frontmatter + "\n" + body
+    def _build_frontmatter(
+        self,
+        title: str,
+        emoji: str,
+        color_from: str,
+        color_to: str,
+        sdk: str,
+        models: list,
+    ) -> str:
+        lines = [
+            "---",
+            f'title: "{title}"',
+            f"emoji: {emoji}",
+            f"colorFrom: {color_from}",
+            f"colorTo: {color_to}",
+        ]
+        if sdk == "gradio":
+            lines.append("sdk: gradio")
+            lines.append("sdk_version: 5.9.1")
+        elif sdk == "docker":
+            lines.append("sdk: docker")
+            lines.append("app_port: 7860")
+        else:
+            lines.append("sdk: static")
+        if models:
+            lines.append("models:")
+            for m in models[:3]:
+                lines.append(f'  - "{m["id"]}"')
+        lines.append("pinned: false")
+        lines.append("license: mit")
+        lines.append("---")
+        return "\n".join(lines)
+    def _build_body(
+        self,
+        title: str,
+        description: str,
+        app_type: str,
+        sdk: str,
+        models: list,
+        components: list,
+        plan: dict,
+    ) -> str:
+        sections = []
+        # Title and description
+        sections.append(f"# {title}\n")
+        sections.append(f"{description}\n")
+        # Features section
+        sections.append("## Features\n")
+        feature_descriptions = {
+            "chat_interface": "Interactive chat interface with streaming responses",
+            "system_prompt_config": "Configurable system prompt",
+            "clear_button": "Clear conversation history",
+            "history": "Persistent chat history",
+            "image_upload": "Image upload support",
+            "label_output": "Classification labels with confidence scores",
+            "confidence_bars": "Visual confidence bars",
+            "examples": "Pre-loaded example inputs",
+            "text_input": "Text input area",
+            "file_upload": "File upload support",
+            "length_selector": "Adjustable output length",
+            "text_output": "Text output display",
+            "chart_output": "Data visualization charts",
+            "parameter_controls": "Adjustable model parameters",
+            "language_selector": "Multi-language selection",
+            "audio_input": "Audio/microphone input",
+            "annotated_image_output": "Annotated image output with bounding boxes",
+            "json_output": "Structured JSON output",
+            "gallery": "Image gallery view",
+            "image_output": "Image output display",
+            "fastapi_app": "FastAPI web application",
+            "model_endpoint": "Model inference endpoint",
+            "docs": "Interactive API documentation",
+            "health_check": "Health check endpoint",
+            "html_page": "Responsive HTML pages",
+            "css_styles": "Custom CSS styling",
+            "js_scripts": "Interactive JavaScript",
+            "context_input": "Context paragraph input",
+            "question_input": "Question input field",
+            "answer_output": "Answer display with confidence",
+            "highlight": "Answer highlighting in context",
+            "file_component": "File handling component",
+            "video_input": "Video input support",
+            "hero_section": "Hero section with CTA",
+            "projects_section": "Projects showcase",
+            "skills_section": "Skills display",
+            "contact_form": "Contact form",
+        }
+        for comp in components:
+            desc = feature_descriptions.get(comp, comp.replace("_", " ").title())
+            sections.append(f"- {desc}")
+        sections.append("")
+        # Models section
+        if models:
+            sections.append("## Models Used\n")
+            for m in models:
+                sections.append(f"- **[{m['id']}](https://huggingface.co/{m['id']})** - {m.get('desc', '')}")
+            sections.append("")
+        # Tech stack
+        sections.append("## Tech Stack\n")
+        if sdk == "gradio":
+            sections.append("- [Gradio](https://gradio.app/) - UI framework")
+            sections.append("- [Hugging Face Hub](https://huggingface.co/) - Model inference")
+        elif sdk == "docker":
+            sections.append("- [FastAPI](https://fastapi.tiangolo.com/) - Web framework")
+            sections.append("- [Docker](https://docker.com/) - Containerization")
+            sections.append("- [Hugging Face Hub](https://huggingface.co/) - Model inference")
+        else:
+            sections.append("- HTML5 / CSS3 / JavaScript")
+        sections.append("")
+        # Usage
+        sections.append("## Usage\n")
+        if sdk == "gradio":
+            sections.append("1. Open the Space URL")
+            sections.append("2. Interact with the interface")
+            sections.append("3. Results will be displayed automatically")
+        elif sdk == "docker":
+            sections.append("### API Endpoints\n")
+            sections.append("Visit `/docs` for interactive API documentation.\n")
+            sections.append("```bash")
+            sections.append('curl -X POST "/query" -H "Content-Type: application/json" -d \'{"query": "Hello"}\'')
+            sections.append("```")
+        else:
+            sections.append("Simply visit the Space URL to view the site.")
+        sections.append("")
+        # Footer
+        sections.append("---\n")
+        sections.append("*Generated by [AutoApp Builder](https://huggingface.co/spaces/autoapp-builder)*")
+        return "\n".join(sections)

app/codegen/repo_generator.py ADDED Viewed

	@@ -0,0 +1,333 @@

+"""
+Orchestrate full repository generation by delegating to SDK-specific generators.
+"""
+from app.codegen.gradio_generator import GradioGenerator
+from app.codegen.docker_generator import DockerGenerator
+from app.codegen.readme_generator import ReadmeGenerator
+STATIC_TEMPLATE = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{title}</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{
+            font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
+            background: #0f172a;
+            color: #e2e8f0;
+            min-height: 100vh;
+        }}
+        .hero {{
+            min-height: 60vh;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            text-align: center;
+            padding: 2rem;
+            background: linear-gradient(135deg, #0f172a 0%, #1e293b 50%, #0f172a 100%);
+        }}
+        .hero h1 {{
+            font-size: 3.5rem;
+            font-weight: 800;
+            background: linear-gradient(135deg, #38bdf8, #818cf8);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 1rem;
+        }}
+        .hero p {{
+            font-size: 1.25rem;
+            color: #94a3b8;
+            max-width: 600px;
+            line-height: 1.8;
+        }}
+        .section {{
+            max-width: 1000px;
+            margin: 0 auto;
+            padding: 4rem 2rem;
+        }}
+        .section h2 {{
+            font-size: 2rem;
+            margin-bottom: 2rem;
+            color: #38bdf8;
+        }}
+        .grid {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+            gap: 1.5rem;
+        }}
+        .card {{
+            background: rgba(30, 41, 59, 0.8);
+            border: 1px solid rgba(56, 189, 248, 0.1);
+            border-radius: 12px;
+            padding: 1.5rem;
+            transition: transform 0.2s, border-color 0.2s;
+        }}
+        .card:hover {{
+            transform: translateY(-4px);
+            border-color: rgba(56, 189, 248, 0.4);
+        }}
+        .card h3 {{ color: #f1f5f9; margin-bottom: 0.5rem; }}
+        .card p {{ color: #94a3b8; line-height: 1.6; }}
+        .skills {{
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.75rem;
+        }}
+        .skill-tag {{
+            background: rgba(56, 189, 248, 0.15);
+            color: #38bdf8;
+            padding: 0.5rem 1rem;
+            border-radius: 9999px;
+            font-size: 0.875rem;
+        }}
+        .contact {{
+            background: rgba(30, 41, 59, 0.6);
+            border-radius: 16px;
+            padding: 2rem;
+            text-align: center;
+        }}
+        .contact a {{
+            display: inline-block;
+            margin: 0.5rem;
+            padding: 0.75rem 1.5rem;
+            background: linear-gradient(135deg, #38bdf8, #818cf8);
+            color: white;
+            text-decoration: none;
+            border-radius: 8px;
+            font-weight: 600;
+        }}
+        footer {{
+            text-align: center;
+            padding: 2rem;
+            color: #475569;
+            font-size: 0.875rem;
+        }}
+    </style>
+</head>
+<body>
+    <div class="hero">
+        <h1>{title}</h1>
+        <p>{description}</p>
+    </div>
+    <div class="section">
+        <h2>Projects</h2>
+        <div class="grid">
+            <div class="card">
+                <h3>Project Alpha</h3>
+                <p>A cutting-edge machine learning project that pushes the boundaries of what's possible.</p>
+            </div>
+            <div class="card">
+                <h3>Project Beta</h3>
+                <p>An innovative data pipeline that processes millions of records in real-time.</p>
+            </div>
+            <div class="card">
+                <h3>Project Gamma</h3>
+                <p>A beautiful visualization dashboard that makes complex data accessible.</p>
+            </div>
+        </div>
+    </div>
+    <div class="section">
+        <h2>Skills</h2>
+        <div class="skills">
+            <span class="skill-tag">Python</span>
+            <span class="skill-tag">Machine Learning</span>
+            <span class="skill-tag">Deep Learning</span>
+            <span class="skill-tag">NLP</span>
+            <span class="skill-tag">Computer Vision</span>
+            <span class="skill-tag">Data Science</span>
+            <span class="skill-tag">FastAPI</span>
+            <span class="skill-tag">Docker</span>
+        </div>
+    </div>
+    <div class="section">
+        <div class="contact">
+            <h2>Get in Touch</h2>
+            <p style="color: #94a3b8; margin: 1rem 0;">Interested in collaborating? Reach out!</p>
+            <a href="mailto:hello@example.com">Email</a>
+            <a href="https://github.com">GitHub</a>
+            <a href="https://linkedin.com">LinkedIn</a>
+        </div>
+    </div>
+    <footer>
+        <p>Built with care. Hosted on Hugging Face Spaces.</p>
+    </footer>
+</body>
+</html>
+"""
+class RepoGenerator:
+    """Orchestrate full repo generation for any SDK type."""
+    def __init__(self):
+        self.gradio_gen = GradioGenerator()
+        self.docker_gen = DockerGenerator()
+        self.readme_gen = ReadmeGenerator()
+    def generate(self, plan: dict, prompt: str) -> dict:
+        """
+        Generate all files for a complete HF Space repo.
+        Returns dict of {filepath: content}.
+        """
+        sdk = plan.get("sdk", "gradio")
+        if sdk == "gradio":
+            return self._generate_gradio_repo(plan, prompt)
+        elif sdk == "docker":
+            return self._generate_docker_repo(plan, prompt)
+        else:
+            return self._generate_static_repo(plan, prompt)
+    def _generate_gradio_repo(self, plan: dict, prompt: str) -> dict:
+        """Generate a complete Gradio Space repo."""
+        files = {}
+        # README.md
+        files["README.md"] = self.readme_gen.generate(plan, "gradio")
+        # app.py - the main Gradio application
+        files["app.py"] = self.gradio_gen.generate(plan, prompt)
+        # requirements.txt
+        files["requirements.txt"] = self._gradio_requirements(plan)
+        # .gitignore
+        files[".gitignore"] = self._gitignore()
+        return files
+    def _generate_docker_repo(self, plan: dict, prompt: str) -> dict:
+        """Generate a complete Docker Space repo."""
+        # Get docker-specific files from the generator
+        docker_files = self.docker_gen.generate(plan, prompt)
+        files = {}
+        # README.md (always generate our own)
+        files["README.md"] = self.readme_gen.generate(plan, "docker")
+        # Merge docker-generated files
+        for name, content in docker_files.items():
+            files[name] = content
+        # .gitignore
+        files[".gitignore"] = self._gitignore()
+        return files
+    def _generate_static_repo(self, plan: dict, prompt: str) -> dict:
+        """Generate a complete Static Space repo."""
+        title = plan.get("title", "My Site")
+        description = plan.get("description", "A static website")
+        files = {}
+        # README.md
+        files["README.md"] = self.readme_gen.generate(plan, "static")
+        # index.html
+        files["index.html"] = STATIC_TEMPLATE.format(
+            title=title,
+            description=description,
+        )
+        # style.css (additional styles)
+        files["style.css"] = """/* Additional custom styles */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap');
+body {
+    font-family: 'Inter', system-ui, sans-serif;
+}
+/* Smooth scrolling */
+html {
+    scroll-behavior: smooth;
+}
+/* Animated gradient background */
+@keyframes gradient-shift {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+}
+.hero {
+    background-size: 200% 200%;
+    animation: gradient-shift 8s ease infinite;
+}
+/* Fade-in animation */
+@keyframes fadeInUp {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+.card {
+    animation: fadeInUp 0.5s ease forwards;
+}
+"""
+        files[".gitignore"] = self._gitignore()
+        return files
+    def _gradio_requirements(self, plan: dict) -> str:
+        """Generate requirements.txt for Gradio apps."""
+        deps = [
+            "gradio>=5.9.1",
+            "huggingface-hub>=0.27.1",
+        ]
+        # Add task-specific dependencies
+        task = plan.get("model_task", "")
+        if task in ("text-to-image", "image-classification", "object-detection"):
+            deps.append("Pillow>=10.0.0")
+        if "chart_output" in plan.get("components", []):
+            deps.append("matplotlib>=3.8.0")
+            deps.append("numpy>=1.26.0")
+        return "\n".join(deps) + "\n"
+    def _gitignore(self) -> str:
+        return """__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.env
+.venv/
+venv/
+.DS_Store
+*.log
+"""
+    def edit(self, plan: dict, current_files: dict, edit_prompt: str) -> dict:
+        """Edit an existing repo based on user instructions."""
+        sdk = plan.get("sdk", "gradio")
+        updated = dict(current_files)
+        if sdk == "gradio" and "app.py" in current_files:
+            updated["app.py"] = self.gradio_gen.edit(plan, current_files["app.py"], edit_prompt)
+        elif sdk == "docker":
+            docker_updated = self.docker_gen.edit(plan, current_files, edit_prompt)
+            updated.update(docker_updated)
+        # Static sites: for now return unchanged (could add LLM-based HTML editing)
+        return updated

app/engine/__init__.py ADDED Viewed

File without changes

app/engine/app_planner.py ADDED Viewed

	@@ -0,0 +1,279 @@

+"""
+Analyze user prompts, select the appropriate SDK, and plan app architecture.
+"""
+import re
+from typing import Optional
+# Keywords that strongly indicate a particular SDK
+GRADIO_KEYWORDS = [
+    "gradio", "demo", "interface", "chatbot", "chat", "image classifier",
+    "image classification", "object detection", "text generation", "summarizer",
+    "summarization", "sentiment", "translation", "translate", "speech",
+    "audio", "video", "upload", "webcam", "microphone", "slider", "dropdown",
+    "interactive", "ml model", "machine learning", "deep learning", "neural",
+    "predict", "inference", "classify", "segment", "detect", "recognize",
+    "generate image", "stable diffusion", "text-to-image", "image-to-text",
+    "question answering", "qa", "ner", "named entity", "token classification",
+    "zero-shot", "few-shot", "embedding", "similarity",
+]
+DOCKER_KEYWORDS = [
+    "docker", "api", "rest", "fastapi", "flask", "endpoint", "websocket",
+    "agent", "autonomous", "pipeline", "workflow", "backend", "server",
+    "database", "redis", "celery", "queue", "cron", "schedule", "scrape",
+    "crawl", "multi-step", "orchestrat", "microservice", "webhook",
+    "authentication", "auth", "oauth", "custom server", "complex",
+    "real-time", "streaming api",
+]
+STATIC_KEYWORDS = [
+    "static", "landing page", "portfolio", "documentation", "docs",
+    "blog", "website", "html", "css only", "showcase", "gallery",
+    "resume", "cv", "personal site", "no backend", "frontend only",
+]
+# Templates for common app types
+APP_TEMPLATES = {
+    "chatbot": {
+        "components": ["chat_interface", "system_prompt_config", "clear_button", "history"],
+        "model_task": "text-generation",
+        "description": "Conversational AI chatbot",
+    },
+    "image_classifier": {
+        "components": ["image_upload", "label_output", "confidence_bars", "examples"],
+        "model_task": "image-classification",
+        "description": "Image classification with confidence scores",
+    },
+    "text_summarizer": {
+        "components": ["text_input", "file_upload", "length_selector", "text_output"],
+        "model_task": "summarization",
+        "description": "Text summarization tool",
+    },
+    "sentiment_analyzer": {
+        "components": ["text_input", "label_output", "chart_output"],
+        "model_task": "text-classification",
+        "description": "Sentiment analysis with visualization",
+    },
+    "text_generator": {
+        "components": ["text_input", "parameter_controls", "text_output"],
+        "model_task": "text-generation",
+        "description": "Text generation with configurable parameters",
+    },
+    "translator": {
+        "components": ["text_input", "language_selector", "text_output"],
+        "model_task": "translation",
+        "description": "Multi-language translation tool",
+    },
+    "object_detector": {
+        "components": ["image_upload", "annotated_image_output", "json_output"],
+        "model_task": "object-detection",
+        "description": "Object detection with bounding boxes",
+    },
+    "speech_to_text": {
+        "components": ["audio_input", "text_output", "language_selector"],
+        "model_task": "automatic-speech-recognition",
+        "description": "Speech recognition / transcription",
+    },
+    "image_generator": {
+        "components": ["text_input", "parameter_controls", "image_output", "gallery"],
+        "model_task": "text-to-image",
+        "description": "AI image generation from text prompts",
+    },
+    "question_answering": {
+        "components": ["context_input", "question_input", "answer_output", "highlight"],
+        "model_task": "question-answering",
+        "description": "Extractive question answering",
+    },
+    "rest_api": {
+        "components": ["fastapi_app", "model_endpoint", "docs", "health_check"],
+        "model_task": "text-generation",
+        "description": "REST API serving ML models",
+    },
+    "portfolio": {
+        "components": ["hero_section", "projects_section", "skills_section", "contact_form"],
+        "model_task": None,
+        "description": "Personal portfolio website",
+    },
+}
+class AppPlanner:
+    """Analyzes user prompts and produces a structured app plan."""
+    def analyze(self, prompt: str, sdk_preference: str = "auto") -> dict:
+        """
+        Analyze the user prompt and return a structured plan.
+        Returns dict with keys:
+            sdk, app_name, app_type, description, components,
+            model_task, template_key, title
+        """
+        prompt_lower = prompt.lower()
+        # Detect the best matching template
+        template_key = self._match_template(prompt_lower)
+        template = APP_TEMPLATES.get(template_key, {})
+        # Determine SDK
+        if sdk_preference != "auto":
+            sdk = sdk_preference
+        else:
+            sdk = self._select_sdk(prompt_lower, template_key)
+        # Generate an app name from the prompt
+        app_name = self._generate_app_name(prompt_lower)
+        # Determine a human-readable title
+        title = self._generate_title(prompt, template_key)
+        plan = {
+            "sdk": sdk,
+            "app_name": app_name,
+            "app_type": template_key or "custom",
+            "title": title,
+            "description": template.get("description", self._extract_description(prompt)),
+            "components": template.get("components", self._infer_components(prompt_lower, sdk)),
+            "model_task": template.get("model_task", self._infer_model_task(prompt_lower)),
+            "template_key": template_key,
+            "original_prompt": prompt,
+        }
+        return plan
+    def _select_sdk(self, prompt_lower: str, template_key: Optional[str]) -> str:
+        """Auto-select the best SDK based on prompt analysis."""
+        # Check template-based hints
+        if template_key in ("rest_api",):
+            return "docker"
+        if template_key in ("portfolio",):
+            return "static"
+        gradio_score = sum(1 for kw in GRADIO_KEYWORDS if kw in prompt_lower)
+        docker_score = sum(1 for kw in DOCKER_KEYWORDS if kw in prompt_lower)
+        static_score = sum(1 for kw in STATIC_KEYWORDS if kw in prompt_lower)
+        scores = {"gradio": gradio_score, "docker": docker_score, "static": static_score}
+        best = max(scores, key=scores.get)
+        # Default to gradio if no strong signal
+        if scores[best] == 0:
+            return "gradio"
+        return best
+    def _match_template(self, prompt_lower: str) -> Optional[str]:
+        """Find the best matching template for the prompt."""
+        scores = {}
+        keyword_map = {
+            "chatbot": ["chat", "chatbot", "conversation", "dialogue", "talk"],
+            "image_classifier": ["classify image", "image classif", "image recogni", "predict image"],
+            "text_summarizer": ["summar", "summarize", "summarization", "tldr", "shorten text"],
+            "sentiment_analyzer": ["sentiment", "emotion", "mood", "opinion"],
+            "text_generator": ["text generat", "write text", "generate text", "story generat", "complete text"],
+            "translator": ["translat", "language translation"],
+            "object_detector": ["object detect", "detect object", "bounding box", "find objects"],
+            "speech_to_text": ["speech", "transcri", "voice to text", "audio to text", "asr"],
+            "image_generator": ["generate image", "text to image", "stable diffusion", "create image", "dall-e", "image generat"],
+            "question_answering": ["question answer", "qa ", "answer question", "reading comprehension"],
+            "rest_api": ["rest api", "api service", "endpoint", "api server", "fastapi"],
+            "portfolio": ["portfolio", "personal site", "resume", "cv site", "showcase"],
+        }
+        for key, keywords in keyword_map.items():
+            score = sum(1 for kw in keywords if kw in prompt_lower)
+            if score > 0:
+                scores[key] = score
+        if not scores:
+            return None
+        return max(scores, key=scores.get)
+    def _generate_app_name(self, prompt_lower: str) -> str:
+        """Generate a slug-style app name."""
+        # Try to extract key nouns
+        words = re.sub(r"[^a-z0-9\s]", "", prompt_lower).split()
+        stop_words = {
+            "a", "an", "the", "is", "are", "was", "were", "be", "been",
+            "being", "have", "has", "had", "do", "does", "did", "will",
+            "would", "could", "should", "may", "might", "can", "shall",
+            "build", "create", "make", "develop", "design", "generate",
+            "that", "which", "who", "whom", "this", "these", "those",
+            "i", "me", "my", "we", "our", "you", "your", "it", "its",
+            "they", "them", "their", "what", "where", "when", "how",
+            "and", "or", "but", "if", "then", "else", "so", "for",
+            "with", "from", "to", "of", "in", "on", "at", "by", "about",
+            "into", "through", "during", "before", "after", "above",
+            "below", "between", "under", "using", "use", "uses",
+            "let", "users", "user", "app", "application",
+        }
+        meaningful = [w for w in words if w not in stop_words and len(w) > 2][:4]
+        if not meaningful:
+            meaningful = ["my", "app"]
+        return "-".join(meaningful)
+    def _generate_title(self, prompt: str, template_key: Optional[str]) -> str:
+        """Generate a human-friendly title."""
+        if template_key and template_key in APP_TEMPLATES:
+            return APP_TEMPLATES[template_key]["description"]
+        # Capitalize first ~6 words of prompt
+        words = prompt.split()[:6]
+        title = " ".join(words)
+        if len(prompt.split()) > 6:
+            title += "..."
+        return title
+    def _extract_description(self, prompt: str) -> str:
+        """Extract a short description from the prompt."""
+        sentences = prompt.split(".")
+        if sentences:
+            return sentences[0].strip()[:200]
+        return prompt[:200]
+    def _infer_components(self, prompt_lower: str, sdk: str) -> list:
+        """Infer UI components from the prompt when no template matches."""
+        components = []
+        if sdk == "gradio":
+            if any(w in prompt_lower for w in ["image", "photo", "picture", "upload image"]):
+                components.append("image_upload")
+            if any(w in prompt_lower for w in ["text", "input", "enter", "paste", "type"]):
+                components.append("text_input")
+            if any(w in prompt_lower for w in ["audio", "sound", "voice", "microphone"]):
+                components.append("audio_input")
+            if any(w in prompt_lower for w in ["video", "webcam"]):
+                components.append("video_input")
+            if any(w in prompt_lower for w in ["chart", "plot", "graph", "visual"]):
+                components.append("chart_output")
+            if any(w in prompt_lower for w in ["file", "upload", "download"]):
+                components.append("file_component")
+            if not components:
+                components = ["text_input", "text_output"]
+        elif sdk == "docker":
+            components = ["fastapi_app", "model_endpoint", "health_check"]
+        else:
+            components = ["html_page", "css_styles", "js_scripts"]
+        return components
+    def _infer_model_task(self, prompt_lower: str) -> Optional[str]:
+        """Infer the HF model task from prompt keywords."""
+        task_keywords = {
+            "text-generation": ["generat", "write", "complete", "chat", "story"],
+            "text-classification": ["classif", "sentiment", "emotion", "categor"],
+            "summarization": ["summar", "tldr", "shorten"],
+            "translation": ["translat"],
+            "image-classification": ["image classif", "recognize image", "identify image"],
+            "object-detection": ["object detect", "bounding box", "detect object"],
+            "text-to-image": ["generate image", "text to image", "create image"],
+            "automatic-speech-recognition": ["speech", "transcri", "asr", "voice to text"],
+            "question-answering": ["question answer", "qa"],
+            "token-classification": ["ner", "named entity", "token classif"],
+            "fill-mask": ["fill mask", "mask", "cloze"],
+        }
+        for task, keywords in task_keywords.items():
+            if any(kw in prompt_lower for kw in keywords):
+                return task
+        return "text-generation"  # sensible default

app/engine/model_recommender.py ADDED Viewed

	@@ -0,0 +1,192 @@

+"""
+Recommend Hugging Face models based on the app plan, size preference, and GPU needs.
+"""
+from typing import Optional
+# Curated model recommendations by task and size
+MODEL_CATALOG = {
+    "text-generation": {
+        "small": [
+            {"id": "HuggingFaceTB/SmolLM2-360M-Instruct", "desc": "Compact instruct model, very fast", "size": "360M"},
+        ],
+        "medium": [
+            {"id": "Qwen/Qwen2.5-7B-Instruct", "desc": "Strong general-purpose 7B instruct model", "size": "7B"},
+            {"id": "mistralai/Mistral-7B-Instruct-v0.3", "desc": "Fast and capable instruct model", "size": "7B"},
+        ],
+        "large": [
+            {"id": "meta-llama/Llama-3.1-70B-Instruct", "desc": "Top-tier large language model", "size": "70B"},
+            {"id": "Qwen/Qwen2.5-72B-Instruct", "desc": "Excellent multilingual reasoning", "size": "72B"},
+        ],
+    },
+    "text-classification": {
+        "small": [
+            {"id": "distilbert-base-uncased-finetuned-sst-2-english", "desc": "Fast sentiment classifier", "size": "66M"},
+        ],
+        "medium": [
+            {"id": "cardiffnlp/twitter-roberta-base-sentiment-latest", "desc": "Social media sentiment analysis", "size": "125M"},
+            {"id": "j-hartmann/emotion-english-distilroberta-base", "desc": "Multi-emotion classifier", "size": "82M"},
+        ],
+        "large": [
+            {"id": "SamLowe/roberta-base-go_emotions", "desc": "28-class emotion detection", "size": "125M"},
+        ],
+    },
+    "summarization": {
+        "small": [
+            {"id": "sshleifer/distilbart-cnn-12-6", "desc": "Compact summarization model", "size": "306M"},
+        ],
+        "medium": [
+            {"id": "facebook/bart-large-cnn", "desc": "Strong CNN/DailyMail summarizer", "size": "406M"},
+            {"id": "google/pegasus-xsum", "desc": "Abstractive summarization", "size": "568M"},
+        ],
+        "large": [
+            {"id": "google/pegasus-large", "desc": "High-quality abstractive summaries", "size": "568M"},
+        ],
+    },
+    "translation": {
+        "small": [
+            {"id": "Helsinki-NLP/opus-mt-en-fr", "desc": "English to French translation", "size": "298M"},
+        ],
+        "medium": [
+            {"id": "facebook/mbart-large-50-many-to-many-mmt", "desc": "50-language translation", "size": "611M"},
+        ],
+        "large": [
+            {"id": "facebook/nllb-200-3.3B", "desc": "200-language translation model", "size": "3.3B"},
+        ],
+    },
+    "image-classification": {
+        "small": [
+            {"id": "google/mobilenet_v2_1.0_224", "desc": "Mobile-optimized classifier", "size": "3.4M"},
+        ],
+        "medium": [
+            {"id": "microsoft/resnet-50", "desc": "Classic ResNet-50 ImageNet classifier", "size": "25.6M"},
+            {"id": "google/vit-base-patch16-224", "desc": "Vision Transformer classifier", "size": "86M"},
+        ],
+        "large": [
+            {"id": "google/vit-large-patch16-224", "desc": "Large Vision Transformer", "size": "304M"},
+        ],
+    },
+    "object-detection": {
+        "small": [
+            {"id": "hustvl/yolos-tiny", "desc": "Tiny YOLO-style detector", "size": "6.5M"},
+        ],
+        "medium": [
+            {"id": "facebook/detr-resnet-50", "desc": "DETR object detector", "size": "41M"},
+        ],
+        "large": [
+            {"id": "facebook/detr-resnet-101", "desc": "Large DETR detector", "size": "60M"},
+        ],
+    },
+    "text-to-image": {
+        "small": [
+            {"id": "segmind/SSD-1B", "desc": "Compact SD distilled model", "size": "1.3B"},
+        ],
+        "medium": [
+            {"id": "stabilityai/stable-diffusion-xl-base-1.0", "desc": "SDXL base model", "size": "3.5B"},
+        ],
+        "large": [
+            {"id": "black-forest-labs/FLUX.1-dev", "desc": "State-of-the-art image gen", "size": "12B"},
+        ],
+    },
+    "automatic-speech-recognition": {
+        "small": [
+            {"id": "openai/whisper-tiny", "desc": "Tiny Whisper ASR", "size": "39M"},
+        ],
+        "medium": [
+            {"id": "openai/whisper-base", "desc": "Whisper base ASR model", "size": "74M"},
+            {"id": "openai/whisper-medium", "desc": "Whisper medium ASR model", "size": "769M"},
+        ],
+        "large": [
+            {"id": "openai/whisper-large-v3", "desc": "Best Whisper ASR model", "size": "1.5B"},
+        ],
+    },
+    "question-answering": {
+        "small": [
+            {"id": "distilbert-base-cased-distilled-squad", "desc": "Fast QA model", "size": "66M"},
+        ],
+        "medium": [
+            {"id": "deepset/roberta-base-squad2", "desc": "RoBERTa QA on SQuAD2", "size": "125M"},
+        ],
+        "large": [
+            {"id": "deepset/deberta-v3-large-squad2", "desc": "DeBERTa large QA", "size": "304M"},
+        ],
+    },
+    "token-classification": {
+        "small": [
+            {"id": "dslim/bert-base-NER", "desc": "BERT NER model", "size": "110M"},
+        ],
+        "medium": [
+            {"id": "Jean-Baptiste/roberta-large-ner-english", "desc": "Large NER model", "size": "355M"},
+        ],
+        "large": [
+            {"id": "Jean-Baptiste/roberta-large-ner-english", "desc": "Large NER model", "size": "355M"},
+        ],
+    },
+}
+# GPU recommendation thresholds
+GPU_THRESHOLDS = {
+    "small": False,
+    "medium": False,  # most medium models run on CPU
+    "large": True,
+}
+class ModelRecommender:
+    """Recommend HF models based on app plan and user preferences."""
+    def recommend(
+        self,
+        plan: dict,
+        model_size: str = "medium",
+        gpu_needed: bool = False,
+    ) -> list:
+        """
+        Return a list of recommended model dicts.
+        Each dict has: id, desc, size, gpu_recommended
+        """
+        task = plan.get("model_task")
+        if not task:
+            return []
+        # Normalize size
+        if model_size not in ("small", "medium", "large"):
+            model_size = "medium"
+        task_models = MODEL_CATALOG.get(task, {})
+        candidates = task_models.get(model_size, [])
+        # Fallback: try adjacent sizes
+        if not candidates:
+            for fallback in ("medium", "small", "large"):
+                candidates = task_models.get(fallback, [])
+                if candidates:
+                    break
+        # If still nothing, provide a generic suggestion
+        if not candidates:
+            candidates = [
+                {
+                    "id": f"models?pipeline_tag={task}",
+                    "desc": f"Search HF Hub for {task} models",
+                    "size": "varies",
+                }
+            ]
+        # Annotate with GPU recommendation
+        results = []
+        for model in candidates:
+            m = dict(model)
+            m["gpu_recommended"] = gpu_needed or GPU_THRESHOLDS.get(model_size, False)
+            results.append(m)
+        return results
+    def get_primary_model(self, plan: dict, model_size: str = "medium") -> Optional[str]:
+        """Get the single best model ID for the plan."""
+        models = self.recommend(plan, model_size)
+        if models:
+            return models[0]["id"]
+        return None

app/main.py ADDED Viewed

	@@ -0,0 +1,326 @@

+import os
+import io
+import json
+import uuid
+import zipfile
+import traceback
+from pathlib import Path
+from typing import Optional
+from fastapi import FastAPI, Request, Form, HTTPException
+from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from app.engine.app_planner import AppPlanner
+from app.engine.model_recommender import ModelRecommender
+from app.codegen.repo_generator import RepoGenerator
+from app.validators.code_checker import CodeChecker
+app = FastAPI(title="AutoApp Builder", version="1.0.0")
+BASE_DIR = Path(__file__).resolve().parent
+GENERATED_DIR = Path("/tmp/autoapp_generated")
+GENERATED_DIR.mkdir(parents=True, exist_ok=True)
+app.mount("/static", StaticFiles(directory=str(BASE_DIR / "static")), name="static")
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+# In-memory store for generated projects (keyed by session id)
+projects: dict = {}
+planner = AppPlanner()
+recommender = ModelRecommender()
+generator = RepoGenerator()
+checker = CodeChecker()
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    examples = [
+        {
+            "title": "Image Classifier",
+            "prompt": "Build a Gradio app that classifies images using a pretrained ResNet model. Users upload an image and get top-5 predictions with confidence bars.",
+        },
+        {
+            "title": "AI Chatbot",
+            "prompt": "Create a chatbot that uses a Hugging Face language model to have conversations. Include chat history, system prompt configuration, and a clear button.",
+        },
+        {
+            "title": "Text Summarizer",
+            "prompt": "Build an app that summarizes long text documents. Let users paste text or upload a .txt file, choose summary length (short/medium/long), and display the result.",
+        },
+        {
+            "title": "Sentiment Dashboard",
+            "prompt": "Create an interactive sentiment analysis tool. Users enter text and see sentiment scores (positive/negative/neutral) visualized with charts.",
+        },
+        {
+            "title": "REST API Service",
+            "prompt": "Build a Docker-based REST API that serves a text generation model with endpoints for completion, summarization, and translation. Include API docs.",
+        },
+        {
+            "title": "Portfolio Site",
+            "prompt": "Create a beautiful static portfolio website for a data scientist. Include sections for projects, skills, publications, and contact info with a dark theme.",
+        },
+    ]
+    return templates.TemplateResponse(
+        "home.html", {"request": request, "examples": examples}
+    )
+@app.post("/generate", response_class=HTMLResponse)
+async def generate(
+    request: Request,
+    prompt: str = Form(...),
+    sdk_preference: str = Form("auto"),
+    model_size: str = Form("medium"),
+    gpu_needed: bool = Form(False),
+    features: str = Form(""),
+):
+    try:
+        # Step 1: Plan the app
+        plan = planner.analyze(prompt, sdk_preference)
+        # Step 2: Recommend models
+        recommended_models = recommender.recommend(plan, model_size, gpu_needed)
+        plan["recommended_models"] = recommended_models
+        # Step 3: Parse additional features
+        feature_list = [f.strip() for f in features.split(",") if f.strip()]
+        plan["extra_features"] = feature_list
+        # Step 4: Generate repository files
+        repo_files = generator.generate(plan, prompt)
+        # Step 5: Validate the generated code
+        validation = checker.check(repo_files, plan["sdk"])
+        # Step 6: Store the project
+        project_id = str(uuid.uuid4())[:8]
+        projects[project_id] = {
+            "plan": plan,
+            "files": repo_files,
+            "validation": validation,
+            "prompt": prompt,
+        }
+        # Build file tree structure
+        file_tree = _build_file_tree(repo_files)
+        # Generate architecture diagram
+        arch_diagram = _generate_arch_diagram(plan)
+        return templates.TemplateResponse(
+            "result.html",
+            {
+                "request": request,
+                "project_id": project_id,
+                "plan": plan,
+                "files": repo_files,
+                "file_tree": file_tree,
+                "validation": validation,
+                "arch_diagram": arch_diagram,
+                "prompt": prompt,
+            },
+        )
+    except Exception as e:
+        traceback.print_exc()
+        return templates.TemplateResponse(
+            "home.html",
+            {
+                "request": request,
+                "examples": [],
+                "error": f"Generation failed: {str(e)}. Please try again with a different prompt.",
+            },
+        )
+@app.post("/edit", response_class=HTMLResponse)
+async def edit_project(
+    request: Request,
+    project_id: str = Form(...),
+    edit_prompt: str = Form(...),
+):
+    if project_id not in projects:
+        raise HTTPException(status_code=404, detail="Project not found")
+    project = projects[project_id]
+    original_plan = project["plan"]
+    original_files = project["files"]
+    try:
+        # Re-generate with edit instructions
+        updated_files = generator.edit(original_plan, original_files, edit_prompt)
+        validation = checker.check(updated_files, original_plan["sdk"])
+        project["files"] = updated_files
+        project["validation"] = validation
+        file_tree = _build_file_tree(updated_files)
+        arch_diagram = _generate_arch_diagram(original_plan)
+        return templates.TemplateResponse(
+            "result.html",
+            {
+                "request": request,
+                "project_id": project_id,
+                "plan": original_plan,
+                "files": updated_files,
+                "file_tree": file_tree,
+                "validation": validation,
+                "arch_diagram": arch_diagram,
+                "prompt": project["prompt"],
+                "edit_prompt": edit_prompt,
+            },
+        )
+    except Exception as e:
+        traceback.print_exc()
+        # Return original project with error
+        file_tree = _build_file_tree(original_files)
+        arch_diagram = _generate_arch_diagram(original_plan)
+        return templates.TemplateResponse(
+            "result.html",
+            {
+                "request": request,
+                "project_id": project_id,
+                "plan": original_plan,
+                "files": original_files,
+                "file_tree": file_tree,
+                "validation": project["validation"],
+                "arch_diagram": arch_diagram,
+                "prompt": project["prompt"],
+                "edit_error": f"Edit failed: {str(e)}",
+            },
+        )
+@app.get("/download/{project_id}")
+async def download_zip(project_id: str):
+    if project_id not in projects:
+        raise HTTPException(status_code=404, detail="Project not found")
+    project = projects[project_id]
+    files = project["files"]
+    plan = project["plan"]
+    app_name = plan.get("app_name", "my-hf-space")
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for filepath, content in files.items():
+            zf.writestr(f"{app_name}/{filepath}", content)
+    buf.seek(0)
+    return StreamingResponse(
+        buf,
+        media_type="application/zip",
+        headers={"Content-Disposition": f'attachment; filename="{app_name}.zip"'},
+    )
+@app.get("/api/file/{project_id}/{filepath:path}")
+async def get_file(project_id: str, filepath: str):
+    if project_id not in projects:
+        raise HTTPException(status_code=404, detail="Project not found")
+    files = projects[project_id]["files"]
+    if filepath not in files:
+        raise HTTPException(status_code=404, detail="File not found")
+    return JSONResponse({"filename": filepath, "content": files[filepath]})
+def _build_file_tree(files: dict) -> list:
+    """Build a nested file tree structure from flat file dict."""
+    tree = []
+    dirs_seen = set()
+    sorted_files = sorted(files.keys())
+    for filepath in sorted_files:
+        parts = filepath.split("/")
+        # Add directory entries
+        for i in range(len(parts) - 1):
+            dir_path = "/".join(parts[: i + 1])
+            if dir_path not in dirs_seen:
+                dirs_seen.add(dir_path)
+                tree.append(
+                    {
+                        "path": dir_path,
+                        "name": parts[i],
+                        "type": "dir",
+                        "depth": i,
+                    }
+                )
+        # Add file entry
+        tree.append(
+            {
+                "path": filepath,
+                "name": parts[-1],
+                "type": "file",
+                "depth": len(parts) - 1,
+            }
+        )
+    return tree
+def _generate_arch_diagram(plan: dict) -> str:
+    """Generate ASCII architecture diagram."""
+    sdk = plan.get("sdk", "gradio")
+    app_name = plan.get("app_name", "App")
+    components = plan.get("components", [])
+    if sdk == "gradio":
+        diagram = f"""
++------------------------------------------------------+
+|                  Hugging Face Spaces                  |
+|  +------------------------------------------------+  |
+|  |              {app_name:^30s}          |  |
+|  |  +------------------------------------------+  |  |
+|  |  |            Gradio Interface               |  |  |
+|  |  |  +------------+    +------------------+   |  |  |
+|  |  |  |   Inputs   |--->|   Processing     |   |  |  |
+|  |  |  +------------+    |  +------------+  |   |  |  |
+|  |  |                    |  |  HF Model  |  |   |  |  |
+|  |  |  +------------+    |  +------------+  |   |  |  |
+|  |  |  |  Outputs   |<---|                  |   |  |  |
+|  |  |  +------------+    +------------------+   |  |  |
+|  |  +------------------------------------------+  |  |
+|  +------------------------------------------------+  |
++------------------------------------------------------+"""
+    elif sdk == "docker":
+        diagram = f"""
++------------------------------------------------------+
+|                  Hugging Face Spaces                  |
+|  +------------------------------------------------+  |
+|  |            Docker Container                     |  |
+|  |  +------------------------------------------+  |  |
+|  |  |         {app_name:^30s}      |  |  |
+|  |  |  +----------+  +----------+  +---------+ |  |  |
+|  |  |  |  FastAPI  |  |  Model   |  |  Utils  | |  |  |
+|  |  |  |  Routes   |  |  Service |  |         | |  |  |
+|  |  |  +-----+-----+  +----+-----+  +---------+ |  |  |
+|  |  |        |              |                    |  |  |
+|  |  |  +-----v--------------v-----------------+ |  |  |
+|  |  |  |        API Endpoints                  | |  |  |
+|  |  |  +---------------------------------------+ |  |  |
+|  |  +------------------------------------------+  |  |
+|  +------------------------------------------------+  |
++------------------------------------------------------+"""
+    else:
+        diagram = f"""
++------------------------------------------------------+
+|                  Hugging Face Spaces                  |
+|  +------------------------------------------------+  |
+|  |            Static Site                          |  |
+|  |  +------------------------------------------+  |  |
+|  |  |         {app_name:^30s}      |  |  |
+|  |  |  +----------+  +----------+  +---------+ |  |  |
+|  |  |  |  HTML     |  |  CSS     |  |   JS   | |  |  |
+|  |  |  |  Pages    |  |  Styles  |  | Scripts | |  |  |
+|  |  |  +----------+  +----------+  +---------+ |  |  |
+|  |  +------------------------------------------+  |  |
+|  +------------------------------------------------+  |
++------------------------------------------------------+"""
+    return diagram

app/static/app.js ADDED Viewed

	@@ -0,0 +1,211 @@

+/**
+ * AutoApp Builder - Frontend JavaScript
+ */
+// ─── Character Counter ──────────────────────────────────────────────
+const promptInput = document.getElementById('promptInput');
+const charCount = document.getElementById('charCount');
+if (promptInput && charCount) {
+    promptInput.addEventListener('input', () => {
+        const len = promptInput.value.length;
+        charCount.textContent = `${len} / 2000`;
+        if (len > 1800) {
+            charCount.classList.add('text-yellow-500');
+        } else {
+            charCount.classList.remove('text-yellow-500');
+        }
+    });
+}
+// ─── Example Buttons ────────────────────────────────────────────────
+document.querySelectorAll('.example-btn').forEach(btn => {
+    btn.addEventListener('click', () => {
+        const prompt = btn.getAttribute('data-prompt');
+        if (promptInput && prompt) {
+            promptInput.value = prompt;
+            promptInput.dispatchEvent(new Event('input'));
+            promptInput.focus();
+            // Scroll to textarea
+            promptInput.scrollIntoView({ behavior: 'smooth', block: 'center' });
+        }
+    });
+});
+// ─── SDK Preference Toggle ──────────────────────────────────────────
+document.querySelectorAll('.sdk-option').forEach(label => {
+    label.addEventListener('click', () => {
+        // Remove active styles from all
+        document.querySelectorAll('.sdk-option').forEach(l => {
+            l.classList.remove('bg-cyan-500/20', 'text-cyan-400');
+            l.classList.add('text-dark-400');
+        });
+        // Add active style to clicked
+        label.classList.add('bg-cyan-500/20', 'text-cyan-400');
+        label.classList.remove('text-dark-400');
+    });
+});
+// ─── Advanced Options Toggle ────────────────────────────────────────
+const toggleAdvanced = document.getElementById('toggleAdvanced');
+const advancedPanel = document.getElementById('advancedPanel');
+const advancedArrow = document.getElementById('advancedArrow');
+if (toggleAdvanced && advancedPanel) {
+    toggleAdvanced.addEventListener('click', () => {
+        advancedPanel.classList.toggle('hidden');
+        if (advancedArrow) {
+            advancedArrow.style.transform = advancedPanel.classList.contains('hidden')
+                ? 'rotate(0deg)'
+                : 'rotate(90deg)';
+        }
+    });
+}
+// ─── Form Submission Loading State ──────────────────────────────────
+const generateForm = document.getElementById('generateForm');
+if (generateForm) {
+    generateForm.addEventListener('submit', () => {
+        const btn = document.getElementById('submitBtn');
+        const text = document.getElementById('submitText');
+        const spinner = document.getElementById('submitSpinner');
+        if (btn) btn.disabled = true;
+        if (text) text.textContent = 'Generating...';
+        if (spinner) spinner.classList.remove('hidden');
+        btn.classList.add('opacity-75', 'cursor-not-allowed');
+    });
+}
+const editForm = document.getElementById('editForm');
+if (editForm) {
+    editForm.addEventListener('submit', () => {
+        const btn = document.getElementById('editBtn');
+        const text = document.getElementById('editText');
+        const spinner = document.getElementById('editSpinner');
+        if (btn) btn.disabled = true;
+        if (text) text.textContent = 'Editing...';
+        if (spinner) spinner.classList.remove('hidden');
+        btn.classList.add('opacity-75', 'cursor-not-allowed');
+    });
+}
+// ─── File Selection & Code Preview (Result Page) ────────────────────
+function selectFile(filepath) {
+    if (typeof fileData === 'undefined') return;
+    const content = fileData[filepath];
+    if (content === undefined) return;
+    // Update active state in tree
+    document.querySelectorAll('.file-tree-item').forEach(item => {
+        item.classList.remove('active');
+    });
+    const activeItem = document.querySelector(`[data-filepath="${filepath}"]`);
+    if (activeItem) activeItem.classList.add('active');
+    // Update filename display
+    const fileNameEl = document.getElementById('currentFileName');
+    if (fileNameEl) fileNameEl.textContent = filepath;
+    // Determine language for syntax highlighting
+    const lang = getLanguage(filepath);
+    // Show code block, hide placeholder
+    const placeholder = document.getElementById('codePlaceholder');
+    const codeBlock = document.getElementById('codeBlock');
+    const codeContent = document.getElementById('codeContent');
+    if (placeholder) placeholder.classList.add('hidden');
+    if (codeBlock) codeBlock.classList.remove('hidden');
+    if (codeContent) {
+        // Escape HTML entities
+        codeContent.textContent = content;
+        codeContent.className = `language-${lang}`;
+        // Re-highlight
+        if (window.Prism) {
+            Prism.highlightElement(codeContent);
+        }
+    }
+}
+function getLanguage(filepath) {
+    const ext = filepath.split('.').pop().toLowerCase();
+    const langMap = {
+        'py': 'python',
+        'js': 'javascript',
+        'ts': 'javascript',
+        'html': 'markup',
+        'htm': 'markup',
+        'css': 'css',
+        'md': 'markdown',
+        'yaml': 'yaml',
+        'yml': 'yaml',
+        'json': 'javascript',
+        'sh': 'bash',
+        'bash': 'bash',
+        'dockerfile': 'docker',
+        'txt': 'text',
+        'toml': 'text',
+        'cfg': 'text',
+        'ini': 'text',
+        'gitignore': 'text',
+    };
+    // Handle Dockerfile specifically
+    if (filepath.toLowerCase() === 'dockerfile') return 'docker';
+    return langMap[ext] || 'text';
+}
+// ─── Copy Code ──────────────────────────────────────────────────────
+function copyCode() {
+    const codeContent = document.getElementById('codeContent');
+    if (!codeContent) return;
+    const text = codeContent.textContent;
+    navigator.clipboard.writeText(text).then(() => {
+        const btn = document.getElementById('copyBtn');
+        if (btn) {
+            const originalHTML = btn.innerHTML;
+            btn.innerHTML = '<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg> Copied!';
+            btn.classList.add('text-emerald-400');
+            setTimeout(() => {
+                btn.innerHTML = originalHTML;
+                btn.classList.remove('text-emerald-400');
+            }, 2000);
+        }
+    }).catch(() => {
+        // Fallback: select text
+        const range = document.createRange();
+        range.selectNodeContents(codeContent);
+        const sel = window.getSelection();
+        sel.removeAllRanges();
+        sel.addRange(range);
+    });
+}
+// ─── Architecture Diagram Toggle ────────────────────────────────────
+function toggleDiagram() {
+    const panel = document.getElementById('diagramPanel');
+    const toggle = document.getElementById('diagramToggle');
+    if (panel) {
+        panel.classList.toggle('hidden');
+        if (toggle) {
+            toggle.textContent = panel.classList.contains('hidden') ? 'Show' : 'Hide';
+        }
+    }
+}
+// ─── Keyboard Shortcuts ─────────────────────────────────────────────
+document.addEventListener('keydown', (e) => {
+    // Ctrl/Cmd + Enter to submit form
+    if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
+        const form = document.getElementById('generateForm') || document.getElementById('editForm');
+        if (form) {
+            form.dispatchEvent(new Event('submit', { bubbles: true }));
+            form.submit();
+        }
+    }
+});

app/templates/base.html ADDED Viewed

	@@ -0,0 +1,187 @@

+<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}AutoApp Builder{% endblock %}</title>
+    <!-- TailwindCSS -->
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        tailwind.config = {
+            darkMode: 'class',
+            theme: {
+                extend: {
+                    colors: {
+                        dark: {
+                            50: '#f8fafc',
+                            100: '#f1f5f9',
+                            200: '#e2e8f0',
+                            300: '#cbd5e1',
+                            400: '#94a3b8',
+                            500: '#64748b',
+                            600: '#475569',
+                            700: '#334155',
+                            800: '#1e293b',
+                            900: '#0f172a',
+                            950: '#020617',
+                        }
+                    },
+                    animation: {
+                        'gradient': 'gradient 6s ease infinite',
+                        'float': 'float 6s ease-in-out infinite',
+                        'pulse-slow': 'pulse 4s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+                        'fade-in': 'fadeIn 0.5s ease forwards',
+                        'slide-up': 'slideUp 0.5s ease forwards',
+                    },
+                    keyframes: {
+                        gradient: {
+                            '0%, 100%': { backgroundPosition: '0% 50%' },
+                            '50%': { backgroundPosition: '100% 50%' },
+                        },
+                        float: {
+                            '0%, 100%': { transform: 'translateY(0px)' },
+                            '50%': { transform: 'translateY(-10px)' },
+                        },
+                        fadeIn: {
+                            from: { opacity: '0' },
+                            to: { opacity: '1' },
+                        },
+                        slideUp: {
+                            from: { opacity: '0', transform: 'translateY(20px)' },
+                            to: { opacity: '1', transform: 'translateY(0)' },
+                        },
+                    }
+                }
+            }
+        }
+    </script>
+    <!-- Prism.js for code highlighting -->
+    <link href="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism-tomorrow.min.css" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/prism.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-python.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-bash.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-docker.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-yaml.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-markdown.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-markup.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-css.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-javascript.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/line-numbers/prism-line-numbers.min.js"></script>
+    <link href="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/line-numbers/prism-line-numbers.min.css" rel="stylesheet">
+    <style>
+        /* Custom scrollbar */
+        ::-webkit-scrollbar { width: 8px; height: 8px; }
+        ::-webkit-scrollbar-track { background: #0f172a; }
+        ::-webkit-scrollbar-thumb { background: #334155; border-radius: 4px; }
+        ::-webkit-scrollbar-thumb:hover { background: #475569; }
+        /* Glassmorphism */
+        .glass {
+            background: rgba(15, 23, 42, 0.7);
+            backdrop-filter: blur(16px);
+            -webkit-backdrop-filter: blur(16px);
+            border: 1px solid rgba(56, 189, 248, 0.1);
+        }
+        .glass-light {
+            background: rgba(30, 41, 59, 0.5);
+            backdrop-filter: blur(12px);
+            -webkit-backdrop-filter: blur(12px);
+            border: 1px solid rgba(56, 189, 248, 0.08);
+        }
+        /* Gradient text */
+        .gradient-text {
+            background: linear-gradient(135deg, #38bdf8, #818cf8, #c084fc);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+        /* Animated gradient background */
+        .animated-gradient {
+            background: linear-gradient(-45deg, #0f172a, #1e1b4b, #172554, #0f172a);
+            background-size: 400% 400%;
+            animation: gradient 6s ease infinite;
+        }
+        /* Glow effects */
+        .glow-blue { box-shadow: 0 0 20px rgba(56, 189, 248, 0.15); }
+        .glow-purple { box-shadow: 0 0 20px rgba(139, 92, 246, 0.15); }
+        /* Code preview overrides */
+        pre[class*="language-"] {
+            background: #0d1117 !important;
+            border-radius: 8px;
+            font-size: 0.85rem;
+            margin: 0;
+        }
+        code[class*="language-"] {
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+        }
+        /* Loading spinner */
+        .spinner {
+            border: 3px solid rgba(56, 189, 248, 0.2);
+            border-top: 3px solid #38bdf8;
+            border-radius: 50%;
+            width: 24px;
+            height: 24px;
+            animation: spin 0.8s linear infinite;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        /* File tree styling */
+        .file-tree-item { transition: all 0.15s ease; }
+        .file-tree-item:hover { background: rgba(56, 189, 248, 0.08); }
+        .file-tree-item.active { background: rgba(56, 189, 248, 0.15); border-left: 2px solid #38bdf8; }
+        /* Textarea styling */
+        textarea:focus { outline: none; }
+        /* Smooth transitions */
+        .transition-smooth { transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1); }
+    </style>
+    {% block extra_head %}{% endblock %}
+</head>
+<body class="bg-dark-950 text-dark-200 min-h-screen">
+    <!-- Navigation -->
+    <nav class="glass sticky top-0 z-50 px-6 py-3">
+        <div class="max-w-7xl mx-auto flex items-center justify-between">
+            <a href="/" class="flex items-center gap-3 group">
+                <div class="w-9 h-9 rounded-lg bg-gradient-to-br from-cyan-500 to-blue-600 flex items-center justify-center text-white font-bold text-sm group-hover:scale-110 transition-transform">
+                    AB
+                </div>
+                <span class="text-lg font-bold gradient-text">AutoApp Builder</span>
+            </a>
+            <div class="flex items-center gap-4">
+                <a href="/" class="text-dark-400 hover:text-cyan-400 transition-colors text-sm font-medium">New Project</a>
+                <a href="https://huggingface.co/spaces" target="_blank" class="text-dark-400 hover:text-cyan-400 transition-colors text-sm font-medium">HF Spaces</a>
+            </div>
+        </div>
+    </nav>
+    <!-- Main Content -->
+    <main>
+        {% block content %}{% endblock %}
+    </main>
+    <!-- Footer -->
+    <footer class="border-t border-dark-800 mt-16 py-8 px-6">
+        <div class="max-w-7xl mx-auto text-center text-dark-500 text-sm">
+            <p>AutoApp Builder &mdash; Generate complete HF Space repos from natural language.</p>
+            <p class="mt-1">Powered by Hugging Face Inference API</p>
+        </div>
+    </footer>
+    <script src="/static/app.js"></script>
+    {% block extra_scripts %}{% endblock %}
+</body>
+</html>

app/templates/home.html ADDED Viewed

	@@ -0,0 +1,236 @@

+{% extends "base.html" %}
+{% block title %}AutoApp Builder - Generate HF Spaces from Prompts{% endblock %}
+{% block content %}
+<!-- Hero Section -->
+<section class="animated-gradient py-20 px-6 relative overflow-hidden">
+    <!-- Background decorations -->
+    <div class="absolute inset-0 overflow-hidden pointer-events-none">
+        <div class="absolute top-20 left-10 w-72 h-72 bg-cyan-500/10 rounded-full blur-3xl animate-float"></div>
+        <div class="absolute bottom-10 right-10 w-96 h-96 bg-purple-500/10 rounded-full blur-3xl animate-float" style="animation-delay: -3s;"></div>
+        <div class="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-[600px] h-[600px] bg-blue-500/5 rounded-full blur-3xl"></div>
+    </div>
+    <div class="max-w-4xl mx-auto text-center relative z-10">
+        <div class="inline-flex items-center gap-2 px-4 py-1.5 rounded-full glass-light text-cyan-400 text-sm font-medium mb-6">
+            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"/></svg>
+            LLM-Powered Code Generation
+        </div>
+        <h1 class="text-5xl md:text-6xl font-extrabold mb-6 leading-tight">
+            <span class="gradient-text">Build HF Spaces</span><br>
+            <span class="text-dark-200">From a Simple Prompt</span>
+        </h1>
+        <p class="text-xl text-dark-400 max-w-2xl mx-auto mb-10 leading-relaxed">
+            Describe your app idea in plain English. AutoApp Builder generates a complete,
+            working Hugging Face Space repository &mdash; ready to deploy.
+        </p>
+        <!-- Stats -->
+        <div class="flex items-center justify-center gap-8 mb-10 text-sm">
+            <div class="flex items-center gap-2 text-dark-400">
+                <svg class="w-5 h-5 text-emerald-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>
+                Gradio Apps
+            </div>
+            <div class="flex items-center gap-2 text-dark-400">
+                <svg class="w-5 h-5 text-emerald-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>
+                Docker APIs
+            </div>
+            <div class="flex items-center gap-2 text-dark-400">
+                <svg class="w-5 h-5 text-emerald-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>
+                Static Sites
+            </div>
+        </div>
+    </div>
+</section>
+<!-- Main Form -->
+<section class="max-w-4xl mx-auto px-6 -mt-8 relative z-20">
+    {% if error %}
+    <div class="mb-6 p-4 rounded-xl bg-red-900/30 border border-red-500/30 text-red-300 animate-fade-in">
+        <div class="flex items-center gap-3">
+            <svg class="w-5 h-5 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/></svg>
+            <span>{{ error }}</span>
+        </div>
+    </div>
+    {% endif %}
+    <form id="generateForm" action="/generate" method="POST" class="glass rounded-2xl p-8 glow-blue">
+        <!-- Prompt Input -->
+        <div class="mb-6">
+            <label class="block text-sm font-semibold text-dark-300 mb-2">
+                Describe Your App
+            </label>
+            <div class="relative">
+                <textarea
+                    name="prompt"
+                    id="promptInput"
+                    rows="4"
+                    required
+                    class="w-full bg-dark-900/80 border border-dark-700 rounded-xl px-5 py-4 text-dark-200 placeholder-dark-500 focus:border-cyan-500/50 focus:ring-2 focus:ring-cyan-500/20 resize-none transition-all"
+                    placeholder="e.g., Build a Gradio app that classifies images using a pretrained ResNet model..."
+                ></textarea>
+                <!-- Character count -->
+                <div class="absolute bottom-3 right-3 text-xs text-dark-600" id="charCount">0 / 2000</div>
+            </div>
+        </div>
+        <!-- Examples Dropdown -->
+        <div class="mb-6">
+            <label class="block text-sm font-semibold text-dark-300 mb-2">Quick Examples</label>
+            <div class="grid grid-cols-2 md:grid-cols-3 gap-2">
+                {% for example in examples %}
+                <button
+                    type="button"
+                    class="example-btn text-left p-3 rounded-lg glass-light hover:border-cyan-500/30 transition-all text-sm group"
+                    data-prompt="{{ example.prompt }}"
+                >
+                    <span class="text-dark-300 group-hover:text-cyan-400 font-medium transition-colors">{{ example.title }}</span>
+                </button>
+                {% endfor %}
+            </div>
+        </div>
+        <!-- Options Row -->
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+            <!-- SDK Preference -->
+            <div>
+                <label class="block text-sm font-semibold text-dark-300 mb-2">SDK Preference</label>
+                <div class="flex rounded-lg overflow-hidden border border-dark-700">
+                    <label class="sdk-option flex-1 text-center py-2.5 cursor-pointer transition-all text-sm font-medium bg-cyan-500/20 text-cyan-400 border-r border-dark-700">
+                        <input type="radio" name="sdk_preference" value="auto" checked class="hidden"> Auto
+                    </label>
+                    <label class="sdk-option flex-1 text-center py-2.5 cursor-pointer transition-all text-sm font-medium text-dark-400 hover:text-dark-200 border-r border-dark-700">
+                        <input type="radio" name="sdk_preference" value="gradio" class="hidden"> Gradio
+                    </label>
+                    <label class="sdk-option flex-1 text-center py-2.5 cursor-pointer transition-all text-sm font-medium text-dark-400 hover:text-dark-200 border-r border-dark-700">
+                        <input type="radio" name="sdk_preference" value="docker" class="hidden"> Docker
+                    </label>
+                    <label class="sdk-option flex-1 text-center py-2.5 cursor-pointer transition-all text-sm font-medium text-dark-400 hover:text-dark-200">
+                        <input type="radio" name="sdk_preference" value="static" class="hidden"> Static
+                    </label>
+                </div>
+            </div>
+            <!-- Model Size -->
+            <div>
+                <label class="block text-sm font-semibold text-dark-300 mb-2">Model Size</label>
+                <select name="model_size" class="w-full bg-dark-900/80 border border-dark-700 rounded-lg px-4 py-2.5 text-dark-300 text-sm focus:border-cyan-500/50 focus:ring-2 focus:ring-cyan-500/20">
+                    <option value="small">Small (fastest)</option>
+                    <option value="medium" selected>Medium (balanced)</option>
+                    <option value="large">Large (best quality)</option>
+                </select>
+            </div>
+            <!-- GPU Toggle -->
+            <div>
+                <label class="block text-sm font-semibold text-dark-300 mb-2">GPU Required</label>
+                <label class="flex items-center gap-3 bg-dark-900/80 border border-dark-700 rounded-lg px-4 py-2.5 cursor-pointer">
+                    <input type="checkbox" name="gpu_needed" value="true" class="w-4 h-4 rounded border-dark-600 text-cyan-500 focus:ring-cyan-500/30 bg-dark-800">
+                    <span class="text-dark-400 text-sm">Enable GPU hardware</span>
+                </label>
+            </div>
+        </div>
+        <!-- Advanced: Extra Features -->
+        <div class="mb-6">
+            <button type="button" id="toggleAdvanced" class="text-sm text-dark-500 hover:text-cyan-400 transition-colors flex items-center gap-1">
+                <svg id="advancedArrow" class="w-4 h-4 transition-transform" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"/></svg>
+                Advanced Options
+            </button>
+            <div id="advancedPanel" class="hidden mt-3">
+                <label class="block text-sm font-semibold text-dark-300 mb-2">Extra Features (comma-separated)</label>
+                <input
+                    type="text"
+                    name="features"
+                    class="w-full bg-dark-900/80 border border-dark-700 rounded-lg px-4 py-2.5 text-dark-300 placeholder-dark-600 text-sm focus:border-cyan-500/50 focus:ring-2 focus:ring-cyan-500/20"
+                    placeholder="e.g., dark theme, error handling, caching, rate limiting"
+                >
+            </div>
+        </div>
+        <!-- Submit Button -->
+        <button
+            type="submit"
+            id="submitBtn"
+            class="w-full py-4 rounded-xl bg-gradient-to-r from-cyan-500 to-blue-600 hover:from-cyan-400 hover:to-blue-500 text-white font-bold text-lg transition-all hover:shadow-lg hover:shadow-cyan-500/20 flex items-center justify-center gap-3"
+        >
+            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"/></svg>
+            <span id="submitText">Generate Space</span>
+            <div id="submitSpinner" class="spinner hidden"></div>
+        </button>
+    </form>
+</section>
+<!-- How It Works -->
+<section class="max-w-5xl mx-auto px-6 py-20">
+    <h2 class="text-3xl font-bold text-center mb-12 gradient-text">How It Works</h2>
+    <div class="grid md:grid-cols-4 gap-6">
+        <div class="text-center animate-slide-up" style="animation-delay: 0.1s;">
+            <div class="w-14 h-14 rounded-2xl bg-gradient-to-br from-cyan-500/20 to-blue-500/20 flex items-center justify-center mx-auto mb-4 text-2xl">1</div>
+            <h3 class="font-semibold text-dark-200 mb-2">Describe</h3>
+            <p class="text-dark-500 text-sm">Write a plain-English description of your app idea</p>
+        </div>
+        <div class="text-center animate-slide-up" style="animation-delay: 0.2s;">
+            <div class="w-14 h-14 rounded-2xl bg-gradient-to-br from-blue-500/20 to-purple-500/20 flex items-center justify-center mx-auto mb-4 text-2xl">2</div>
+            <h3 class="font-semibold text-dark-200 mb-2">Analyze</h3>
+            <p class="text-dark-500 text-sm">AI selects the best SDK, models, and architecture</p>
+        </div>
+        <div class="text-center animate-slide-up" style="animation-delay: 0.3s;">
+            <div class="w-14 h-14 rounded-2xl bg-gradient-to-br from-purple-500/20 to-pink-500/20 flex items-center justify-center mx-auto mb-4 text-2xl">3</div>
+            <h3 class="font-semibold text-dark-200 mb-2">Generate</h3>
+            <p class="text-dark-500 text-sm">LLM generates complete, working code for every file</p>
+        </div>
+        <div class="text-center animate-slide-up" style="animation-delay: 0.4s;">
+            <div class="w-14 h-14 rounded-2xl bg-gradient-to-br from-pink-500/20 to-red-500/20 flex items-center justify-center mx-auto mb-4 text-2xl">4</div>
+            <h3 class="font-semibold text-dark-200 mb-2">Deploy</h3>
+            <p class="text-dark-500 text-sm">Download the ZIP and push to Hugging Face Spaces</p>
+        </div>
+    </div>
+</section>
+<!-- Supported SDK cards -->
+<section class="max-w-5xl mx-auto px-6 pb-20">
+    <h2 class="text-3xl font-bold text-center mb-12 gradient-text">Supported SDKs</h2>
+    <div class="grid md:grid-cols-3 gap-6">
+        <div class="glass rounded-xl p-6 hover:glow-blue transition-all group">
+            <div class="flex items-center gap-3 mb-4">
+                <div class="w-10 h-10 rounded-lg bg-orange-500/20 flex items-center justify-center text-orange-400 text-lg font-bold">G</div>
+                <h3 class="text-lg font-bold text-dark-200">Gradio</h3>
+            </div>
+            <p class="text-dark-400 text-sm leading-relaxed mb-4">Interactive ML demos, chatbots, image classifiers, audio/video processing, and more.</p>
+            <div class="flex flex-wrap gap-1.5">
+                <span class="text-xs px-2 py-1 rounded-full bg-orange-500/10 text-orange-400">ML Demos</span>
+                <span class="text-xs px-2 py-1 rounded-full bg-orange-500/10 text-orange-400">Chatbots</span>
+                <span class="text-xs px-2 py-1 rounded-full bg-orange-500/10 text-orange-400">Vision</span>
+            </div>
+        </div>
+        <div class="glass rounded-xl p-6 hover:glow-blue transition-all group">
+            <div class="flex items-center gap-3 mb-4">
+                <div class="w-10 h-10 rounded-lg bg-blue-500/20 flex items-center justify-center text-blue-400 text-lg font-bold">D</div>
+                <h3 class="text-lg font-bold text-dark-200">Docker</h3>
+            </div>
+            <p class="text-dark-400 text-sm leading-relaxed mb-4">REST APIs, custom backends, agents, websocket apps, complex multi-service workflows.</p>
+            <div class="flex flex-wrap gap-1.5">
+                <span class="text-xs px-2 py-1 rounded-full bg-blue-500/10 text-blue-400">APIs</span>
+                <span class="text-xs px-2 py-1 rounded-full bg-blue-500/10 text-blue-400">Agents</span>
+                <span class="text-xs px-2 py-1 rounded-full bg-blue-500/10 text-blue-400">Backends</span>
+            </div>
+        </div>
+        <div class="glass rounded-xl p-6 hover:glow-blue transition-all group">
+            <div class="flex items-center gap-3 mb-4">
+                <div class="w-10 h-10 rounded-lg bg-emerald-500/20 flex items-center justify-center text-emerald-400 text-lg font-bold">S</div>
+                <h3 class="text-lg font-bold text-dark-200">Static</h3>
+            </div>
+            <p class="text-dark-400 text-sm leading-relaxed mb-4">Landing pages, portfolios, documentation sites, galleries, and pure frontend apps.</p>
+            <div class="flex flex-wrap gap-1.5">
+                <span class="text-xs px-2 py-1 rounded-full bg-emerald-500/10 text-emerald-400">Portfolio</span>
+                <span class="text-xs px-2 py-1 rounded-full bg-emerald-500/10 text-emerald-400">Docs</span>
+                <span class="text-xs px-2 py-1 rounded-full bg-emerald-500/10 text-emerald-400">Showcase</span>
+            </div>
+        </div>
+    </div>
+</section>
+{% endblock %}

app/templates/result.html ADDED Viewed

	@@ -0,0 +1,217 @@

+{% extends "base.html" %}
+{% block title %}{{ plan.title }} - AutoApp Builder{% endblock %}
+{% block content %}
+<div class="max-w-7xl mx-auto px-6 py-8">
+    <!-- Header -->
+    <div class="flex flex-col md:flex-row items-start md:items-center justify-between gap-4 mb-8 animate-fade-in">
+        <div>
+            <div class="flex items-center gap-3 mb-2">
+                <span class="px-3 py-1 rounded-full text-xs font-bold uppercase tracking-wider
+                    {% if plan.sdk == 'gradio' %}bg-orange-500/20 text-orange-400
+                    {% elif plan.sdk == 'docker' %}bg-blue-500/20 text-blue-400
+                    {% else %}bg-emerald-500/20 text-emerald-400{% endif %}">
+                    {{ plan.sdk }}
+                </span>
+                <span class="px-3 py-1 rounded-full text-xs font-medium bg-dark-800 text-dark-400">
+                    {{ plan.app_type }}
+                </span>
+                {% if validation.valid %}
+                <span class="px-3 py-1 rounded-full text-xs font-medium bg-emerald-500/20 text-emerald-400 flex items-center gap-1">
+                    <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>
+                    Valid
+                </span>
+                {% else %}
+                <span class="px-3 py-1 rounded-full text-xs font-medium bg-red-500/20 text-red-400 flex items-center gap-1">
+                    <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>
+                    Issues Found
+                </span>
+                {% endif %}
+            </div>
+            <h1 class="text-3xl font-bold gradient-text">{{ plan.title }}</h1>
+            <p class="text-dark-400 mt-1 text-sm">{{ plan.description }}</p>
+        </div>
+        <div class="flex items-center gap-3">
+            <a href="/download/{{ project_id }}" class="flex items-center gap-2 px-5 py-2.5 rounded-xl bg-gradient-to-r from-cyan-500 to-blue-600 hover:from-cyan-400 hover:to-blue-500 text-white font-semibold text-sm transition-all hover:shadow-lg hover:shadow-cyan-500/20">
+                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"/></svg>
+                Download ZIP
+            </a>
+            <a href="/" class="flex items-center gap-2 px-5 py-2.5 rounded-xl glass hover:border-cyan-500/30 text-dark-300 hover:text-cyan-400 font-semibold text-sm transition-all">
+                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/></svg>
+                Generate Another
+            </a>
+        </div>
+    </div>
+    {% if edit_error %}
+    <div class="mb-6 p-4 rounded-xl bg-red-900/30 border border-red-500/30 text-red-300 animate-fade-in">
+        <div class="flex items-center gap-3">
+            <svg class="w-5 h-5 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/></svg>
+            <span>{{ edit_error }}</span>
+        </div>
+    </div>
+    {% endif %}
+    <!-- Validation Warnings/Errors -->
+    {% if validation.warnings or validation.errors %}
+    <div class="mb-6 animate-fade-in">
+        {% for error in validation.errors %}
+        <div class="mb-2 p-3 rounded-lg bg-red-900/20 border border-red-500/20 text-red-300 text-sm flex items-center gap-2">
+            <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>
+            {{ error }}
+        </div>
+        {% endfor %}
+        {% for warning in validation.warnings %}
+        <div class="mb-2 p-3 rounded-lg bg-yellow-900/20 border border-yellow-500/20 text-yellow-300 text-sm flex items-center gap-2">
+            <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.964-.833-2.732 0L4.082 16.5c-.77.833.192 2.5 1.732 2.5z"/></svg>
+            {{ warning }}
+        </div>
+        {% endfor %}
+    </div>
+    {% endif %}
+    <!-- Recommended Models -->
+    {% if plan.recommended_models %}
+    <div class="mb-6 glass rounded-xl p-5 animate-fade-in">
+        <h3 class="text-sm font-semibold text-dark-300 mb-3 flex items-center gap-2">
+            <svg class="w-4 h-4 text-purple-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z"/></svg>
+            Recommended Models
+        </h3>
+        <div class="flex flex-wrap gap-3">
+            {% for model in plan.recommended_models %}
+            <a href="https://huggingface.co/{{ model.id }}" target="_blank" class="flex items-center gap-2 px-3 py-2 rounded-lg glass-light hover:border-purple-500/30 transition-all group">
+                <span class="text-sm font-mono text-purple-400 group-hover:text-purple-300">{{ model.id }}</span>
+                <span class="text-xs text-dark-500">{{ model.size }}</span>
+                {% if model.gpu_recommended %}
+                <span class="text-xs px-1.5 py-0.5 rounded bg-yellow-500/20 text-yellow-400">GPU</span>
+                {% endif %}
+            </a>
+            {% endfor %}
+        </div>
+    </div>
+    {% endif %}
+    <!-- Main Content: File Tree + Code Preview -->
+    <div class="grid grid-cols-1 lg:grid-cols-12 gap-6 animate-slide-up">
+        <!-- File Tree Sidebar -->
+        <div class="lg:col-span-3">
+            <div class="glass rounded-xl overflow-hidden sticky top-20">
+                <div class="px-4 py-3 border-b border-dark-800">
+                    <h3 class="text-sm font-semibold text-dark-300 flex items-center gap-2">
+                        <svg class="w-4 h-4 text-cyan-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z"/></svg>
+                        File Tree
+                    </h3>
+                    <p class="text-xs text-dark-500 mt-1">{{ files|length }} files</p>
+                </div>
+                <div class="p-2 max-h-[60vh] overflow-y-auto" id="fileTree">
+                    {% for item in file_tree %}
+                    {% if item.type == 'dir' %}
+                    <div class="file-tree-item flex items-center gap-2 px-3 py-1.5 rounded-lg" style="padding-left: {{ (item.depth * 16) + 12 }}px;">
+                        <svg class="w-4 h-4 text-cyan-500/60" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z"/></svg>
+                        <span class="text-sm text-dark-400">{{ item.name }}</span>
+                    </div>
+                    {% else %}
+                    <button
+                        type="button"
+                        class="file-tree-item w-full flex items-center gap-2 px-3 py-1.5 rounded-lg cursor-pointer text-left"
+                        style="padding-left: {{ (item.depth * 16) + 12 }}px;"
+                        data-filepath="{{ item.path }}"
+                        onclick="selectFile('{{ item.path }}')"
+                    >
+                        <svg class="w-4 h-4 text-dark-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"/></svg>
+                        <span class="text-sm text-dark-300 truncate">{{ item.name }}</span>
+                    </button>
+                    {% endif %}
+                    {% endfor %}
+                </div>
+            </div>
+        </div>
+        <!-- Code Preview -->
+        <div class="lg:col-span-9">
+            <div class="glass rounded-xl overflow-hidden">
+                <!-- Tab Bar -->
+                <div class="flex items-center justify-between px-4 py-2 border-b border-dark-800 bg-dark-900/50">
+                    <div class="flex items-center gap-2">
+                        <div class="flex items-center gap-1.5">
+                            <div class="w-3 h-3 rounded-full bg-red-500/60"></div>
+                            <div class="w-3 h-3 rounded-full bg-yellow-500/60"></div>
+                            <div class="w-3 h-3 rounded-full bg-green-500/60"></div>
+                        </div>
+                        <span class="text-sm font-mono text-dark-400 ml-3" id="currentFileName">Select a file</span>
+                    </div>
+                    <button onclick="copyCode()" class="text-xs text-dark-500 hover:text-cyan-400 transition-colors flex items-center gap-1 px-2 py-1 rounded hover:bg-dark-800" id="copyBtn">
+                        <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 5H6a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2v-1M8 5a2 2 0 002 2h2a2 2 0 002-2M8 5a2 2 0 012-2h2a2 2 0 012 2m0 0h2a2 2 0 012 2v3m2 4H10m0 0l3-3m-3 3l3 3"/></svg>
+                        Copy
+                    </button>
+                </div>
+                <!-- Code Content -->
+                <div class="overflow-auto max-h-[70vh] p-0" id="codeContainer">
+                    <div class="p-8 text-center text-dark-500" id="codePlaceholder">
+                        <svg class="w-12 h-12 mx-auto mb-3 text-dark-600" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 20l4-16m4 4l4 4-4 4M6 16l-4-4 4-4"/></svg>
+                        <p>Click a file in the tree to view its code</p>
+                    </div>
+                    <pre class="hidden line-numbers" id="codeBlock"><code id="codeContent"></code></pre>
+                </div>
+            </div>
+            <!-- Architecture Diagram -->
+            <div class="glass rounded-xl mt-6 overflow-hidden">
+                <div class="px-4 py-3 border-b border-dark-800 flex items-center justify-between">
+                    <h3 class="text-sm font-semibold text-dark-300 flex items-center gap-2">
+                        <svg class="w-4 h-4 text-purple-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 5a1 1 0 011-1h14a1 1 0 011 1v2a1 1 0 01-1 1H5a1 1 0 01-1-1V5zM4 13a1 1 0 011-1h6a1 1 0 011 1v6a1 1 0 01-1 1H5a1 1 0 01-1-1v-6zM16 13a1 1 0 011-1h2a1 1 0 011 1v6a1 1 0 01-1 1h-2a1 1 0 01-1-1v-6z"/></svg>
+                        Architecture
+                    </h3>
+                    <button onclick="toggleDiagram()" class="text-xs text-dark-500 hover:text-cyan-400 transition-colors" id="diagramToggle">Hide</button>
+                </div>
+                <div id="diagramPanel" class="p-4">
+                    <pre class="text-xs font-mono text-cyan-400/70 overflow-x-auto leading-relaxed">{{ arch_diagram }}</pre>
+                </div>
+            </div>
+            <!-- Edit Section -->
+            <div class="glass rounded-xl mt-6 p-6">
+                <h3 class="text-sm font-semibold text-dark-300 mb-3 flex items-center gap-2">
+                    <svg class="w-4 h-4 text-cyan-400" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"/></svg>
+                    Iterate on Your App
+                </h3>
+                <form action="/edit" method="POST" id="editForm" class="flex gap-3">
+                    <input type="hidden" name="project_id" value="{{ project_id }}">
+                    <input
+                        type="text"
+                        name="edit_prompt"
+                        required
+                        class="flex-1 bg-dark-900/80 border border-dark-700 rounded-lg px-4 py-2.5 text-dark-300 placeholder-dark-600 text-sm focus:border-cyan-500/50 focus:ring-2 focus:ring-cyan-500/20"
+                        placeholder="e.g., Add a dark theme toggle, increase max tokens to 4096, add error messages..."
+                    >
+                    <button type="submit" id="editBtn" class="px-5 py-2.5 rounded-lg bg-gradient-to-r from-purple-500 to-pink-600 hover:from-purple-400 hover:to-pink-500 text-white font-semibold text-sm transition-all flex items-center gap-2">
+                        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/></svg>
+                        <span id="editText">Edit</span>
+                        <div id="editSpinner" class="spinner hidden"></div>
+                    </button>
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+<!-- Hidden data for JS -->
+<script id="fileData" type="application/json">{{ files | tojson }}</script>
+{% endblock %}
+{% block extra_scripts %}
+<script>
+    // Load file data
+    const fileData = JSON.parse(document.getElementById('fileData').textContent);
+    // Auto-select the first file
+    const firstFile = Object.keys(fileData)[0];
+    if (firstFile) {
+        selectFile(firstFile);
+    }
+</script>
+{% endblock %}

app/validators/__init__.py ADDED Viewed

File without changes

app/validators/code_checker.py ADDED Viewed

	@@ -0,0 +1,191 @@

+"""
+Validate generated code for common issues.
+"""
+import ast
+import re
+from typing import Optional
+class CodeChecker:
+    """Validate generated Space code for correctness and common issues."""
+    def check(self, files: dict, sdk: str) -> dict:
+        """
+        Validate all files in the repo.
+        Returns dict with:
+            valid: bool
+            errors: list of error strings
+            warnings: list of warning strings
+            file_checks: dict of filename -> {valid, issues}
+        """
+        errors = []
+        warnings = []
+        file_checks = {}
+        for filename, content in files.items():
+            check = self._check_file(filename, content, sdk)
+            file_checks[filename] = check
+            errors.extend(check.get("errors", []))
+            warnings.extend(check.get("warnings", []))
+        # Cross-file checks
+        cross_issues = self._cross_file_checks(files, sdk)
+        errors.extend(cross_issues.get("errors", []))
+        warnings.extend(cross_issues.get("warnings", []))
+        return {
+            "valid": len(errors) == 0,
+            "errors": errors,
+            "warnings": warnings,
+            "file_checks": file_checks,
+        }
+    def _check_file(self, filename: str, content: str, sdk: str) -> dict:
+        """Check a single file."""
+        errors = []
+        warnings = []
+        if not content or not content.strip():
+            errors.append(f"{filename}: File is empty")
+            return {"valid": False, "errors": errors, "warnings": warnings}
+        if filename.endswith(".py"):
+            py_result = self._check_python(filename, content)
+            errors.extend(py_result["errors"])
+            warnings.extend(py_result["warnings"])
+        elif filename == "Dockerfile":
+            docker_result = self._check_dockerfile(content)
+            errors.extend(docker_result["errors"])
+            warnings.extend(docker_result["warnings"])
+        elif filename == "requirements.txt":
+            req_result = self._check_requirements(content)
+            errors.extend(req_result["errors"])
+            warnings.extend(req_result["warnings"])
+        elif filename == "README.md":
+            if "---" not in content:
+                warnings.append("README.md: Missing YAML frontmatter")
+        elif filename.endswith(".html"):
+            html_result = self._check_html(filename, content)
+            errors.extend(html_result["errors"])
+            warnings.extend(html_result["warnings"])
+        valid = len(errors) == 0
+        return {"valid": valid, "errors": errors, "warnings": warnings}
+    def _check_python(self, filename: str, content: str) -> dict:
+        """Validate Python code syntax and common patterns."""
+        errors = []
+        warnings = []
+        # Syntax check
+        try:
+            ast.parse(content)
+        except SyntaxError as e:
+            errors.append(f"{filename}: Python syntax error at line {e.lineno}: {e.msg}")
+            return {"errors": errors, "warnings": warnings}
+        # Check for common issues
+        if "import " not in content and "from " not in content:
+            warnings.append(f"{filename}: No imports found")
+        # Check for dangerous patterns
+        dangerous_patterns = [
+            (r"os\.system\(", "os.system() call found - potential security risk"),
+            (r"eval\(", "eval() call found - potential security risk"),
+            (r"exec\(", "exec() call found - potential security risk"),
+            (r"__import__\(", "__import__() call found - potential security risk"),
+        ]
+        for pattern, msg in dangerous_patterns:
+            if re.search(pattern, content):
+                warnings.append(f"{filename}: {msg}")
+        # Check for hardcoded tokens/secrets
+        secret_patterns = [
+            (r'(?:token|key|secret|password)\s*=\s*["\'][^"\']{10,}["\']', "Possible hardcoded secret"),
+        ]
+        for pattern, msg in secret_patterns:
+            if re.search(pattern, content, re.IGNORECASE):
+                warnings.append(f"{filename}: {msg}")
+        return {"errors": errors, "warnings": warnings}
+    def _check_dockerfile(self, content: str) -> dict:
+        """Validate Dockerfile content."""
+        errors = []
+        warnings = []
+        if "FROM" not in content:
+            errors.append("Dockerfile: Missing FROM instruction")
+        if "EXPOSE" not in content:
+            warnings.append("Dockerfile: Missing EXPOSE instruction")
+        if "7860" not in content:
+            warnings.append("Dockerfile: Port 7860 not found (required for HF Spaces)")
+        if "CMD" not in content and "ENTRYPOINT" not in content:
+            errors.append("Dockerfile: Missing CMD or ENTRYPOINT")
+        return {"errors": errors, "warnings": warnings}
+    def _check_requirements(self, content: str) -> dict:
+        """Validate requirements.txt."""
+        errors = []
+        warnings = []
+        lines = [l.strip() for l in content.strip().split("\n") if l.strip() and not l.strip().startswith("#")]
+        if not lines:
+            warnings.append("requirements.txt: No dependencies listed")
+        for line in lines:
+            # Basic format check
+            if " " in line and ";" not in line and "#" not in line:
+                warnings.append(f"requirements.txt: Suspicious line: '{line}'")
+        return {"errors": errors, "warnings": warnings}
+    def _check_html(self, filename: str, content: str) -> dict:
+        """Basic HTML validation."""
+        errors = []
+        warnings = []
+        if "<html" not in content.lower() and "<!doctype" not in content.lower():
+            warnings.append(f"{filename}: Missing <html> tag or DOCTYPE")
+        # Check for unclosed tags (very basic)
+        for tag in ["html", "head", "body"]:
+            open_count = len(re.findall(f"<{tag}[\\s>]", content, re.IGNORECASE))
+            close_count = len(re.findall(f"</{tag}>", content, re.IGNORECASE))
+            if open_count > close_count:
+                warnings.append(f"{filename}: Unclosed <{tag}> tag")
+        return {"errors": errors, "warnings": warnings}
+    def _cross_file_checks(self, files: dict, sdk: str) -> dict:
+        """Perform checks across multiple files."""
+        errors = []
+        warnings = []
+        if sdk == "gradio":
+            if "app.py" not in files:
+                errors.append("Missing app.py (required for Gradio Spaces)")
+            if "requirements.txt" not in files:
+                warnings.append("Missing requirements.txt")
+            if "README.md" not in files:
+                warnings.append("Missing README.md")
+            # Check that requirements includes gradio
+            req = files.get("requirements.txt", "")
+            if "gradio" not in req.lower():
+                warnings.append("requirements.txt: 'gradio' not listed as dependency")
+        elif sdk == "docker":
+            if "Dockerfile" not in files:
+                errors.append("Missing Dockerfile (required for Docker Spaces)")
+            if "README.md" not in files:
+                warnings.append("Missing README.md")
+        elif sdk == "static":
+            if "index.html" not in files:
+                errors.append("Missing index.html (required for Static Spaces)")
+        return {"errors": errors, "warnings": warnings}

requirements.txt ADDED Viewed

	@@ -0,0 +1,6 @@

+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+jinja2==3.1.5
+python-multipart==0.0.20
+huggingface-hub==0.27.1
+aiofiles==24.1.0