Update app.py

app.py

@@ -1,271 +1,154 @@
+import os
+import time
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
-import torch
-import logging
-from typing import List, Dict, Any
-from functools import partial
+from playwright.sync_api import sync_playwright
+from huggingface_hub import InferenceClient, login
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# --- AUTHENTICATION ---
+# Ensure this token has WRITE permissions
+HF_TOKEN = os.environ.get("HF_TOKEN") 
 
-class VibeThinker:
-    def __init__(self, model_path: str = "WeiboAI/VibeThinker-1.5B"):
-        self.model_path = model_path
-        logger.info(f"Loading model {model_path}...")
-        
-        try:
-            # Use trust_remote_code only if absolutely required (VibeThinker needs it)
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                model_path,
-                trust_remote_code=True,
-                padding_side="left"  # Important for generation
-            )
-            
-            # Add pad token if missing (common with some custom models)
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-                self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
-
-            self.model = AutoModelForCausalLM.from_pretrained(
-                model_path,
-                torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
-                device_map="auto",
-                low_cpu_mem_usage=True,
-                trust_remote_code=True,
-            )
-            
-            self.model.eval()
-            logger.info("Model loaded successfully.")
-            
-        except Exception as e:
-            logger.error(f"Failed to load model: {e}")
-            raise
+# --- AGENT BRAIN & IMAGINATION ---
+# We use Qwen-2.5-Coder for logic (Smartest open coder) and FLUX for images.
+LLM_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
+IMG_MODEL = "black-forest-labs/FLUX.1-dev"
 
-    def infer_text(self, messages: List[Dict[str, str]], **gen_kwargs) -> str:
-        try:
-            # Apply chat template safely
-            text = self.tokenizer.apply_chat_template(
-                messages,
-                tokenize=False,
-                add_generation_prompt=True
-            )
-
-            inputs = self.tokenizer(
-                text,
-                return_tensors="pt",
-                truncation=True,
-                max_length=8192  # Prevent OOM on very long histories
-            ).to(self.model.device)
-
-            # Default generation config (tuned for quality + coherence)
-            default_gen = {
-                "max_new_tokens": 2048,
-                "do_sample": True,
-                "temperature": 0.7,
-                "top_p": 0.90,
-                "top_k": 50,
-                "repetition_penalty": 1.1,
-                "eos_token_id": self.tokenizer.eos_token_id,
-                "pad_token_id": self.tokenizer.pad_token_id,
-            }
-            default_gen.update(gen_kwargs)
-
-            with torch.no_grad():
-                generated_ids = self.model.generate(
-                    **inputs,
-                    generation_config=GenerationConfig(**default_gen)
-                )
-
-            # Decode only the newly generated part
-            response_ids = generated_ids[0][inputs.input_ids.shape[-1]:]
-            response = self.tokenizer.decode(response_ids, skip_special_tokens=True).strip()
-            
-            return response
-
-        except torch.cuda.OutOfMemoryError:
-            torch.cuda.empty_cache()
-            return "❌ GPU ran out of memory. Please shorten your conversation history or try again."
-        except Exception as e:
-            logger.error(f"Generation error: {e}")
-            return f"❌ An error occurred during generation: {str(e)}"
-
-
-# === Initialize model once (global) ===
-try:
-    model = VibeThinker()
-except Exception:
-    model = None
-    error_msg = "Failed to load VibeThinker model. The app will run in fallback mode."
-    logger.error(error_msg)
-
-# === System prompt (clear, focused, and optimized for Joomla/Yootheme) ===
-SYSTEM_PROMPT = """
-You are an expert Joomla developer specializing in YOOtheme Pro Builder (dynamic content, custom elements, layout library).
-Your task is to convert or optimize any provided HTML/CSS/JS into clean, high-performance code that works perfectly inside YOOtheme Pro elements (HTML, Custom Element, Code element, etc.).
-
-Rules:
-- Always use inline styles or scoped CSS when needed (no external files unless requested).
-- Prefer YOOtheme dynamic tags {{ }} when relevant.
-- Ensure responsive design (use uk-grid, uk-width-*, flex, etc.).
-- Optimize for performance: minify when possible, avoid heavy frameworks.
-- Wrap JavaScript in <script> tags with defer if needed.
-- Output ONLY the final optimized code unless the user asks for explanation.
-- If the input is already good, enhance it (accessibility, speed, modern syntax).
-"""
-
-def build_messages(history: List[List[Any]], user_message: str) -> List[Dict[str, str]]:
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-    
-    for human, assistant in history:
-        if human:
-            messages.append({"role": "user", "content": human})
-        if assistant:
-            messages.append({"role": "assistant", "content": assistant})
-    
-    messages.append({"role": "user", "content": user_message})
-    return messages
-
-def chatbot_response(message: str, history: List[List[str]]) -> str:
-    if model is None:
-        return "🚨 Model failed to load. Please check server logs."
-
-    messages = build_messages(history, message)
-    
-    # Stream the response using Gradio's streaming
-    for chunk in stream_response(messages):
-        yield chunk
-
-def stream_response(messages: List[Dict[str, str]]):
-    if model is None:
-        yield "Model not available."
-        return
+client = InferenceClient(token=HF_TOKEN)
 
