Update app.py

app.py

@@ -1,546 +1,456 @@
+import warnings
+warnings.filterwarnings("ignore", category=FutureWarning, message=".*torch.distributed.reduce_op.*")
 import gradio as gr
-import os
+import torch
+import time
 import sys
 import subprocess
+import os
+import pty
+import select
+import signal
+import fcntl
+import struct
+import termios
 import threading
-import time
-import ast
 import re
-import signal
-import shutil
+import ast
+import json
 import tempfile
-import atexit
-from PIL import Image
+from pathlib import Path
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, GenerationConfig
+from typing import List, Dict
+from functools import lru_cache
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+MODEL_NAME = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+DEVICE = "cpu"
+DTYPE = torch.float32
+DISPLAY_NUM = ":99"
+SCREEN_W, SCREEN_H = 800, 600
+SNIPPETS_FILE = "/tmp/axon_snippets.json"
 
 # ═══════════════════════════════════════
-# 1. HELPER CLASSES
+# Virtual Display
 # ═══════════════════════════════════════
-
-class VirtualDisplayManager:
-    """Manages a virtual display (Xvfb) for capturing GUI output."""
+class VirtualDisplay:
     def __init__(self):
-        self.display = None
-        self.is_active = False
-        self.check_xvfb()
-
-    def check_xvfb(self):
-        # Check if Xvfb is installed (Linux only)
-        self.has_xvfb = shutil.which('Xvfb') is not None
-
-    def start(self):
-        if not self.has_xvfb:
-            print("Xvfb not found. Virtual display disabled.")
-            return
-        try:
-            from pyvirtualdisplay import Display
-            self.display = Display(visible=0, size=(1280, 720))
-            self.display.start()
-            os.environ["DISPLAY"] = f":{self.display.display}"
-            self.is_active = True
-            print(f"Virtual Display started on {os.environ['DISPLAY']}")
-        except Exception as e:
-            print(f"Failed to start virtual display: {e}")
+        self.xvfb_proc = None
+        self.display = DISPLAY_NUM
+        self._start_xvfb()
 
-    def capture(self):
-        if not self.is_active:
-            return None
+    def _start_xvfb(self):
         try:
