Update app.py

app.py

@@ -1,212 +1,202 @@
+# app.py
+# ---------------------------------------------------------------------
+# AnyCoder / Shasha AI  –  Gradio front‑end (no external static files)
+# ---------------------------------------------------------------------
 """
-Main application file for SHASHA AI, a Gradio-based AI code generation tool.
-
-Provides a UI for generating code in many languages using various AI models.
-Supports text prompts, file uploads, website scraping, optional web search,
-and live previews of HTML output.
+Interactive UI for generating / modifying / previewing code with multiple
+LLM back‑ends.  Relies on:
+
+ • models.py       – AVAILABLE_MODELS registry + find_model()
+ • inference.py    – chat_completion()  (provider routing handled there)
+ • utils.py        – file / website extractors, history helpers, etc.
+ • tavily_search.py (optional) – enhance_query_with_search()
+ • deploy.py       – send_to_sandbox() for live HTML preview
 """
 
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Tuple, Dict, Any, Optional
+
 import gradio as gr
-from typing import Optional, Dict, List, Tuple, Any
-
-# --- Local module imports ---
-from constants import (
-    HTML_SYSTEM_PROMPT,
-    TRANSFORMERS_JS_SYSTEM_PROMPT,
-    AVAILABLE_MODELS,
-    DEMO_LIST,
-)
-from hf_client import get_inference_client
-from tavily_search import enhance_query_with_search
-from utils import (
+
+# ---------- local helpers --------------------------------------------------
+from models          import AVAILABLE_MODELS, find_model, ModelInfo
+from inference       import chat_completion
+from tavily_search   import enhance_query_with_search
+from utils           import (
     extract_text_from_file,
     extract_website_content,
-    apply_search_replace_changes,
     history_to_messages,
     history_to_chatbot_messages,
+    apply_search_replace_changes,
     remove_code_block,
     parse_transformers_js_output,
     format_transformers_js_output,
 )
-from deploy import send_to_sandbox, load_project_from_url
-
-# --- Type aliases ---
-History = List[Tuple[str, str]]
-Model = Dict[str, Any]
-
-# --- Supported languages for dropdown ---
+from deploy          import send_to_sandbox
+
+# ---------- constants ------------------------------------------------------
+SYSTEM_PROMPTS = {
+    "html": (
+        "ONLY USE HTML, CSS AND JAVASCRIPT.  Produce ONE complete html file "
+        "wrapped in ```html … ```."
+    ),
+    "transformers.js": (
+        "Generate THREE fenced blocks: index.html, index.js, style.css "
+        "for a transformers.js demo."
+    ),
+}
 SUPPORTED_LANGUAGES = [
     "python", "c", "cpp", "markdown", "latex", "json", "html", "css",
     "javascript", "jinja2", "typescript", "yaml", "dockerfile", "shell",
     "r", "sql", "sql-msSQL", "sql-mySQL", "sql-mariaDB", "sql-sqlite",
     "sql-cassandra", "sql-plSQL", "sql-hive", "sql-pgSQL", "sql-gql",
-    "sql-gpSQL", "sql-sparkSQL", "sql-esper"
+    "sql-gpSQL", "sql-sparkSQL", "sql-esper",
 ]
+History = List[Tuple[str, str]]  # [(prompt, code/result)]
 
-def get_model_details(name: str) -> Optional[Model]:
-    for m in AVAILABLE_MODELS:
-        if m["name"] == name:
-            return m
-    return None
-
-def generation_code(
-    query: Optional[str],
-    file: Optional[str],
-    website_url: Optional[str],
-    current_model: Model,
-    enable_search: bool,
+
+# ---------- core generation callback --------------------------------------
+def generate(
+    prompt: str,
+    file_path: str | None,
+    website_url: str | None,
+    model_name: str,
     language: str,
-    history: Optional[History],
+    use_search: bool,
+    hist: History | None,
 ) -> Tuple[str, History, str, List[Dict[str, str]]]:
-    query = query or ""
-    history = history or []
+    """Main callback wired to the “Generate Code” button."""
+    hist = hist or []
+    user_prompt = (prompt or "").strip()
+
+    # 1 · system + previous messages
+    sys = SYSTEM_PROMPTS.get(language, f"You are an expert {language} developer.")
+    messages = history_to_messages(hist, sys)
+
+    # 2 · gather extra context
+    ctx_parts: list[str] = [user_prompt]
+
+    if file_path:
+        ctx_parts.append("[Reference file]")
+        ctx_parts.append(extract_text_from_file(file_path)[:5000])
+
+    if website_url:
+        html = extract_website_content(website_url)
+        if not html.lower().startswith("error"):
+            ctx_parts.append("[Website content]")
+            ctx_parts.append(html[:8000])
+
+    user_query = "\n\n".join(filter(None, ctx_parts))
+    user_query = enhance_query_with_search(user_query, use_search)
+    messages.append({"role": "user", "content": user_query})
+
+    # 3 · call the model
+    model: ModelInfo = find_model(model_name) or AVAILABLE_MODELS[0]
     try:
-        # Choose system prompt based on language
-        if language == "html":
-            system_prompt = HTML_SYSTEM_PROMPT
-        elif language == "transformers.js":
-            system_prompt = TRANSFORMERS_JS_SYSTEM_PROMPT
-        else:
-            # Generic fallback prompt
-            system_prompt = (
-                f"You are an expert {language} developer. "
-                f"Write clean, idiomatic {language} code based on the user's request."
-            )
+        assistant = chat_completion(model.id, messages)
+    except Exception as exc:
+        err = f"❌ **Error**\n```{exc}```"
+        hist.append((user_prompt, err))
+        return "", hist, "", history_to_chatbot_messages(hist)
 
-        model_id = current_model["id"]
-        # Determine provider
-        if model_id.startswith("openai/") or model_id in {"gpt-4", "gpt-3.5-turbo"}:
-            provider = "openai"
-        elif model_id.startswith("gemini/") or model_id.startswith("google/"):
-            provider = "gemini"
-        elif model_id.startswith("fireworks-ai/"):
-            provider = "fireworks-ai"
-        else:
-            provider = "auto"
-
-        # Build message history
-        msgs = history_to_messages(history, system_prompt)
-        context = query
-        if file:
-            ftext = extract_text_from_file(file)
-            context += f"\n\n[Attached file]\n{ftext[:5000]}"
-        if website_url:
-            wtext = extract_website_content(website_url)
-            if not wtext.startswith("Error"):
-                context += f"\n\n[Website content]\n{wtext[:8000]}"
-        final_q = enhance_query_with_search(context, enable_search)
-        msgs.append({"role": "user", "content": final_q})
-
-        # Call the model
-        client = get_inference_client(model_id, provider)
-        resp = client.chat.completions.create(
-            model=model_id,
-            messages=msgs,
-            max_tokens=16000,
-            temperature=0.1
-        )
-        content = resp.choices[0].message.content
-
-    except Exception as e:
-        err = f"❌ **Error:**\n```\n{e}\n```"
-        history.append((query, err))
-        return "", history, "", history_to_chatbot_messages(history)
-
-    # Process model output
+    # 4 · post‑process
     if language == "transformers.js":
-        files = parse_transformers_js_output(content)
+        files = parse_transformers_js_output(assistant)
         code = format_transformers_js_output(files)
         preview = send_to_sandbox(files.get("index.html", ""))
     else:
-        cleaned = remove_code_block(content)
-        if history and history[-1][1] and not history[-1][1].startswith("❌"):
-            code = apply_search_replace_changes(history[-1][1], cleaned)
-        else:
-            code = cleaned
+        cleaned = remove_code_block(assistant)
+        if hist and not hist[-1][1].startswith("❌"):
+            cleaned = apply_search_replace_changes(hist[-1][1], cleaned)
+        code = cleaned
         preview = send_to_sandbox(code) if language == "html" else ""
 
-    new_hist = history + [(query, code)]
-    chat = history_to_chatbot_messages(new_hist)
-    return code, new_hist, preview, chat
-
-# --- Custom CSS ---
-CUSTOM_CSS = """
-body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; }
-#main_title { text-align: center; font-size: 2.5rem; margin-top: 1.5rem; }
-#subtitle { text-align: center; color: #4a5568; margin-bottom: 2.5rem; }
-.gradio-container { background-color: #f7fafc; }
-#gen_btn { box-shadow: 0 4px 6px rgba(0,0,0,0.1); }
+    # 5 · update history & chat
+    hist.append((user_prompt, code))
+    chat_messages = history_to_chatbot_messages(hist)
+    return code, hist, preview, chat_messages
+
+
+# ---------- UI (Gradio 5) --------------------------------------------------
+THEME = gr.themes.Soft(primary_hue="indigo")
+CSS = """
+.gradio-container {max-width: 1450px !important;}
+@media (min-width: 960px){
+  .layout {display:flex; gap:32px}
+  .inputs  {flex:1 0 360px}
+  .outputs {flex:2 0 0}
+}
 """
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="Shasha AI") as demo:
-    history_state = gr.State([])
-    initial_model = AVAILABLE_MODELS[0]
-    model_state = gr.State(initial_model)
+with gr.Blocks(title="AnyCoder AI", theme=THEME, css=CSS) as demo:
+    state_hist: gr.State = gr.State([])
 
-    gr.Markdown("# 🚀 Shasha AI", elem_id="main_title")
-    gr.Markdown("Your AI partner for generating, modifying, and understanding code.", elem_id="subtitle")
+    # ---- header ----------------------------------------------------------
+    gr.Markdown(
+        "## 🚀 **AnyCoder AI**  \n"
+        "Your AI partner for generating, modifying & understanding code."
+    )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 1. Select Model")
+    with gr.Row(elem_classes="layout"):
+        # -------- left column (inputs) ------------------------------------
+        with gr.Column(elem_classes="inputs"):
+            gr.Markdown("### 1 · Model")
             model_dd = gr.Dropdown(
-                choices=[m["name"] for m in AVAILABLE_MODELS],
-                value=initial_model["name"],
-                label="AI Model"
+                choices=[m.name for m in AVAILABLE_MODELS],
+                value=AVAILABLE_MODELS[0].name,
+                label="AI Model",
             )
 
-            gr.Markdown("### 2. Provide Context")
+            gr.Markdown("### 2 · Context")
             with gr.Tabs():
-                with gr.Tab("📝 Prompt"):
-                    prompt_in = gr.Textbox(lines=7, placeholder="Describe your request...", show_label=False)
-                with gr.Tab("📄 File"):
-                    file_in = gr.File(type="filepath")
-                with gr.Tab("🌐 Website"):
-                    url_in = gr.Textbox(placeholder="https://example.com")
+                with gr.Tab("Prompt"):
+                    prompt_box = gr.Textbox(lines=6, placeholder="Describe what you need…")
+                with gr.Tab("File"):
+                    file_box = gr.File(type="filepath")
+                with gr.Tab("Website"):
+                    url_box = gr.Textbox(placeholder="https://example.com")
 
-            gr.Markdown("### 3. Configure Output")
-            lang_dd = gr.Dropdown(SUPPORTED_LANGUAGES, value="html", label="Target Language")
-            search_chk = gr.Checkbox(label="Enable Web Search")
+            gr.Markdown("### 3 · Output")
+            lang_dd = gr.Dropdown(SUPPORTED_LANGUAGES, value="html", label="Target Language")
+            search_chk = gr.Checkbox(label="Enable Tavily Web Search")
 
             with gr.Row():
-                clr_btn = gr.Button("Clear Session", variant="secondary")
-                gen_btn = gr.Button("Generate Code", variant="primary", elem_id="gen_btn")
-
-            # --- Hugging Face Integration ---
-            gr.Markdown("---")
-            gr.Markdown("#### Hugging Face Integration")
-            hf_url = gr.Textbox(label="Load HF Space URL")
-            hf_load_btn = gr.Button("Import Project")
-            hf_status = gr.Markdown(visible=False)
-
-            hf_load_btn.click(
-                fn=lambda u: load_project_from_url(u),
-                inputs=hf_url,
-                outputs=[hf_status, code_out, preview_out, hf_url, history_state, chat_out]
-            )
+                clear_btn = gr.Button("Clear Session", variant="secondary")
+                gen_btn   = gr.Button("Generate Code", variant="primary")
 
-        with gr.Column(scale=2):
+        # -------- right column (outputs) ----------------------------------
+        with gr.Column(elem_classes="outputs"):
             with gr.Tabs():
-                with gr.Tab("💻 Code"):
-                    code_out = gr.Code(language="html", interactive=True)
-                with gr.Tab("👁️ Live Preview"):
+                with gr.Tab("Code"):
+                    code_out = gr.Code(height=500, language="html")
+                with gr.Tab("Live Preview"):
                     preview_out = gr.HTML()
-                with gr.Tab("📜 History"):
+                with gr.Tab("History"):
                     chat_out = gr.Chatbot(type="messages")
 
-    model_dd.change(lambda n: get_model_details(n) or initial_model, inputs=[model_dd], outputs=[model_state])
-
+    # ---- callbacks -------------------------------------------------------
     gen_btn.click(
-        fn=generation_code,
-        inputs=[prompt_in, file_in, url_in, model_state, search_chk, lang_dd, history_state],
-        outputs=[code_out, history_state, preview_out, chat_out],
+        generate,
+        inputs=[
+            prompt_box, file_box, url_box,
+            model_dd, lang_dd, search_chk, state_hist
+        ],
+        outputs=[code_out, state_hist, preview_out, chat_out],
     )
 
-    clr_btn.click(
-        lambda: ("", None, "", [], "", "", []),
-        outputs=[prompt_in, file_in, url_in, history_state, code_out, preview_out, chat_out],
+    clear_btn.click(
+        lambda: ("", None, "", "html", False, [], [], "", []),
+        outputs=[
+            prompt_box, file_box, url_box,
+            lang_dd, search_chk, state_hist,
+            code_out, preview_out, chat_out,
+        ],
         queue=False,
     )
 
+
+# ---------- launch ---------------------------------------------------------
 if __name__ == "__main__":
     demo.queue().launch()