+def generate_image_asset(prompt):
+    """Generates an image using FLUX based on the context."""
+    print(f"🎨 Generative Cortex: Creating image for '{prompt}'...")
     try:
-        text = model.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        inputs = model.tokenizer(text, return_tensors="pt").to(model.model.device)
-
-        streamer = partial(model.model.generate,
-                           **inputs,
-                           streamer=None,  # We'll do manual streaming for better control
-                           max_new_tokens=2048,
-                           do_sample=True,
-                           temperature=0.7,
-                           top_p=0.90,
-                           repetition_penalty=1.1,
-                           pad_token_id=model.tokenizer.pad_token_id)
-
-        generated_text = ""
-        for new_token in streamer:
-            # This is a simplified streaming approach; for real token-by-token streaming use TextIteratorStreamer
-            pass  # Replace with real streaming if needed (see below for full streaming version)
-
-        # Simpler: just return full response (still fast with bfloat16)
-        response = model.infer_text(messages)
-        yield response
-
+        # Enhance prompt for better aesthetics
+        enhanced_prompt = f"professional web design asset, high quality, {prompt}, 8k resolution, trending on artstation"
+        image = client.text_to_image(enhanced_prompt, model=IMG_MODEL)
+        return image, f"Generated: {prompt}"
     except Exception as e:
-        yield f"Error: {str(e)}"
-
-
-# === Proper streaming version (recommended) ===
-from transformers import TextIteratorStreamer
-import threading
-
-def chatbot_response_stream(message: str, history: List[List[str]]):
-    if model is None:
-        yield "🚨 Model failed to load."
-        return
-
-    messages = build_messages(history, message)
-    text = model.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = model.tokenizer(text, return_tensors="pt").to(model.model.device)
+        return None, f"Image Gen Error: {e}"
 