-            # Capture screenshot of the virtual display
-            # Using xwd and converting to png is standard, but let's try PIL grab if possible
-            # or a simple screenshot tool if installed.
-            # Fallback: ImageGrab works on Linux if DISPLAY is set correctly and dependencies exist.
-            from PIL import ImageGrab
-            img = ImageGrab.grab()
-            
-            # Save to a temporary path for Gradio to display
-            fd, path = tempfile.mkstemp(suffix=".png")
-            os.close(fd)
-            img.save(path)
-            return path
-        except Exception as e:
-            print(f"Capture failed: {e}")
-            return None
-
-    def cleanup(self):
-        if self.display:
-            self.display.stop()
-
-class FileSystem:
-    """Manages file operations."""
-    def __init__(self, root="."):
-        self.root = os.path.abspath(root)
-        self.current_file = None
-        self.files = []
-        self.refresh()
-
-    def refresh(self):
-        # List only .py files for simplicity, or all text files
-        self.files = [f for f in os.listdir(self.root) if f.endswith('.py') or f.endswith('.txt') or f.endswith('.md')]
-        self.files.sort()
-        if not self.current_file and self.files:
-            self.current_file = self.files[0]
-        return self.files
-
-    def get_all_files(self):
-        self.refresh()
-        return self.files
-
-    def set_current_file(self, filename):
-        if filename in self.files:
-            self.current_file = filename
-
-    def get_current_file_content(self):
-        if not self.current_file: return ""
-        try:
-            with open(os.path.join(self.root, self.current_file), 'r', encoding='utf-8') as f:
-                return f.read()
-        except:
-            return "Error reading file."
-
-    def save_file(self, content):
-        if not self.current_file: return
-        with open(os.path.join(self.root, self.current_file), 'w', encoding='utf-8') as f:
-            f.write(content)
-
-    def create_file(self, name):
-        if not name: return
-        path = os.path.join(self.root, name)
-        if not os.path.exists(path):
-            with open(path, 'w') as f:
-                f.write("# New file\n")
-            self.refresh()
-            self.current_file = name
-
-    def delete_file(self, name):
-        path = os.path.join(self.root, name)
-        if os.path.exists(path):
-            os.remove(path)
-            self.current_file = None
-            self.refresh()
-            return True
-        return False
-
-class TerminalManager:
-    """Manages running shell commands."""
-    def __init__(self):
-        self.history = []
-        
-    def run_command(self, command):
-        if not command.strip(): return "No command"
-        
-        try:
-            # Capture output
-            result = subprocess.run(
-                command, 
-                shell=True, 
-                cwd=os.getcwd(),
-                stdout=subprocess.PIPE, 
-                stderr=subprocess.PIPE,
-                text=True,
-                timeout=10
+            subprocess.run(["pkill", "-f", f"Xvfb {self.display}"], capture_output=True, timeout=5)
+            time.sleep(0.2)
+            self.xvfb_proc = subprocess.Popen(
+                ["Xvfb", self.display, "-screen", "0", f"{SCREEN_W}x{SCREEN_H}x24", "-ac", "-nolisten", "tcp"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
             )
-            output = f"$ {command}\n{result.stdout}\n{result.stderr}"
+            time.sleep(0.5)
+            if self.xvfb_proc.poll() is None:
+                print(f"[Xvfb] Running on {self.display}")
+                os.environ["DISPLAY"] = self.display
+            else:
+                self.xvfb_proc = None
         except Exception as e:
-            output = f"$ {command}\nError: {str(e)}"
-            
-        self.history.append(command)
-        return output
+            print(f"[Xvfb] {e}"); self.xvfb_proc = None
 
-    def get_history_choices(self):
-        return list(set(self.history)) # Unique history
+    def capture(self):
+        if not self.is_running: return None
+        tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False); tmp.close()
+        # Try multiple capture methods
+        cmds = [
+            ["scrot", "--display", self.display, tmp.name],
+            f"import -window root -display {self.display} {tmp.name}"
+        ]
+        for cmd in cmds:
+            try:
+                kw = {"shell": True} if isinstance(cmd, str) else {}
+                r = subprocess.run(cmd, capture_output=True, timeout=2, env={**os.environ, "DISPLAY": self.display}, **kw)
+                if r.returncode == 0 and os.path.exists(tmp.name) and os.path.getsize(tmp.name) > 100:
+                    return tmp.name
+            except: pass
+        return None
+
+    @property
+    def is_running(self): return self.xvfb_proc is not None and self.xvfb_proc.poll() is None
     
     def cleanup(self):
-        pass
+        if self.xvfb_proc:
+            self.xvfb_proc.terminate()
+            try: self.xvfb_proc.wait(timeout=3)
+            except: self.xvfb_proc.kill()
 
-class GUIManager:
-    """Manages running the user's Python script as a subprocess."""
+vdisplay = VirtualDisplay()
+
+# ═══════════════════════════════════════
+# GUI Process Manager
+# ═══════════════════════════════════════
+class GUIProcessManager:
     def __init__(self):
         self.process = None
-
+    
     def launch(self, code):
-        self.stop() # Stop any existing process
-        
-        # Write code to a temp file to run it
-        fd, path = tempfile.mkstemp(suffix=".py")
-        with os.fdopen(fd, 'w') as f:
-            f.write(code)
-            
+        self.stop()
+        tmp = "/tmp/_axon_gui_run.py"
+        with open(tmp, "w") as f: f.write(code)
+        env = os.environ.copy()
+        env.update({"DISPLAY": DISPLAY_NUM, "SDL_VIDEODRIVER": "x11"})
         try:
-            # Run asynchronously
-            self.process = subprocess.Popen(
-                [sys.executable, path],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                cwd=os.getcwd()
-            )
-            return f"Started process PID: {self.process.pid}"
-        except Exception as e:
-            return f"Failed to start: {e}"
+            self.process = subprocess.Popen([sys.executable, tmp], stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE, env=env, preexec_fn=os.setsid)
+            time.sleep(0.5)
+            if self.process.poll() is not None:
+                out, err = self.process.communicate(timeout=2)
+                msg = (out.decode(errors="replace") + "\n" + err.decode(errors="replace")).strip()
+                return f"[Exited immediately]\n{msg}" if msg else "[Exited]"
+            return f"[GUI launched — PID {self.process.pid}] Switch to DISPLAY tab to view."
+        except Exception as e: return f"[Error] {e}"
 
     def stop(self):
-        if self.process:
-            self.process.terminate()
-            self.process = None
-            return "Process stopped."
-        return "No process running."
+        if self.process and self.process.poll() is None:
+            pid = self.process.pid
+            try: os.killpg(os.getpgid(pid), signal.SIGTERM); self.process.wait(timeout=3)
+            except:
+                try: os.killpg(os.getpgid(pid), signal.SIGKILL)
+                except: pass
+            self.process = None; return f"[Stopped PID {pid}]"
+        self.process = None; return "[No process]"
 
-class CodeAnalyzer:
-    """Parses Python code to extract structure (Classes/Functions)."""
-    def analyze(self, code):
-        if not code: return "No code."
-        try:
-            tree = ast.parse(code)
-            lines = []
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    lines.append(f"📦 Class: {node.name}")
-                    for item in node.body:
-                        if isinstance(item, ast.FunctionDef):
-                            lines.append(f"  🔹 def {item.name}(...)")
-                elif isinstance(node, ast.FunctionDef):
-                    # Only list top-level functions here (those not in a class)
-                    # This logic is simplified; ast.walk flattens everything.
-                    # A proper visitor is better, but for a simple view:
-                    pass 
-            
-            # Simple Regex fallback for cleaner hierarchy if AST is too messy
-            summary = []
-            for line in code.splitlines():
-                if line.strip().startswith("class "):
-                    summary.append(f"📦 {line.split(':')[0]}")
-                elif line.strip().startswith("def "):
-                    indent = "  " if line.startswith("    ") else ""
-                    summary.append(f"{indent}🔹 {line.split(':')[0]}")
-            
-            return "\n".join(summary) if summary else "No classes/functions found."
-        except SyntaxError:
-            return "❌ Syntax Error"
+gui_mgr = GUIProcessManager()
 
-class SnippetManager:
-    """Manages code snippets."""
+# ═══════════════════════════════════════
+# File System
+# ═══════════════════════════════════════
+class FileSystem:
     def __init__(self):
-        self.snippets = {
-            "Hello World": "print('Hello World')",
-            "Tkinter Basic": "import tkinter as tk\nroot = tk.Tk()\nroot.mainloop()",
-            "Gradio Demo": "import gradio as gr\ndef greet(n):\n return 'Hi '+n\ngr.Interface(fn=greet, inputs='text', outputs='text').launch()"
+        self.files: Dict[str, str] = {
+            "main.py": '# Start coding here\nprint("Hello World")',
+            "utils.py": "def add(a, b): return a + b",
         }
+        self.current_file = "main.py"
+        self._sync_dir = "/tmp/axon_workspace"
+        self._sync_to_disk()
 
-    def get_names(self):
-        return list(self.snippets.keys())
+    def _sync_to_disk(self):
+        os.makedirs(self._sync_dir, exist_ok=True)
+        for name, content in self.files.items():
+            path = os.path.join(self._sync_dir, name)
+            with open(path, "w") as f: f.write(content)
 
-    def get(self, name):
-        return self.snippets.get(name, "")
+    def save_file(self, content):
+        if self.current_file:
+            self.files[self.current_file] = content
+            path = os.path.join(self._sync_dir, self.current_file)
+            os.makedirs(os.path.dirname(path) if "/" in self.current_file else self._sync_dir, exist_ok=True)
+            with open(path, "w") as f: f.write(content)
+
+    def get_current_file_content(self): return self.files.get(self.current_file, "")
+    def set_current_file(self, f):
+        if f in self.files: self.current_file = f
+    def create_file(self, f, c=""):
+        if f and f not in self.files:
+            self.files[f] = c; self.current_file = f
+            self._sync_to_disk()
+    def delete_file(self, f):
+        if f in self.files and len(self.files) > 1:
+            del self.files[f]
+            path = os.path.join(self._sync_dir, f)
+            if os.path.exists(path): os.unlink(path)
+            self.current_file = list(self.files.keys())[0]
+            return True
+        return False
+    def get_all_files(self): return list(self.files.keys())
 
-    def add(self, name, code, tags):
-        self.snippets[name] = code
-        return "Snippet saved."
+fs = FileSystem()
 
-class FindReplace:
-    """Handles Text Finding and Replacing."""
-    def find_in_file(self, code, query, match_case):
-        if not query: return "Empty query."
-        flags = 0 if match_case else re.IGNORECASE
-        matches = list(re.finditer(re.escape(query), code, flags))
-        return f"Found {len(matches)} occurrences."
-
-    def find_in_all_files(self, file_list, query):
-        results = []
-        for filename in file_list:
+# ═══════════════════════════════════════
+# Snippet Library
+# ═══════════════════════════════════════
+class SnippetLibrary:
+    def __init__(self):
+        self.snippets = {}
+        self._load()
+    def _load(self):
+        if os.path.exists(SNIPPETS_FILE):
             try:
-                with open(filename, 'r') as f:
-                    content = f.read()
-                    if query in content:
-                        results.append(filename)
-            except: pass
-        return "\n".join(results) if results else "No matches in other files."
-
-    def replace_in_file(self, code, find, replace, match_case):
-        if not find: return code, "Empty search."
-        flags = 0 if match_case else re.IGNORECASE
-        new_code, count = re.subn(re.escape(find), replace, code, flags=flags)
-        return new_code, f"Replaced {count} occurrences."
+                with open(SNIPPETS_FILE) as f: self.snippets = json.load(f)
+            except: self.snippets = {}
+    def _save(self):
+        with open(SNIPPETS_FILE, "w") as f: json.dump(self.snippets, f)
+    def add(self, name, code, tags=""):
+        if not name.strip(): return "Error: name required"
+        self.snippets[name.strip()] = {"code": code, "tags": tags, "created": time.strftime("%Y-%m-%d")}
+        self._save(); return f"Saved: {name}"
+    def get(self, name): return self.snippets.get(name, {}).get("code", "")
+    def get_names(self): return list(self.snippets.keys())
+
+snippets = SnippetLibrary()
 
 # ═══════════════════════════════════════
-# 2. INSTANTIATE MANAGERS
+# Code Analyzer & FindReplace
 # ═══════════════════════════════════════
+class CodeAnalyzer:
+    @staticmethod
+    def analyze(code: str) -> str:
+        if not code.strip(): return "Empty file"
+        try: tree = ast.parse(code)
+        except SyntaxError as e: return f"⚠ Syntax error: line {e.lineno}: {e.msg}"
+        lines = [f"📊 {len(code.splitlines())} lines"]
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                lines.append(f"⚡ def {node.name}(...)")
+            elif isinstance(node, ast.ClassDef):
+                lines.append(f"🏗 class {node.name}")
+        return "\n".join(lines)
 
-vdisplay = VirtualDisplayManager()
-vdisplay.start()
-
-fs = FileSystem()
-terminal = TerminalManager()
-gui_mgr = GUIManager()
 analyzer = CodeAnalyzer()
-snippets = SnippetManager()
+
+class FindReplace:
+    @staticmethod
+    def find_in_file(code, query, case):
+        if not query: return ""
+        res = []
+        for i, line in enumerate(code.splitlines(), 1):
+            if (query in line) if case else (query.lower() in line.lower()):
+                res.append(f"L{i}: {line.strip()}")
+        return "\n".join(res) if res else "No matches."
+
+    @staticmethod
+    def replace_in_file(code, find, replace, case):
+        if not find: return code, "Empty find."
+        flags = 0 if case else re.IGNORECASE
+        new_code, count = re.subn(re.escape(find), replace, code, flags=flags)
+        return new_code, f"Replaced {count}."
+
 finder = FindReplace()
 
 # ═══════════════════════════════════════
-# 3. UI THEME & CSS
+# Terminal
 # ═══════════════════════════════════════
+class PTYTerminal:
+    def __init__(self):
+        self.master_fd = None; self.pid = None
+        self.lock = threading.Lock(); self.log = []
+        self._spawn()
+    def _spawn(self):
+        try:
+            pid, fd = pty.openpty(); self.pid = os.fork()
+            if self.pid == 0:
+                os.setsid(); os.dup2(fd,0); os.dup2(fd,1); os.dup2(fd,2)
+                if fd>2: os.close(fd)
+                os.execvpe("/bin/bash", ["/bin/bash","--norc","-i"], {**os.environ, "PS1":"$ ", "TERM":"dumb"})
+            else:
+                os.close(fd); self.master_fd = pid
+                fcntl.fcntl(self.master_fd, fcntl.F_SETFL, os.O_NONBLOCK)
+        except: pass
+    def read(self):
+        if not self.master_fd: return ""
+        try:
+            out = b""
+            while True:
+                r,_,_ = select.select([self.master_fd],[],[],0.01)
+                if not r: break
+                out += os.read(self.master_fd, 1024)
+            if out:
+                txt = out.decode(errors="replace")
+                self.log.append(txt)
+                return "".join(self.log)[-2000:]
+        except: return "".join(self.log)[-2000:]
+        return "".join(self.log)[-2000:]
+    def write(self, cmd):
+        if self.master_fd: os.write(self.master_fd, (cmd+"\n").encode())
+    def cleanup(self):
+        if self.pid: os.kill(self.pid, signal.SIGTERM)
 
-theme = gr.themes.Soft(
-    primary_hue="orange",
-    secondary_hue="slate",
-    neutral_hue="slate",
-)
+terminal = PTYTerminal()
 
-css = """
-.gradio-container { min-height: 100vh; }
-textarea { font-family: 'Consolas', 'Monaco', monospace !important; }
-.cm-scroller { overflow: auto !important; }
-"""
+# ═══════════════════════════════════════
+# AI Model
+# ═════════��═════════════════════════════
+@lru_cache(maxsize=1)
+def load_model():
+    print("Loading Model...")
+    try:
+        tok = AutoTokenizer.from_pretrained(MODEL_NAME)
+        mdl = AutoModelForCausalLM.from_pretrained(MODEL_NAME, dtype=DTYPE, device_map=DEVICE)
+        return pipeline("text-generation", model=mdl, tokenizer=tok)
+    except: return None
+
+def ai_gen(prompt, code):
+    pipe = load_model()
+    if not pipe: return "Model load failed."
+    formatted = f"<|system|>You are a Python coding assistant.</s><|user|>{prompt}\n{code}</s><|assistant|>"
+    try: return pipe(formatted, max_new_tokens=256, temperature=0.2)[0]["generated_text"].split("<|assistant|>")[-1]
+    except Exception as e: return str(e)
 
 # ═══════════════════════════════════════
-# 4. UI CONSTRUCTION
+# UI Setup
 # ═══════════════════════════════════════
+theme = gr.themes.Default(
+    primary_hue="cyan", neutral_hue="gray",
+    font=[gr.themes.GoogleFont("IBM Plex Mono"), "monospace"]
+).set(body_background_fill="#080808", body_text_color="#e0e0e0")
 
-with gr.Blocks(theme=theme, css=css, title="Python IDE") as demo:
-    
-    # State variables
-    # (Gradio 4.x usually handles state via component values, but we can use State objects if needed)
+css = """
+.gradio-container { max-width: 100% !important; }
+textarea { font-family: 'IBM Plex Mono', monospace !important; font-size: 12px !important; }
+"""
+
+with gr.Blocks(title="Axon Pro", theme=theme, css=css) as demo:
     
     with gr.Row():
-        # ─── LEFT SIDEBAR ───
-        with gr.Column(scale=1, min_width=250):
-            gr.Markdown("### 📂 Explorer")
-            
-            with gr.Row():
-                new_file_name = gr.Textbox(placeholder="NewFile.py", show_label=False, scale=3)
-                new_file_btn = gr.Button("➕", scale=1, min_width=10)
+        gr.Markdown("# ⬡ AXON PRO v4")
+
+    with gr.Row():
+        # Left Sidebar
+        with gr.Column(scale=1, min_width=200):
+            with gr.Accordion("📁 EXPLORER", open=True):
+                file_list = gr.Dropdown(choices=fs.get_all_files(), value=fs.current_file, label="Files")
+                new_file_txt = gr.Textbox(placeholder="new_file.py", show_label=False)
+                with gr.Row():
+                    new_btn = gr.Button("NEW", size="sm")
+                    save_btn = gr.Button("SAVE", size="sm")
+                    del_btn = gr.Button("DEL", size="sm", variant="stop")
             
-            file_list = gr.Dropdown(choices=fs.get_all_files(), label="Files", value=fs.current_file, interactive=True)
+            with gr.Accordion("🗺 STRUCTURE", open=True):
+                structure_view = gr.Textbox(label="", lines=10, interactive=False)
             
-            with gr.Row():
-                refresh_btn = gr.Button("🔄 Refresh")
-                del_file_btn = gr.Button("🗑 Delete", variant="stop")
-
-            gr.Markdown("### 🌳 Structure")
-            structure_view = gr.Code(language="markdown", label="AST Outline", interactive=False, lines=15)
-
-        # ─── MAIN AREA ───
+            with gr.Accordion("📋 SNIPPETS", open=False):
+                snip_list = gr.Dropdown(choices=snippets.get_names(), label="Saved")
+                snip_name = gr.Textbox(placeholder="Name", show_label=False)
+                with gr.Row():
+                    snip_save_btn = gr.Button("SAVE", size="sm")
+                    snip_load_btn = gr.Button("INSERT", size="sm")
+                status_msg = gr.Markdown("")
+
+        # Main Editor Area
         with gr.Column(scale=4):
+            editor = gr.Code(value=fs.get_current_file_content(), language="python", lines=20)
             
-            # Toolbar
-            with gr.Row():
-                run_btn = gr.Button("▶ RUN (Console)", variant="primary")
-                run_gui_btn = gr.Button("🖼 RUN (GUI)", variant="secondary")
-                stop_gui_btn = gr.Button("⏹ STOP", variant="stop")
-                save_btn = gr.Button("💾 SAVE")
-            
-            # Editor
-            editor = gr.Code(
-                value=fs.get_current_file_content(), 
-                language="python", 
-                label=f"Editor - {fs.current_file}", 
-                lines=20,
-                interactive=True
-            )
-
-            # AI/Tools Row (Placeholder for future expansion)
             with gr.Row():
-                complete_btn = gr.Button("✨ Auto-Complete")
-                explain_btn = gr.Button("🧐 Explain")
-                refactor_btn = gr.Button("🛠 Refactor")
+                run_btn = gr.Button("▶ RUN CLI", variant="primary")
+                run_gui_btn = gr.Button("🖥 RUN GUI", variant="primary")
+                stop_btn = gr.Button("■ STOP", variant="stop")
+                ai_complete = gr.Button("✨ COMPLETE")
+                ai_explain = gr.Button("🤔 EXPLAIN")
 
-            # Bottom Tabs
             with gr.Tabs():
-                
-                # ─ Terminal Tab ─
-                with gr.Tab("💻 TERMINAL"):
-                    terminal_output = gr.Textbox(label="Output", lines=10, max_lines=20, elem_classes="term-out")
-                    with gr.Row():
-                        terminal_input = gr.Textbox(show_label=False, placeholder="Type command here...", scale=4)
-                        terminal_run_btn = gr.Button("Run", scale=1)
-                    with gr.Row():
-                        clear_btn = gr.Button("Clear Output")
-                        history_refresh = gr.Button("History")
-                        history_dd = gr.Dropdown(label="Command History", choices=[])
+                with gr.Tab("TERMINAL"):
+                    term_out = gr.Textbox(lines=12, label="Output", interactive=False)
+                    term_in = gr.Textbox(placeholder="$ Command...", show_label=False)
+                    term_run = gr.Button("Enter")
 
-                # ─ Find/Replace Tab ─
-                with gr.Tab("🔍 FIND"):
-                    with gr.Row():
-                        find_query = gr.Textbox(label="Find", placeholder="Text to find...")
-                        replace_query = gr.Textbox(label="Replace", placeholder="Replacement text...")
-                    
+                with gr.Tab("FIND"):
                     with gr.Row():
-                        find_case = gr.Checkbox(label="Match Case")
-                        
+                        find_query = gr.Textbox(label="Find")
+                        replace_query = gr.Textbox(label="Replace")
+                        find_case = gr.Checkbox(label="Case Sensitive")
                     with gr.Row():
-                        find_btn = gr.Button("FIND", variant="primary")
-                        find_all_btn = gr.Button("FIND ALL")
-                        replace_btn = gr.Button("REPLACE")
-                    
+                        find_btn = gr.Button("Find")
+                        replace_btn = gr.Button("Replace All")
                     find_results = gr.Textbox(label="Results", lines=5)
 
-                # ─ Snippets Tab ─
-                with gr.Tab("🧩 SNIPPETS"):
+                with gr.Tab("DISPLAY"):
+                    display_image = gr.Image(label="Virtual Display", interactive=False, type="filepath")
                     with gr.Row():
-                        snippet_list = gr.Dropdown(choices=snippets.get_names(), label="Load Snippet")
-                        snippet_insert_btn = gr.Button("Insert into Editor")
-                    
-                    gr.Markdown("---")
-                    with gr.Row():
-                        snippet_name = gr.Textbox(label="Snippet Name")
-                        snippet_tags = gr.Textbox(label="Tags (comma sep)")
-                    snippet_save_btn = gr.Button("Save Selection as Snippet")
-                    snippet_status = gr.Markdown("")
-
-                # ─ Display Tab (Xvfb) ─
-                with gr.Tab("🖥 DISPLAY"):
-                    display_image = gr.Image(label="Xvfb Capture", type="filepath", interactive=False, height=400)
-                    with gr.Row():
-                        capture_btn = gr.Button("📸 CAPTURE SCREEN", variant="primary")
-                        auto_capture = gr.Checkbox(label="Auto-refresh (2s)")
-                    
+                        capture_btn = gr.Button("📸 Refresh Screen")
+                        auto_capture = gr.Checkbox(label="Auto Refresh (2s)")
                     auto_timer = gr.Timer(value=2.0, active=False)
 
     # ═══════════════════════════════════════
-    # 5. LOGIC FUNCTIONS
+    # LOGIC & WIRING
     # ═══════════════════════════════════════
-    
-    # --- File System Wrappers ---
-    def load_file_content(f):
+
+    # --- File System Handlers ---
+    def load_file(f):
         fs.set_current_file(f)
-        content = fs.get_current_file_content()
-        return content, f"Editor - {f}", analyzer.analyze(content)
+        code = fs.get_current_file_content()
+        return code, analyzer.analyze(code)
 
-    def refresh_file_list():
-        files = fs.refresh()
-        return gr.update(choices=files, value=fs.current_file)
+    def create_file(name):
+        fs.create_file(name)
+        return gr.Dropdown(choices=fs.get_all_files(), value=name), "", ""
 
-    def save_file_content(code):
+    def save_file(code):
         fs.save_file(code)
-        return "File saved."
-
-    def create_new_file(name):
-        if not name: return gr.update(), "Name required", ""
-        fs.create_file(name)
-        content = fs.get_current_file_content()
-        return gr.update(choices=fs.get_all_files(), value=name), f"Editor - {name}", analyzer.analyze(content)
-
-    def delete_current_file(name):
-        if fs.delete_file(name):
-            next_file = fs.current_file
-            content = fs.get_current_file_content()
-            return (
-                gr.update(choices=fs.get_all_files(), value=next_file), 
-                content, 
-                f"Editor - {next_file}", 
-                analyzer.analyze(content)
-            )
-        return gr.update(), gr.update(), gr.update(), gr.update()
-
-    # --- Execution Wrappers ---
-    def run_console_code(code):
-        # Simply run the code and return stdout
-        # Note: This runs in the same environment, simplistic.
-        fd, path = tempfile.mkstemp(suffix=".py")
-        with os.fdopen(fd, 'w') as f:
-            f.write(code)
-        try:
-            res = subprocess.run([sys.executable, path], capture_output=True, text=True, timeout=5)
-            return f"OUTPUT:\n{res.stdout}\nERRORS:\n{res.stderr}"
-        except Exception as e:
-            return str(e)
+        return "Saved."
+
+    def delete_file(f):
+        fs.delete_file(f)
+        new_f = fs.current_file
+        new_c = fs.get_current_file_content()
+        return gr.Dropdown(choices=fs.get_all_files(), value=new_f), new_c
+
+    file_list.change(load_file, file_list, [editor, structure_view])
+    new_btn.click(create_file, new_file_txt, [file_list, new_file_txt, editor])
+    save_btn.click(save_file, editor, status_msg)
+    del_btn.click(delete_file, file_list, [file_list, editor])
+    editor.change(lambda c: analyzer.analyze(c), editor, structure_view)
+
+    # --- Execution Handlers ---
+    def run_cli(code):
+        fs.save_file(code)
+        cmd = f"python3 {fs._sync_dir}/{fs.current_file}"
+        terminal.write(cmd)
+        time.sleep(0.5)
+        return terminal.read()
 
-    def run_gui_code(code):
+    def run_gui(code):
+        fs.save_file(code)
         return gui_mgr.launch(code)
 
-    def stop_gui_code():
-        return gui_mgr.stop()
+    run_btn.click(run_cli, editor, term_out)
+    run_gui_btn.click(run_gui, editor, term_out)
+    stop_btn.click(gui_mgr.stop, None, term_out)
 
-    def terminal_submit(cmd):
-        return terminal.run_command(cmd), gr.update(value="")
+    # --- AI Handlers ---
+    ai_complete.click(lambda c: ai_gen("Complete this code:", c), editor, editor)
+    ai_explain.click(lambda c: ai_gen("Explain this code:", c), editor, term_out)
 
-    # --- Bridge Functions (Find/Display) ---
-    def do_find(code, query, case):
-        return finder.find_in_file(code, query, case)
+    # --- Terminal Handlers ---
+    def term_cmd(cmd):
+        terminal.write(cmd)
+        time.sleep(0.2)
+        return "", terminal.read()
+    
+    term_run.click(term_cmd, term_in, [term_in, term_out])
+    term_in.submit(term_cmd, term_in, [term_in, term_out])
 
-    def do_find_all(query):
-        return finder.find_in_all_files(fs.files, query)
+    # --- Find/Replace Handlers ---
+    find_btn.click(finder.find_in_file, [editor, find_query, find_case], find_results)
+    
+    def replace_h(c, f, r, case):
+        new_c, msg = finder.replace_in_file(c, f, r, case)
+        return new_c, msg
+    
+    replace_btn.click(replace_h, [editor, find_query, replace_query, find_case], [editor, find_results])
 
-    def do_replace(code, find, replace, case):
-        new_code, msg = finder.replace_in_file(code, find, replace, case)
-        # Update editor, results box, AND structure view
-        fs.save_file(new_code)  # Auto-save on replace
-        new_structure = analyzer.analyze(new_code)
-        return new_code, msg, new_structure
+    # --- Snippet Handlers ---
+    snip_save_btn.click(snippets.add, [snip_name, editor], status_msg)
+    
+    def insert_snip(name, code):
+        return code + "\n" + snippets.get(name)
+        
+    snip_load_btn.click(insert_snip, [snip_list, editor], editor)
 
-    def capture_display():
+    # --- Display Handlers ---
+    def capture():
         path = vdisplay.capture()
         return path if path else None
 
-    def toggle_auto(checkbox_state):
-        return gr.Timer(active=checkbox_state)
-
-    def auto_capture_tick():
-        return capture_display()
-
-    # --- Snippet Wrappers ---
-    def insert_snippet(code, snippet_name):
-        s_code = snippets.get(snippet_name)
-        if not s_code: return code
-        return (code + "\n" + s_code) if code else s_code
-
-    def save_snippet_ui(name, code, tags):
-        return snippets.add(name, code, tags), gr.update(choices=snippets.get_names())
-
-    # --- AI Mock functions ---
-    def mock_ai_action(code, action):
-        return f"# {action} applied to code (AI Mock)\n" + code
-
-    # ═══════════════════════════════════════
-    # 6. EVENT WIRING
-    # ═══════════════════════════════════════
-    
-    # File Explorer
-    file_list.change(fn=load_file_content, inputs=file_list, outputs=[editor, editor.label, structure_view])
-    refresh_btn.click(fn=refresh_file_list, inputs=None, outputs=file_list)
-    new_file_btn.click(fn=create_new_file, inputs=new_file_name, outputs=[file_list, editor.label, structure_view])
-    save_btn.click(fn=save_file_content, inputs=editor, outputs=None)
-    del_file_btn.click(fn=delete_current_file, inputs=file_list, outputs=[file_list, editor, editor.label, structure_view])
-
-    # Editor Actions
-    run_btn.click(fn=run_console_code, inputs=editor, outputs=terminal_output)
-    run_gui_btn.click(fn=run_gui_code, inputs=editor, outputs=terminal_output)
-    stop_gui_btn.click(fn=stop_gui_code, inputs=None, outputs=terminal_output)
-    
-    # AI Actions
-    complete_btn.click(fn=lambda c: mock_ai_action(c, "Completion"), inputs=editor, outputs=editor)
-    explain_btn.click(fn=lambda c: mock_ai_action(c, "Explanation"), inputs=editor, outputs=terminal_output)
-    refactor_btn.click(fn=lambda c: mock_ai_action(c, "Refactor"), inputs=editor, outputs=editor)
-
-    # Terminal
-    terminal_run_btn.click(fn=terminal_submit, inputs=terminal_input, outputs=[terminal_output, terminal_input])
-    terminal_input.submit(fn=terminal_submit, inputs=terminal_input, outputs=[terminal_output, terminal_input])
-    clear_btn.click(fn=lambda: terminal.run_command("clear"), inputs=None, outputs=terminal_output)
-    history_refresh.click(fn=lambda: gr.update(choices=terminal.get_history_choices()), inputs=None, outputs=history_dd)
-    history_dd.change(fn=lambda x: x, inputs=history_dd, outputs=terminal_input)
-
-    # Find & Replace
-    find_btn.click(fn=do_find, inputs=[editor, find_query, find_case], outputs=find_results)
-    find_all_btn.click(fn=do_find_all, inputs=[find_query], outputs=find_results)
-    replace_btn.click(fn=do_replace, 
-                      inputs=[editor, find_query, replace_query, find_case],
-                      outputs=[editor, find_results, structure_view])
-
-    # Display / Capture
-    capture_btn.click(fn=capture_display, inputs=None, outputs=display_image)
-    auto_capture.change(fn=toggle_auto, inputs=auto_capture, outputs=auto_timer)
-    auto_timer.tick(fn=auto_capture_tick, inputs=None, outputs=display_image)
-
-    # Snippets
-    snippet_insert_btn.click(fn=insert_snippet, inputs=[editor, snippet_list], outputs=editor)
-    snippet_save_btn.click(fn=save_snippet_ui, inputs=[snippet_name, editor, snippet_tags], outputs=[snippet_status, snippet_list])
+    capture_btn.click(capture, None, display_image)
+    auto_capture.change(lambda x: gr.Timer(active=x), auto_capture, auto_timer)
+    auto_timer.tick(capture, None, display_image)
 
 if __name__ == "__main__":
-    # Register cleanup handlers
+    import atexit
     atexit.register(terminal.cleanup)
     atexit.register(gui_mgr.stop)
     atexit.register(vdisplay.cleanup)
     
-    # Launch
     demo.queue().launch(
         server_name="0.0.0.0", 
         server_port=7860,