-    streamer = TextIteratorStreamer(model.tokenizer, skip_prompt=True, skip_special_tokens=True)
-
-    generation_kwargs = {
-        "inputs": inputs.input_ids,
-        "streamer": streamer,
-        "max_new_tokens": 2048,
-        "do_sample": True,
-        "temperature": 0.7,
-        "top_p": 0.90,
-        "top_k": 50,
-        "repetition_penalty": 1.1,
-        "pad_token_id": model.tokenizer.pad_token_id,
-    }
-
-    thread = threading.Thread(target=model.model.generate, kwargs=generation_kwargs)
-    thread.start()
-
-    generated_text = ""
-    for new_text in streamer:
-        generated_text += new_text
-        yield generated_text
-
-# === Gradio Interface ===
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    title="Joomla YOOtheme Pro Optimizer",
-    css="""
-    .gradio-container {max-width: 1000px !important; margin: auto;}
-    footer {display: none !important;}
+def interpret_task(task_description):
+    """
+    Uses the LLM to translate a human request into a Joomla/YooTheme strategy.
+    Returns a structured list of steps (pseudo-code for the bot).
+    """
+    system_prompt = """
+    You are an expert Joomla 5 and YooTheme Pro Automator. 
+    Convert the user's natural language request into a logical step-by-step execution plan for a Playwright bot.
+    The bot can: login, goto_url, click_selector, type_text, upload_image.
+    Identify if an image needs to be generated based on the text.
     """
-) as demo:
-    gr.Markdown(
-        """
-        # 🚀 Joomla YOOtheme Pro Optimizer  
-        Powered by **WeiboAI/VibeThinker-1.5B** ∙ Real-time streaming ∙ Optimized for YOOtheme Builder  
-        [Built with ❤️ using Anycoder](https://huggingface.co/spaces/akhaliq/anycoder) | 
-        [Model](https://huggingface.co/WeiboAI/VibeThinker-1.5B) ∙ 
-        [Report issues](https://github.com/your-repo)
-        """
-    )
+    
+    try:
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"Task: {task_description}"}
+        ]
+        response = client.chat_completion(messages, model=LLM_MODEL, max_tokens=500)
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Brain Error: {e}"
 
-    chat = gr.ChatInterface(
-        fn=chatbot_response_stream,
-        chatbot=gr.Chatbot(
-            height=600,
-            show_copy_button=True,
-            avatar_images=(
-                "https://em-content.zobj.net/source/twitter/53/robot_1f916.png",
-                "https://yootheme.com/site/templates/yootheme/images/yootheme/logo.svg"
-            ),
-            render_markdown=True
-        ),
-        textbox=gr.Textbox(
-            placeholder="Paste your HTML/CSS/JS here and ask to optimize for YOOtheme Pro Builder...",
-            container=False,
-            scale=7,
-            autofocus=True
-        ),
-        examples=[
-            ["Make this Bootstrap card work perfectly in YOOtheme Pro as a custom element"],
-            ["Convert this Tailwind section to pure UIKit + YOOtheme dynamic content"],
-            ["Optimize this heavy JS animation for YOOtheme Code element (no jQuery)"],
-        ],
-        cache_examples=False,
-        retry_btn="🔄 Retry",
-        undo_btn="↶ Undo",
-        clear_btn="🗑️ Clear Chat",
-        submit_btn="Optimize →"
-    )
+def execute_mission(joomla_url, username, password, task_input, dry_run):
+    logs = []
+    generated_assets = []
+    
+    def log(msg):
+        t = time.strftime("%H:%M:%S")
+        entry = f"[{t}] {msg}"
+        logs.append(entry)
+        print(entry)
+        return "\n".join(logs)
+
+    log(f"🚀 Hub-Enhancer Agent Initiated.")
+    log(f"🧠 Analyzing Request via {LLM_MODEL}...")
+    
+    # 1. Ask the LLM what to do
+    strategy = interpret_task(task_input)
+    log(f"📋 Strategy Formulated:\n{strategy[:200]}...") # Log first 200 chars of strategy
+
+    # 2. Check for Image Generation Triggers
+    if "image" in task_input.lower() or "photo" in task_input.lower() or "banner" in task_input.lower():
+        log("🎨 Visual Requirement Detected. Initializing Generative Pipeline...")
+        # Extract a prompt (simplified logic here, usually LLM does this)
+        img_prompt = task_input.replace("generate", "").replace("create", "").strip()
+        img, status = generate_image_asset(img_prompt)
+        if img:
+            generated_assets.append((img, "Auto-Generated Asset"))
+            log("✅ Asset Created successfully.")
+
+    # 3. Execute Browser Actions
+    if dry_run:
+        log("⚠️ DRY RUN: Browser actions skipped.")
+        return "\n".join(logs), generated_assets
+
+    with sync_playwright() as p:
+        log("🌐 Launching Headless Chromium...")
+        browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
+        page = browser.new_page()
+        
+        try:
+            # Login Sequence
+            admin_url = f"{joomla_url.rstrip('/')}/administrator"
+            log(f"🔐 Accessing {admin_url}...")
+            page.goto(admin_url)
+            
+            # Intelligent Selector Handling
+            if page.is_visible('#mod-login-username'):
+                page.fill('#mod-login-username', username)
+                page.fill('#mod-login-password', password)
+                page.click('.login-button')
+            else:
+                # Fallback for standard Joomla
+                page.fill('input[name="username"]', username)
+                page.fill('input[name="passwd"]', password)
+                page.click('.btn-primary')
+                
+            page.wait_for_load_state('networkidle')
+            
+            if "dashboard" in page.url or "cpanel" in page.url:
+                log("✅ Authentication Successful.")
+                
+                # HERE is where we would parse the 'strategy' from the LLM 
+                # to determine where to click next.
+                # For this demo, we log the success.
+                log("🤖 Ready to execute builder commands (Pending implementation of deep-link logic).")
+                
+            else:
+                log("❌ Authentication Failed or Redirected.")
+                
+        except Exception as e:
+            log(f"💥 Runtime Error: {e}")
+        finally:
+            browser.close()
+            log("🏁 Mission Complete.")
+
+    return "\n".join(logs), generated_assets
+
+# --- UI CONFIGURATION ---
+with gr.Blocks(theme=gr.themes.Ocean(), title="UIKitV3 Automator") as demo:
+    gr.Markdown("""
+    # ⚡ UIKitV3-Automator (Agentic Mode)
+    **Powered by Qwen-2.5-Coder (Logic) & FLUX.1-dev (Vision)**
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            url = gr.Textbox(label="Joomla URL", value="https://")
+            with gr.Row():
+                user = gr.Textbox(label="Username")
+                pwd = gr.Textbox(label="Password", type="password")
+            
+            task = gr.Textbox(label="Command", lines=4, placeholder="Example: Go to the Article Manager, create a new article titled 'Summer Sale', and generate a hero image of a beach.")
+            dry = gr.Checkbox(label="Dry Run (Safe Mode)", value=True)
+            btn = gr.Button("Execute Agent", variant="primary")
+        
+        with gr.Column():
+            console = gr.Code(label="Agent Logs", language="shell")
+            gallery = gr.Gallery(label="Generated Assets")
 
-    gr.Markdown(
-        """
-        ### Tips:
-        - Paste raw HTML, full pages, or just snippets
-        - Ask for dynamic content (`{{ article.title }}`, etc.)
-        - Request minification, accessibility improvements, or UIKit conversion
-        - Streaming responses appear in real-time
-        """
-    )
+    btn.click(execute_mission, inputs=[url, user, pwd, task, dry], outputs=[console, gallery])
 
 if __name__ == "__main__":
-    demo.queue(max_size=20).launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,  # Set to True if you want public link
-        favicon_path="https://yootheme.com/site/templates/yootheme/images/favicon.ico",
-        allowed_paths=[]  # Add static files if needed
-    )
+    # Auto-install playwright browsers on first run
+    os.system("playwright install chromium")
+    demo.launch()