Update app.py

app.py

@@ -14,654 +14,936 @@ import struct
 import termios
 import threading
 import re
+import ast
+import json
+import types
 import tempfile
+from pathlib import Path
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, GenerationConfig
-from typing import List
+from typing import List, Dict, Optional
 from functools import lru_cache
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
-# --- Configuration ---
 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"
 
-# --- Virtual Display ---
+# ═══════════════════════════════════════
+# Virtual Display
+# ═══════════════════════════════════════
 class VirtualDisplay:
     def __init__(self):
         self.xvfb_proc = None
         self.display = DISPLAY_NUM
+        self._ensure_deps()
         self._start_xvfb()
 
+    def _ensure_deps(self):
+        needed = []
+        for cmd in ["Xvfb", "xdpyinfo"]:
+            if subprocess.run(["which", cmd], capture_output=True).returncode != 0:
+                needed.extend(["xvfb", "x11-utils"]); break
+        for cmd in ["scrot", "import"]:
+            if subprocess.run(["which", cmd], capture_output=True).returncode == 0: break
+        else:
+            needed.extend(["scrot", "imagemagick"])
+        if needed:
+            print(f"[Xvfb] Installing: {set(needed)}")
+            subprocess.run(["apt-get", "update", "-qq"], capture_output=True, timeout=60)
+            subprocess.run(["apt-get", "install", "-y", "-qq"] + list(set(needed)),
+                           capture_output=True, timeout=120)
+
     def _start_xvfb(self):
         try:
-            subprocess.run(["pkill", "-f", f"Xvfb {self.display}"],
-                           capture_output=True, timeout=5)
+            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"],
+                ["Xvfb", self.display, "-screen", "0", f"{SCREEN_W}x{SCREEN_H}x24",
+                 "-ac", "-nolisten", "tcp"],
                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
             time.sleep(0.5)
-            if self.xvfb_proc.poll() is not None:
-                print("[Xvfb] Failed, installing...")
-                subprocess.run(["apt-get", "update", "-qq"], capture_output=True, timeout=60)
-                subprocess.run(["apt-get", "install", "-y", "-qq", "xvfb", "x11-utils",
-                                "imagemagick"], capture_output=True, timeout=120)
-                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)
-                time.sleep(0.5)
             if self.xvfb_proc.poll() is None:
                 print(f"[Xvfb] Running on {self.display}")
                 os.environ["DISPLAY"] = self.display
             else:
-                print("[Xvfb] Could not start")
-                self.xvfb_proc = None
-        except FileNotFoundError:
-            print("[Xvfb] Not found, installing...")
-            try:
-                subprocess.run(["apt-get", "update", "-qq"], capture_output=True, timeout=60)
-                subprocess.run(["apt-get", "install", "-y", "-qq", "xvfb", "x11-utils",
-                                "imagemagick"], capture_output=True, timeout=120)
-                self._start_xvfb()
-            except Exception as e:
-                print(f"[Xvfb] Install failed: {e}")
                 self.xvfb_proc = None
         except Exception as e:
-            print(f"[Xvfb] Error: {e}")
-            self.xvfb_proc = None
-
-    def capture_screenshot(self) -> str | None:
-        if not self.is_running:
-            return None
-        try:
-            tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
-            tmp.close()
-            result = subprocess.run(
-                ["import", "-window", "root", "-display", self.display, tmp.name],
-                capture_output=True, timeout=5)
-            if result.returncode == 0 and os.path.getsize(tmp.name) > 100:
-                return tmp.name
-            os.unlink(tmp.name)
-        except Exception:
-            pass
+            print(f"[Xvfb] {e}"); self.xvfb_proc = None
+
+    def capture(self):
+        if not self.is_running: return None
+        tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False); tmp.close()
+        for cmd in [
+            ["scrot", "--display", self.display, tmp.name],
+            f"xwd -root -display {self.display} | convert xwd:- png:{tmp.name}",
+            ["import", "-window", "root", "-display", self.display, tmp.name],
+        ]:
+            try:
+                kw = {"shell": True} if isinstance(cmd, str) else {}
+                r = subprocess.run(cmd, capture_output=True, timeout=5,
+                                   env={**os.environ, "DISPLAY": self.display}, **kw)
+                if r.returncode == 0 and os.path.exists(tmp.name) and os.path.getsize(tmp.name) > 200:
+                    return tmp.name
+            except: pass
+        try: os.unlink(tmp.name)
+        except: pass
         return None
 
     @property
-    def is_running(self) -> bool:
-        return self.xvfb_proc is not None and self.xvfb_proc.poll() is None
-
+    def is_running(self): return self.xvfb_proc is not None and self.xvfb_proc.poll() is None
     def cleanup(self):
         if self.xvfb_proc:
             self.xvfb_proc.terminate()
-            try:
-                self.xvfb_proc.wait(timeout=3)
-            except subprocess.TimeoutExpired:
-                self.xvfb_proc.kill()
+            try: self.xvfb_proc.wait(timeout=3)
+            except: self.xvfb_proc.kill()
 
 vdisplay = VirtualDisplay()
 
-# --- File System ---
+# ═══════════════════════════════════════
+# GUI Process Manager
+# ═══════════════════════════════════════
+class GUIProcessManager:
+    def __init__(self):
+        self.process = None
+    def launch(self, 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:
+            self.process = subprocess.Popen([sys.executable, tmp], stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE, env=env, preexec_fn=os.setsid)
+            time.sleep(1.0)
+            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}]  CAPTURE to see output."
+        except Exception as e: return f"[Error] {e}"
+    def stop(self):
+        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]"
+    @property
+    def is_running(self): return self.process is not None and self.process.poll() is None
+    def get_status(self): return f"● PID {self.process.pid}" if self.is_running else "○ idle"
+
+gui_mgr = GUIProcessManager()
+
+# ═══════════════════════════════════════
+# File System (with cross-file imports)
+# ═══════════════════════════════════════
 class FileSystem:
     def __init__(self):
-        self.files = {
-            "main.py": "# Start coding here\nprint('Hello Axon Pro (Python Edition)')",
-            "utils.py": "# Utility functions\ndef add(a, b):\n    return a + b",
+        self.files: Dict[str, str] = {
+            "main.py": '# Start coding here\nfrom utils import add\n\nresult = add(3, 7)\nprint(f"3 + 7 = {result}")',
+            "utils.py": "# Utility functions\ndef add(a, b):\n    return a + b\n\ndef multiply(a, b):\n    return a * b",
             "notes.txt": "Project requirements:\n- Build a cool AI app\n- Use Gradio"
         }
         self.current_file = "main.py"
-
-    def save_file(self, content: str) -> None:
+        self._sync_dir = "/tmp/axon_workspace"
+        self._sync_to_disk()
+
+    def _sync_to_disk(self):
+        """Write all virtual files to disk so cross-file imports work."""
+        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 save_file(self, content):
         if self.current_file:
             self.files[self.current_file] = content
+            # Sync to disk for imports
+            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 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 rename_file(self, old, new):
+        if old in self.files and new not in self.files:
+            self.files[new] = self.files.pop(old)
+            old_path = os.path.join(self._sync_dir, old)
+            if os.path.exists(old_path): os.unlink(old_path)
+            self._sync_to_disk()
+            if self.current_file == old: self.current_file = new
+            return True
+        return False
+    def get_all_files(self): return list(self.files.keys())
 
-    def get_current_file_content(self) -> str:
-        return self.files.get(self.current_file, "")
-
-    def set_current_file(self, filename: str) -> None:
-        if filename in self.files:
-            self.current_file = filename
-
-    def create_file(self, filename: str, content: str = "") -> None:
-        if filename not in self.files:
-            self.files[filename] = content
-            self.current_file = filename
+fs = FileSystem()
 
-    def get_all_files(self) -> List[str]:
-        return list(self.files.keys())
+# ═══════════════════════════════════════
+# Snippet Library
+# ═══════════════════════════════════════
+class SnippetLibrary:
+    def __init__(self):
+        self.snippets: Dict[str, dict] = {}
+        self._load()
 
-fs = FileSystem()
+    def _load(self):
+        try:
+            if os.path.exists(SNIPPETS_FILE):
+                with open(SNIPPETS_FILE) as f:
+                    self.snippets = json.load(f)
+        except: self.snippets = {}
 
-# --- PTY Terminal ---
+    def _save(self):
+        try:
+            with open(SNIPPETS_FILE, "w") as f:
+                json.dump(self.snippets, f, indent=2)
+        except: pass
+
+    def add(self, name: str, code: str, tags: str = "") -> str:
+        if not name.strip(): return "Error: name required"
+        self.snippets[name.strip()] = {
+            "code": code,
+            "tags": [t.strip() for t in tags.split(",") if t.strip()],
+            "created": time.strftime("%Y-%m-%d %H:%M"),
+        }
+        self._save()
+        return f"Saved snippet: {name.strip()}"
+
+    def get(self, name: str) -> str:
+        s = self.snippets.get(name)
+        return s["code"] if s else ""
+
+    def delete(self, name: str) -> str:
+        if name in self.snippets:
+            del self.snippets[name]
+            self._save()
+            return f"Deleted: {name}"
+        return "Not found"
+
+    def search(self, query: str) -> List[str]:
+        q = query.lower()
+        results = []
+        for name, data in self.snippets.items():
+            if q in name.lower() or any(q in t.lower() for t in data.get("tags", [])):
+                results.append(name)
+        return results if query else list(self.snippets.keys())
+
+    def list_all(self) -> str:
+        if not self.snippets: return "No snippets saved yet."
+        lines = []
+        for name, data in self.snippets.items():
+            tags = ", ".join(data.get("tags", []))
+            lines.append(f"  {name}  [{tags}]  ({data.get('created', '?')})")
+        return "\n".join(lines)
+
+    def get_names(self) -> List[str]:
+        return list(self.snippets.keys())
+
+snippets = SnippetLibrary()
+
+# ═══════════════════════════════════════
+# Code Structure Analyzer
+# ═══════════════════════════════════════
+class CodeAnalyzer:
+    """Parses Python code and extracts structure (functions, classes, imports)."""
+
+    @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 = []
+        imports = []
+        functions = []
+        classes = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imports.append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                imports.append(f"from {node.module} import {', '.join(a.name for a in node.names)}")
+            elif isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
+                # Check if it's a method (inside a class)
+                args = ", ".join(a.arg for a in node.args.args)
+                prefix = "async " if isinstance(node, ast.AsyncFunctionDef) else ""
+                decorators = [f"@{ast.dump(d)}" for d in node.decorator_list] if hasattr(node, 'decorator_list') else []
+                ret = ""
+                if node.returns:
+                    try: ret = f" → {ast.unparse(node.returns)}"
+                    except: ret = " → ?"
+                functions.append((node.lineno, f"{prefix}def {node.name}({args}){ret}"))
+            elif isinstance(node, ast.ClassDef):
+                bases = ", ".join(ast.unparse(b) for b in node.bases) if node.bases else ""
+                bases_str = f"({bases})" if bases else ""
+                methods = []
+                for item in node.body:
+                    if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        methods.append(item.name)
+                classes.append((node.lineno, node.name + bases_str, methods))
+
+        # Count stats
+        total_lines = len(code.splitlines())
+        non_empty = len([l for l in code.splitlines() if l.strip()])
+
+        # Build output
+        lines.append(f"📊 {total_lines} lines ({non_empty} non-empty)")
+        lines.append("")
+
+        if imports:
+            lines.append(f"📦 IMPORTS ({len(imports)})")
+            for i in imports:
+                lines.append(f"  {i}")
+            lines.append("")
+
+        if classes:
+            lines.append(f"🏗 CLASSES ({len(classes)})")
+            for lineno, name, methods in classes:
+                lines.append(f"  L{lineno}: class {name}")
+                for m in methods:
+                    lines.append(f"    .{m}()")
+            lines.append("")
+
+        if functions:
+            # Filter out class methods (they're shown under classes)
+            class_methods = set()
+            for _, _, methods in classes:
+                class_methods.update(methods)
+            standalone = [(ln, f) for ln, f in functions if not any(
+                f.split("(")[0].replace("def ", "").replace("async ", "").strip() in class_methods
+                for _ in [None]
+            )]
+            # Actually just show all functions for simplicity
+            lines.append(f"⚡ FUNCTIONS ({len(functions)})")
+            for lineno, sig in functions:
+                lines.append(f"  L{lineno}: {sig}")
+
+        if not imports and not functions and not classes:
+            lines.append("(No functions, classes, or imports found)")
+
+        return "\n".join(lines)
+
+analyzer = CodeAnalyzer()
+
+# ═══════════════════════════════════════
+# Find & Replace
+# ═══════════════════════════════════════
+class FindReplace:
+    @staticmethod
+    def find_in_file(code: str, query: str, case_sensitive: bool = False) -> str:
+        if not query: return ""
+        lines = code.splitlines()
+        results = []
+        for i, line in enumerate(lines, 1):
+            check_line = line if case_sensitive else line.lower()
+            check_query = query if case_sensitive else query.lower()
+            if check_query in check_line:
+                results.append(f"  L{i}: {line.strip()}")
+        if results:
+            return f"Found {len(results)} match(es):\n" + "\n".join(results)
+        return "No matches found."
+
+    @staticmethod
+    def find_in_all_files(files: Dict[str, str], query: str) -> str:
+        if not query: return ""
+        results = []
+        for fname, content in files.items():
+            lines = content.splitlines()
+            for i, line in enumerate(lines, 1):
+                if query.lower() in line.lower():
+                    results.append(f"  {fname}:L{i}: {line.strip()}")
+        if results:
+            return f"Found {len(results)} match(es) across all files:\n" + "\n".join(results)
+        return "No matches found."
+
+    @staticmethod
+    def replace_in_file(code: str, find: str, replace: str, case_sensitive: bool = False) -> tuple:
+        if not find: return code, "Nothing to find."
+        if case_sensitive:
+            count = code.count(find)
+            new_code = code.replace(find, replace)
+        else:
+            pattern = re.compile(re.escape(find), re.IGNORECASE)
+            matches = pattern.findall(code)
+            count = len(matches)
+            new_code = pattern.sub(replace, code)
+        return new_code, f"Replaced {count} occurrence(s)."
+
+finder = FindReplace()
+
+# ═══════════════════════════════════════
+# PTY Terminal (with history)
+# ═══════════════════════════════════════
 class PTYTerminal:
     STRIP_ANSI = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07|\x1b\[.*?[@-~]|\r')
-
     def __init__(self):
-        self.master_fd = None
-        self.pid = None
-        self.lock = threading.Lock()
-        self.log_lines: List[str] = []
-        self.max_lines = 800
+        self.master_fd = None; self.pid = None
+        self.lock = threading.Lock(); self.log_lines = []; self.max_lines = 800
+        self.cmd_history: List[str] = []
+        self.max_history = 100
         self._spawn_shell()
-        self._append("AXON TERMINAL v3.0")
+        self._append("AXON TERMINAL v4.0")
         self._append("══════════════════════════════════════")
-        self._append("Full PTY shell — everything works:")
-        self._append("  pip/npm/apt-get/git/curl/wget/make")
-        self._append("  python/node — GUI apps render to Display")
+        self._append("Full PTY shell · Cross-file imports")
+        self._append("  pip/npm/apt-get/git/curl/make")
+        self._append("  GUI apps → Display · History → ↑↓")
         self._append("══════════════════════════════════════")
 
     def _spawn_shell(self):
         try:
-            pid, fd = pty.openpty()
-            self.pid = os.fork()
+            pid, fd = pty.openpty(); self.pid = os.fork()
             if self.pid == 0:
-                os.close(pid)
-                os.setsid()
-                fcntl.ioctl(fd, termios.TIOCSCTTY, 0)
-                os.dup2(fd, 0); os.dup2(fd, 1); os.dup2(fd, 2)
-                if fd > 2: os.close(fd)
+                os.close(pid); os.setsid(); fcntl.ioctl(fd, termios.TIOCSCTTY, 0)
+                os.dup2(fd,0); os.dup2(fd,1); os.dup2(fd,2)
+                if fd>2: os.close(fd)
                 env = os.environ.copy()
-                env.update({"TERM": "dumb", "PS1": "$ ",
-                            "DEBIAN_FRONTEND": "noninteractive", "DISPLAY": DISPLAY_NUM})
-                os.execvpe("/bin/bash", ["/bin/bash", "--norc", "--noprofile", "-i"], env)
+                env.update({"TERM":"dumb","PS1":"$ ","DEBIAN_FRONTEND":"noninteractive","DISPLAY":DISPLAY_NUM})
+                os.execvpe("/bin/bash",["/bin/bash","--norc","--noprofile","-i"],env)
             else:
-                os.close(fd)
-                self.master_fd = pid
-                flags = fcntl.fcntl(self.master_fd, fcntl.F_GETFL)
-                fcntl.fcntl(self.master_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
-                fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ,
-                            struct.pack("HHHH", 40, 120, 0, 0))
-                time.sleep(0.3)
-                self._read(0.2)
-        except Exception as e:
-            self._append(f"[Shell Error] {e}")
-            self.master_fd = None
-
-    def _read(self, timeout=0.1) -> str:
-        if self.master_fd is None: return ""
-        out = []
-        deadline = time.time() + timeout
+                os.close(fd); self.master_fd = pid
+                fl = fcntl.fcntl(self.master_fd, fcntl.F_GETFL)
+                fcntl.fcntl(self.master_fd, fcntl.F_SETFL, fl|os.O_NONBLOCK)
+                fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, struct.pack("HHHH",40,120,0,0))
+                time.sleep(0.3); self._read(0.2)
+        except Exception as e: self._append(f"[Shell Error] {e}"); self.master_fd=None
+
+    def _read(self, timeout=0.1):
+        if not self.master_fd: return ""
+        out=[]; dl=time.time()+timeout
         while True:
-            rem = deadline - time.time()
-            if rem <= 0: break
+            r=dl-time.time()
+            if r<=0: break
             try:
-                r, _, _ = select.select([self.master_fd], [], [], min(rem, 0.05))
-                if r:
-                    c = os.read(self.master_fd, 4096)
-                    if c:
-                        out.append(c.decode("utf-8", errors="replace"))
-                        deadline = time.time() + 0.15
+                rd,_,_=select.select([self.master_fd],[],[],min(r,0.05))
+                if rd:
+                    c=os.read(self.master_fd,4096)
+                    if c: out.append(c.decode("utf-8",errors="replace")); dl=time.time()+0.15
                     else: break
                 elif out: break
             except OSError: break
         return "".join(out)
 
-    def _clean(self, text):
-        c = self.STRIP_ANSI.sub("", text)
-        return "".join(ch for ch in c if ch in "\n\t" or ord(ch) >= 32)
+    def _clean(self, t):
+        c=self.STRIP_ANSI.sub("",t); return "".join(ch for ch in c if ch in "\n\t" or ord(ch)>=32)
+    def _append(self, t):
+        self.log_lines.append(t)
+        while len(self.log_lines)>self.max_lines: self.log_lines.pop(0)
+    def get_log(self): return "\n".join(self.log_lines)
 
-    def _append(self, text):
-        self.log_lines.append(text)
-        while len(self.log_lines) > self.max_lines:
-            self.log_lines.pop(0)
-
-    def get_log(self) -> str:
-        return "\n".join(self.log_lines)
-
-    def run_command(self, cmd: str) -> str:
-        cmd = cmd.strip()
+    def run_command(self, cmd):
+        cmd=cmd.strip()
         if not cmd: return self.get_log()
+        # Save to history
+        if not self.cmd_history or self.cmd_history[-1] != cmd:
+            self.cmd_history.append(cmd)
+            if len(self.cmd_history) > self.max_history:
+                self.cmd_history.pop(0)
         with self.lock:
-            if cmd.lower() == "clear":
-                self.log_lines = []
-                return ""
-            if self.master_fd is None:
-                self._append(f"$ {cmd}")
-                self._append("[Error] No shell. Restart Space.")
-                return self.get_log()
-            self._read(0.05)
-            self._append(f"$ {cmd}")
-            try:
-                os.write(self.master_fd, (cmd + "\n").encode())
-            except OSError as e:
-                self._append(f"[Write Error] {e}")
+            if cmd.lower()=="clear": self.log_lines=[]; return ""
+            if cmd.lower()=="history":
+                self._append("Command history:")
+                for i, c in enumerate(self.cmd_history[-20:], 1):
+                    self._append(f"  {i:3d}  {c}")
                 return self.get_log()
-
-            parts = cmd.split()
-            base = parts[0].lower() if parts else ""
-            long = ["pip","pip3","npm","npx","apt-get","apt","git",
-                    "wget","curl","make","cmake","cargo","yarn","conda"]
-            wait = 180 if base in long else (60 if base in ("python","python3","node") else 15)
-
-            chunks = []
-            start = time.time()
-            idle = 0
-            while time.time() - start < wait:
-                c = self._read(0.3)
-                if c:
-                    idle = 0; chunks.append(c)
-                    if "".join(chunks).rstrip().endswith("$"): break
+            if not self.master_fd:
+                self._append(f"$ {cmd}"); self._append("[Error] No shell."); return self.get_log()
+            self._read(0.05); self._append(f"$ {cmd}")
+            try: os.write(self.master_fd,(cmd+"\n").encode())
+            except OSError as e: self._append(f"[Write Error] {e}"); return self.get_log()
+            parts=cmd.split(); base=parts[0].lower() if parts else ""
+            lng=["pip","pip3","npm","npx","apt-get","apt","git","wget","curl","make","cmake","cargo","yarn","conda"]
+            wait=180 if base in lng else(60 if base in("python","python3","node")else 15)
+            chunks=[]; start=time.time(); idle=0
+            while time.time()-start<wait:
+                c=self._read(0.3)
+                if c: idle=0; chunks.append(c)
                 else:
-                    idle += 1
-                    if base not in long and idle >= 3: break
-                    if base in long and idle >= 10: break
-
-            raw = self._clean("".join(chunks))
-            lines = raw.split("\n")
-            filtered = []
-            skip = True
+                    idle+=1
+                    if base not in lng and idle>=3: break
+                    if base in lng and idle>=10: break
+                if chunks and "".join(chunks).rstrip().endswith("$"): break
+            raw=self._clean("".join(chunks)); lines=raw.split("\n"); filtered=[]; skip=True
             for l in lines:
-                s = l.strip()
-                if skip and s == cmd.strip():
-                    skip = False; continue
-                if s in ("$", "$ "): continue
+                s=l.strip()
+                if skip and s==cmd.strip(): skip=False; continue
+                if s in("$","$ "): continue
                 filtered.append(l)
-            result = "\n".join(filtered).strip()
+            result="\n".join(filtered).strip()
             if result: self._append(result)
             return self.get_log()
 
-    def run_editor_code(self, code: str) -> str:
-        with self.lock:
-            self._append("$ python [editor]")
-        tmp = "/tmp/_axon_run.py"
-        try:
-            with open(tmp, "w") as f: f.write(code)
-        except Exception as e:
-            with self.lock: self._append(f"[Error] {e}")
-            return self.get_log()
-        try:
-            env = os.environ.copy()
-            env["DISPLAY"] = DISPLAY_NUM
-            r = subprocess.run([sys.executable, tmp], capture_output=True,
-                               text=True, timeout=30, env=env)
-            with self.lock:
-                if r.stdout.strip(): self._append(r.stdout.rstrip())
-                if r.stderr.strip(): self._append(r.stderr.rstrip())
-                if not r.stdout.strip() and not r.stderr.strip():
-                    self._append("(No output)")
-        except subprocess.TimeoutExpired:
-            with self.lock: self._append("[Timed out 30s]")
-        except Exception as e:
-            with self.lock: self._append(f"[Error] {e}")
-        return self.get_log()
+    def get_history_choices(self):
+        return list(reversed(self.cmd_history[-30:]))
 
     def cleanup(self):
-        if self.pid and self.pid > 0:
+        if self.pid and self.pid>0:
             try: os.kill(self.pid, signal.SIGTERM)
-            except ProcessLookupError: pass
-        if self.master_fd is not None:
+            except: pass
+        if self.master_fd:
             try: os.close(self.master_fd)
-            except OSError: pass
+            except: pass
 
 terminal = PTYTerminal()
 
-# --- Model ---
+# ═══════════════════════════════════════
+# Model
+# ═══════════════════════════════════════
 @lru_cache(maxsize=1)
 def load_model():
-    print("Loading TinyLlama...")
-    t0 = time.time()
+    print("Loading TinyLlama..."); t0=time.time()
     try:
-        tok = AutoTokenizer.from_pretrained(MODEL_NAME)
-        mdl = AutoModelForCausalLM.from_pretrained(
-            MODEL_NAME, dtype=DTYPE, device_map=DEVICE, low_cpu_mem_usage=True)
-        gc = GenerationConfig(max_new_tokens=256, temperature=0.2, top_p=0.95, do_sample=True)
-        pipe = pipeline("text-generation", model=mdl, tokenizer=tok, generation_config=gc)
-        print(f"Loaded in {time.time()-t0:.1f}s")
-        return pipe
-    except Exception as e:
-        print(f"Model error: {e}")
-        return None
-
-def _llm(system, user, max_tok=512):
-    m = load_model()
+        tok=AutoTokenizer.from_pretrained(MODEL_NAME)
+        mdl=AutoModelForCausalLM.from_pretrained(MODEL_NAME,dtype=DTYPE,device_map=DEVICE,low_cpu_mem_usage=True)
+        gc=GenerationConfig(max_new_tokens=256,temperature=0.2,top_p=0.95,do_sample=True)
+        pipe=pipeline("text-generation",model=mdl,tokenizer=tok,generation_config=gc)
+        print(f"Loaded in {time.time()-t0:.1f}s"); return pipe
+    except Exception as e: print(f"Model error: {e}"); return None
+
+def _llm(s,u,mt=512):
+    m=load_model()
     if not m: return "Error: model not loaded"
-    prompt = f"<|system|>{system}</s><|user|>\n{user}\n</s><|assistant|>"
-    try:
-        return m(prompt, max_new_tokens=max_tok)[0]["generated_text"].strip()
-    except Exception as e:
-        return str(e)
-
-def generate_completion(code): return _llm("Complete this Python code. No explanations.", code, 256)
-def explain_code(code): return _llm("Explain this Python code concisely.", code)
-def refactor_code(code): return _llm("Refactor for PEP 8 and best practices.", code)
-def generate_code(p): return _llm(f"Write Python code for: {p}", "")
-
-def create_diff_view(orig, mod):
-    import difflib
-    return "\n".join(difflib.unified_diff(orig.splitlines(), mod.splitlines(), lineterm=""))
-
-# ═══════════════════════════════════════════════════════════
-# THEME — only valid params
-# ═══════════════════════════════════════════════════════════
-
+    try: return m(f"<|system|>{s}</s><|user|>\n{u}\n</s><|assistant|>",max_new_tokens=mt)[0]["generated_text"].strip()
+    except Exception as e: return str(e)
+
+def generate_completion(c): return _llm("Complete this Python code. No explanations.",c,256)
+def explain_code(c): return _llm("Explain this Python code concisely.",c)
+def refactor_code(c): return _llm("Refactor for PEP 8 and best practices.",c)
+def generate_code(p): return _llm(f"Write Python code for: {p}","")
+def create_diff_view(o,m):
+    import difflib; return "\n".join(difflib.unified_diff(o.splitlines(),m.splitlines(),lineterm=""))
+
+GUI_HINTS=["pygame","tkinter","turtle","pyglet","arcade","kivy","wx","Gtk","QApplication",
+           "display.set_mode","mainloop()"]
+def is_gui_code(c): return any(h in c for h in GUI_HINTS)
+
+# ═══════════════════════════════════════
+# Theme + CSS
+# ═══════════════════════════════════════
 theme = gr.themes.Default(
-    font=[gr.themes.GoogleFont("IBM Plex Mono"), "monospace"],
-    primary_hue="cyan",
-    neutral_hue="gray",
+    font=[gr.themes.GoogleFont("IBM Plex Mono"),"monospace"],
+    primary_hue="cyan", neutral_hue="gray",
 ).set(
-    body_background_fill="#080808",
-    body_text_color="#e0e0e0",
-    button_primary_background_fill="#0ff",
-    button_primary_background_fill_hover="#0dd",
+    body_background_fill="#080808", body_text_color="#e0e0e0",
+    button_primary_background_fill="#0ff", button_primary_background_fill_hover="#0dd",
     button_primary_text_color="#000",
-    button_secondary_background_fill="#1a1a1a",
-    button_secondary_background_fill_hover="#2a2a2a",
-    button_secondary_text_color="#0ff",
-    button_secondary_border_color="#0ff4",
-    block_background_fill="#0d0d0d",
-    block_border_color="#1a1a1a",
+    button_secondary_background_fill="#1a1a1a", button_secondary_background_fill_hover="#2a2a2a",
+    button_secondary_text_color="#0ff", button_secondary_border_color="#0ff4",
+    block_background_fill="#0d0d0d", block_border_color="#1a1a1a",
     block_label_text_color="#0f8",
-    input_background_fill="#0a0a0a",
-    input_border_color="#1a3a2a",
-    input_placeholder_color="#0f83",
+    input_background_fill="#0a0a0a", input_border_color="#1a3a2a", input_placeholder_color="#0f83",
 )
 
-# ═══════════════════════════════════════════════════════════
-# CSS
-# ═══════════════════════════════════════════════════════════
-
 css = """
 * { border-radius: 0 !important; }
 .gradio-container { max-width: 100% !important; }
-
-/* ─── Header ─── */
 .axon-header {
     background: linear-gradient(90deg, #080808 0%, #0a1a1a 50%, #080808 100%);
-    border-bottom: 1px solid #0ff3;
-    padding: 12px 20px !important;
-    margin-bottom: 8px;
+    border-bottom: 1px solid #0ff3; padding: 12px 20px !important; margin-bottom: 8px;
 }
 .axon-header h1 {
     font-family: 'IBM Plex Mono', monospace !important;
     background: linear-gradient(90deg, #0ff, #0f8);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    font-size: 1.4em !important;
-    letter-spacing: 3px;
-    margin: 0 !important;
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+    font-size: 1.4em !important; letter-spacing: 3px; margin: 0 !important;
 }
 .axon-header p { color: #0f84 !important; font-size: 0.75em; letter-spacing: 1px; }
-
-/* ─── Terminal ─── */
 .terminal-box textarea {
-    background: #050505 !important;
-    color: #00ff41 !important;
+    background: #050505 !important; color: #00ff41 !important;
     font-family: 'IBM Plex Mono', monospace !important;
-    font-size: 12px !important;
-    line-height: 1.5 !important;
-    border: 1px solid #0f31 !important;
-    text-shadow: 0 0 4px #0f32;
+    font-size: 12px !important; line-height: 1.5 !important;
+    border: 1px solid #0f31 !important; text-shadow: 0 0 4px #0f32;
 }
 .terminal-input input {
-    background: #050505 !important;
-    color: #00ff41 !important;
+    background: #050505 !important; color: #00ff41 !important;
     font-family: 'IBM Plex Mono', monospace !important;
-    border: 1px solid #0f32 !important;
-    font-size: 12px !important;
-    caret-color: #0f8 !important;
+    border: 1px solid #0f32 !important; font-size: 12px !important;
 }
 .terminal-input input::placeholder { color: #0f83 !important; }
 .terminal-input input:focus { border-color: #0ff !important; box-shadow: 0 0 8px #0ff2 !important; }
-
-/* ─── Editor ─── */
 .code-editor textarea, .code-editor .cm-editor {
-    font-family: 'IBM Plex Mono', monospace !important;
-    font-size: 13px !important;
+    font-family: 'IBM Plex Mono', monospace !important; font-size: 13px !important;
 }
-
-/* ─── File explorer ─── */
-.file-explorer { border-right: 1px solid #1a2a2a !important; }
-
-/* ─── Display ─── */
-.display-panel { border: 1px solid #1a2a2a !important; background: #050505 !important; }
-.display-panel img { image-rendering: pixelated; }
-
-/* ─── Toolbar buttons ─── */
 .toolbar-btn {
-    font-size: 0.8em !important;
-    padding: 6px 12px !important;
-    letter-spacing: 0.5px;
-    text-transform: uppercase;
-    font-weight: 600 !important;
-    border: 1px solid transparent !important;
-    transition: all 0.2s ease !important;
+    font-size: 0.8em !important; padding: 6px 12px !important; letter-spacing: 0.5px;
+    text-transform: uppercase; font-weight: 600 !important;
+    border: 1px solid transparent !important; transition: all 0.2s ease !important;
 }
 .toolbar-btn:hover { border-color: #0ff !important; box-shadow: 0 0 12px #0ff2 !important; }
-
-/* ─── Accordion ─── */
 .gr-accordion { border: 1px solid #1a2a2a !important; background: #0a0a0a !important; }
 .gr-accordion > .label-wrap {
-    background: #0d0d0d !important;
-    border-bottom: 1px solid #1a2a2a !important;
-    transition: background 0.2s ease;
+    background: #0d0d0d !important; border-bottom: 1px solid #1a2a2a !important;
 }
 .gr-accordion > .label-wrap:hover { background: #121a1a !important; }
 .gr-accordion > .label-wrap span {
-    color: #0ff !important;
-    font-family: 'IBM Plex Mono', monospace !important;
-    letter-spacing: 1px;
-    font-size: 0.85em;
+    color: #0ff !important; font-family: 'IBM Plex Mono', monospace !important;
+    letter-spacing: 1px; font-size: 0.85em;
 }
-
-/* ─── Tabs ─── */
 .tabs > .tab-nav > button {
     font-family: 'IBM Plex Mono', monospace !important;
     letter-spacing: 1px; font-size: 0.8em; text-transform: uppercase;
     color: #888 !important; border-bottom: 2px solid transparent !important;
-    transition: all 0.2s ease;
 }
 .tabs > .tab-nav > button.selected {
-    color: #0ff !important; border-bottom-color: #0ff !important;
-    text-shadow: 0 0 8px #0ff4;
+    color: #0ff !important; border-bottom-color: #0ff !important; text-shadow: 0 0 8px #0ff4;
 }
-
-/* ─── Status ─── */
 .status-bar {
     background: #0a0a0a !important; border-top: 1px solid #1a2a2a;
     padding: 4px 12px !important; font-size: 11px !important; color: #0f84 !important;
 }
 .status-bar strong { color: #0ff !important; }
-
-/* ─── Scrollbar ─── */
 ::-webkit-scrollbar { width: 6px; height: 6px; }
 ::-webkit-scrollbar-track { background: #0a0a0a; }
 ::-webkit-scrollbar-thumb { background: #0f83; }
-::-webkit-scrollbar-thumb:hover { background: #0ff; }
-
-/* ─── Generic input text color (covers what input_text_color would do) ─── */
 input, textarea, select { color: #0f8 !important; }
+.stop-btn { background: #a00 !important; color: #fff !important; border: none !important; }
+.stop-btn:hover { background: #c00 !important; }
+/* Structure map */
+.structure-box textarea {
+    background: #050505 !important; color: #0ff !important;
+    font-family: 'IBM Plex Mono', monospace !important; font-size: 11px !important;
+}
+/* Snippet code */
+.snippet-code textarea {
+    background: #050505 !important; color: #c8e6c9 !important;
+    font-family: 'IBM Plex Mono', monospace !important; font-size: 12px !important;
+}
+/* Find results */
+.find-results textarea {
+    background: #050505 !important; color: #ffab40 !important;
+    font-family: 'IBM Plex Mono', monospace !important; font-size: 11px !important;
+}
+/* History dropdown */
+.history-dd { font-size: 12px !important; }
 """
 
-# ═══════════════════════════════════════════════════════════
-# UI LAYOUT
-# ═══════════════════════════════════════════════════════════
-
+# ═══════════════════════════════════════
+# UI
+# ═══════════════════════════════════════
 with gr.Blocks(title="Axon Pro — Python AI IDE") as demo:
 
     with gr.Row(elem_classes="axon-header"):
-        gr.Markdown("# ⬡ AXON PRO\n\nPYTHON AI IDE — v3.0")
+        gr.Markdown("# ⬡ AXON PRO\n\nPYTHON AI IDE — v4.0")
 
     with gr.Row(equal_height=False):
 
-        # ── LEFT: FILE EXPLORER ──
-        with gr.Column(scale=1, min_width=180, elem_classes="file-explorer"):
+        # ══ LEFT SIDEBAR ══
+        with gr.Column(scale=1, min_width=200):
+
+            # File Explorer
             with gr.Accordion("📁 EXPLORER", open=True):
-                file_list = gr.Dropdown(
-                    choices=fs.get_all_files(), value=fs.current_file,
-                    label="", interactive=True, container=False)
+                file_list = gr.Dropdown(choices=fs.get_all_files(), value=fs.current_file,
+                                         label="", interactive=True, container=False)
                 new_file_name = gr.Textbox(placeholder="filename.py", label="", container=False)
                 with gr.Row():
-                    new_file_btn = gr.Button("+ NEW", variant="secondary", size="sm",
-                                              elem_classes="toolbar-btn")
-                    save_btn = gr.Button("SAVE", variant="secondary", size="sm",
-                                          elem_classes="toolbar-btn")
-
-        # ── CENTER: EDITOR + TERMINAL ──
+                    new_file_btn = gr.Button("+ NEW", variant="secondary", size="sm", elem_classes="toolbar-btn")
+                    save_btn = gr.Button("SAVE", variant="secondary", size="sm", elem_classes="toolbar-btn")
+                    del_file_btn = gr.Button("✗ DEL", variant="secondary", size="sm", elem_classes="toolbar-btn stop-btn")
+
+            # Code Structure
+            with gr.Accordion("🗺 STRUCTURE", open=True):
+                structure_view = gr.Textbox(
+                    value=analyzer.analyze(fs.get_current_file_content()),
+                    lines=10, max_lines=20, interactive=False,
+                    elem_classes="structure-box", label="", show_label=False)
+
+            # Snippets
+            with gr.Accordion("📋 SNIPPETS", open=False):
+                snippet_list = gr.Dropdown(choices=snippets.get_names(), label="Saved Snippets",
+                                            interactive=True, container=False, elem_classes="history-dd")
+                snippet_search = gr.Textbox(placeholder="Search snippets...", label="", container=False)
+                with gr.Row():
+                    snippet_insert_btn = gr.Button("INSERT", variant="primary", size="sm", elem_classes="toolbar-btn")
+                    snippet_del_btn = gr.Button("DEL", variant="secondary", size="sm", elem_classes="toolbar-btn stop-btn")
+                with gr.Accordion("Save New Snippet", open=False):
+                    snippet_name = gr.Textbox(placeholder="snippet name", label="", container=False)
+                    snippet_tags = gr.Textbox(placeholder="tags: api, util, loop", label="", container=False)
+                    snippet_save_btn = gr.Button("SAVE SNIPPET", variant="primary", size="sm", elem_classes="toolbar-btn")
+                    snippet_status = gr.Markdown("")
+
+        # ══ CENTER ══
         with gr.Column(scale=4):
-            editor = gr.Code(
-                value=fs.get_current_file_content(),
-                label=f"  {fs.current_file}",
-                language="python", lines=22, interactive=True,
-                elem_classes="code-editor")
+            editor = gr.Code(value=fs.get_current_file_content(), label=f"  {fs.current_file}",
+                             language="python", lines=22, interactive=True, elem_classes="code-editor")
 
             with gr.Row():
                 run_btn = gr.Button("▶ RUN", variant="primary", elem_classes="toolbar-btn")
+                run_gui_btn = gr.Button("🖥 GUI", variant="primary", elem_classes="toolbar-btn")
+                stop_gui_btn = gr.Button("■ STOP", variant="secondary", size="sm", elem_classes="toolbar-btn stop-btn")
                 complete_btn = gr.Button("✦ COMPLETE", variant="secondary", elem_classes="toolbar-btn")
                 explain_btn = gr.Button("◈ EXPLAIN", variant="secondary", elem_classes="toolbar-btn")
                 refactor_btn = gr.Button("⟲ REFACTOR", variant="secondary", elem_classes="toolbar-btn")
 
             with gr.Tabs() as bottom_tabs:
+
                 with gr.Tab("⌘ TERMINAL", id="terminal-tab"):
-                    terminal_output = gr.Textbox(
-                        value=terminal.get_log(), lines=10, max_lines=25,
-                        interactive=False, elem_classes="terminal-box",
-                        label="", show_label=False)
+                    terminal_output = gr.Textbox(value=terminal.get_log(), lines=10, max_lines=25,
+                        interactive=False, elem_classes="terminal-box", label="", show_label=False)
                     with gr.Row():
                         terminal_input = gr.Textbox(
-                            placeholder="$ pip install pygame  |  npm i  |  git clone  |  ls ...",
-                            scale=9, container=False, elem_classes="terminal-input")
+                            placeholder="$ pip install pygame | npm i | git clone ...",
+                            scale=8, container=False, elem_classes="terminal-input")
                         terminal_run_btn = gr.Button("⏎", variant="primary", scale=1, min_width=45)
-                    clear_btn = gr.Button("CLEAR", variant="secondary", size="sm",
-                                           elem_classes="toolbar-btn")
+                    with gr.Row():
+                        clear_btn = gr.Button("CLEAR", variant="secondary", size="sm", elem_classes="toolbar-btn")
+                        history_dd = gr.Dropdown(choices=[], label="", container=False,
+                                                  interactive=True, scale=3, elem_classes="history-dd")
+                        history_refresh = gr.Button("↻ HISTORY", variant="secondary", size="sm",
+                                                     elem_classes="toolbar-btn")
+
+                with gr.Tab("🔍 FIND", id="find-tab"):
+                    with gr.Row():
+                        find_query = gr.Textbox(placeholder="Search for...", label="Find", scale=4)
+                        replace_query = gr.Textbox(placeholder="Replace with...", label="Replace", scale=4)
+                        find_case = gr.Checkbox(label="Case sensitive", value=False)
+                    with gr.Row():
+                        find_btn = gr.Button("FIND", variant="primary", size="sm", elem_classes="toolbar-btn")
+                        find_all_btn = gr.Button("FIND ALL FILES", variant="secondary", size="sm", elem_classes="toolbar-btn")
+                        replace_btn = gr.Button("REPLACE ALL", variant="secondary", size="sm", elem_classes="toolbar-btn")
+                    find_results = gr.Textbox(value="", lines=6, interactive=False,
+                                               elem_classes="find-results", label="", show_label=False)
 
                 with gr.Tab("💬 AI CHAT", id="chat-tab"):
                     chat_history = gr.Chatbot(label="", height=250)
                     with gr.Row():
-                        chat_input = gr.Textbox(placeholder="Describe the code you want...",
+                        chat_input = gr.Textbox(placeholder="Describe code you want...",
                                                  scale=8, container=False)
-                        send_btn = gr.Button("GEN", variant="primary", scale=1,
-                                              elem_classes="toolbar-btn")
+                        send_btn = gr.Button("GEN", variant="primary", scale=1, elem_classes="toolbar-btn")
 
                 with gr.Tab("⇄ DIFF", id="diff-tab"):
-                    diff_view = gr.Code(label="AI Changes", language="python",
-                                         interactive=False, lines=15)
+                    diff_view = gr.Code(label="AI Changes", language="python", interactive=False, lines=15)
                     with gr.Row():
-                        apply_btn = gr.Button("✓ APPLY", variant="primary",
-                                               elem_classes="toolbar-btn")
-                        discard_btn = gr.Button("✗ DISCARD", variant="secondary",
-                                                  elem_classes="toolbar-btn")
+                        apply_btn = gr.Button("✓ APPLY", variant="primary", elem_classes="toolbar-btn")
+                        discard_btn = gr.Button("✗ DISCARD", variant="secondary", elem_classes="toolbar-btn")
 
-        # ── RIGHT: DISPLAY ──
+        # ══ RIGHT: DISPLAY ══
         with gr.Column(scale=2, min_width=250):
             with gr.Accordion("🖥 DISPLAY OUTPUT", open=True):
-                gr.Markdown(
-                    "<small style='color:#0f84'>GUI apps (pygame, tkinter, etc.) "
-                    "render here via virtual display</small>")
-                display_image = gr.Image(
-                    label="", type="filepath", interactive=False,
-                    elem_classes="display-panel", height=400)
+                display_image = gr.Image(label="", type="filepath", interactive=False, height=420)
                 with gr.Row():
-                    capture_btn = gr.Button("📸 CAPTURE", variant="secondary", size="sm",
-                                             elem_classes="toolbar-btn")
-                    auto_refresh = gr.Checkbox(label="Auto-refresh", value=False)
-                display_status = gr.Markdown(
-                    f"<small style='color:#0f84'>Xvfb: "
-                    f"{'● running' if vdisplay.is_running else '○ stopped'} "
-                    f"| {SCREEN_W}x{SCREEN_H}</small>")
+                    capture_btn = gr.Button("📸 CAPTURE", variant="secondary", size="sm", elem_classes="toolbar-btn")
+                    auto_capture = gr.Checkbox(label="Auto (2s)", value=False)
+                gui_status = gr.Markdown(
+                    f"<small>Xvfb: {'● ON' if vdisplay.is_running else '○ OFF'} "
+                    f"| {SCREEN_W}x{SCREEN_H} | {gui_mgr.get_status()}</small>")
 
     status_bar = gr.Markdown(
-        f"**AXON PRO v3.0** │ Python {sys.version.split()[0]} │ CPU │ "
-        f"TinyLlama-1.1B │ PTY Shell │ Xvfb {'ON' if vdisplay.is_running else 'OFF'}",
+        f"**AXON PRO v4.0** │ Python {sys.version.split()[0]} │ CPU │ "
+        f"TinyLlama-1.1B │ PTY + Xvfb │ Snippets + Structure + Find",
         elem_classes="status-bar")
 
-    # ── State ──
+    # State
     diff_original_state = gr.State("")
     diff_modified_state = gr.State("")
+    auto_timer = gr.Timer(2, active=False)
+
+    # ═══════════════════════════════════════
+    # HANDLERS
+    # ═══════════════════════════════════════
 
-    # ── Handlers ──
     def update_file(content):
         fs.save_file(content)
+        return analyzer.analyze(content)
 
     def load_file(filename):
         fs.set_current_file(filename)
-        return fs.get_current_file_content(), gr.update(label=f"  {filename}")
+        content = fs.get_current_file_content()
+        return content, gr.update(label=f"  {filename}"), analyzer.analyze(content)
 
     def create_file_fn(name):
-        if name and "." in name:
+        if name and ("." in name or name.endswith("")):
             fs.create_file(name)
+            content = fs.get_current_file_content()
             return (gr.update(choices=fs.get_all_files(), value=name),
-                    fs.get_current_file_content(), gr.update(label=f"  {name}"))
-        return gr.update(choices=fs.get_all_files()), fs.get_current_file_content(), gr.update()
+                    content, gr.update(label=f"  {name}"), analyzer.analyze(content))
+        return gr.update(choices=fs.get_all_files()), fs.get_current_file_content(), gr.update(), gr.update()
+
+    def delete_file_fn():
+        name = fs.current_file
+        if fs.delete_file(name):
+            content = fs.get_current_file_content()
+            return (gr.update(choices=fs.get_all_files(), value=fs.current_file),
+                    content, gr.update(label=f"  {fs.current_file}"),
+                    analyzer.analyze(content))
+        return gr.update(), fs.get_current_file_content(), gr.update(), gr.update()
 
     def terminal_cmd(cmd):
         return terminal.run_command(cmd), ""
 
-    def clear_term():
-        terminal.log_lines = []
-        return ""
-
-    def run_editor(content):
-        return terminal.run_editor_code(content)
+    def clear_term(): terminal.log_lines=[]; return ""
 
-    def complete_fn(content):
-        return content + "\n" + generate_completion(content)
+    def refresh_history():
+        return gr.update(choices=terminal.get_history_choices())
 
-    def explain_fn(content):
-        exp = explain_code(content)
-        fs.save_file(content)
-        mod = f'"""\nEXPLANATION:\n{exp}\n"""\n\n{content}'
-        return create_diff_view(content, mod), content, mod
+    def select_history(cmd):
+        if cmd: return cmd
+        return gr.update()
 
-    def refactor_fn(content):
-        ref = refactor_code(content)
+    # Run with cross-file import support
+    def run_editor(content):
         fs.save_file(content)
-        return create_diff_view(content, ref), content, ref
-
-    def generate_fn(prompt_text, history):
-        gen = generate_code(prompt_text)
-        diff = create_diff_view("", gen)
-        new_h = history + [
-            {"role": "user", "content": prompt_text},
-            {"role": "assistant", "content": "Code generated → check DIFF tab"},
-        ]
-        return diff, "", gen, new_h, ""
-
-    def capture_display():
-        return vdisplay.capture_screenshot()
-
-    # ── Wiring ──
-    editor.change(update_file, editor, None)
-    file_list.change(load_file, file_list, [editor, editor])
-    new_file_btn.click(create_file_fn, new_file_name, [file_list, editor, editor])
-
+        if is_gui_code(content): return run_gui(content)[0]
+        terminal._append("$ python [editor]")
+        tmp = "/tmp/_axon_run.py"
+        with open(tmp, "w") as f: f.write(content)
+        try:
+            env = os.environ.copy()
+            env["DISPLAY"] = DISPLAY_NUM
+            # Add workspace to PYTHONPATH so cross-file imports work
+            env["PYTHONPATH"] = fs._sync_dir + ":" + env.get("PYTHONPATH", "")
+            r = subprocess.run([sys.executable, tmp], capture_output=True, text=True,
+                               timeout=30, env=env, cwd=fs._sync_dir)
+            if r.stdout.strip(): terminal._append(r.stdout.rstrip())
+            if r.stderr.strip(): terminal._append(r.stderr.rstrip())
+            if not r.stdout.strip() and not r.stderr.strip(): terminal._append("(No output)")
+        except subprocess.TimeoutExpired: terminal._append("[Timed out 30s]")
+        except Exception as e: terminal._append(f"[Error] {e}")
+        return terminal.get_log()
+
+    def run_gui(content):
+        fs.save_file(content); msg=gui_mgr.launch(content); terminal._append(msg)
+        time.sleep(1.5); ss=vdisplay.capture()
+        st=f"<small>Xvfb: ● ON | {SCREEN_W}x{SCREEN_H} | {gui_mgr.get_status()}</small>"
+        return terminal.get_log(), ss, st
+
+    def stop_gui():
+        msg=gui_mgr.stop(); terminal._append(msg)
+        st=f"<small>Xvfb: {'● ON' if vdisplay.is_running else '○ OFF'} | {SCREEN_W}x{SCREEN_H} | {gui_mgr.get_status()}</small>"
+        return terminal.get_log(), st
+
+    def capture_display(): return vdisplay.capture()
+    def auto_capture_tick():
+        if gui_mgr.is_running: return vdisplay.capture()
+        return gr.update()
+    def toggle_auto(c): return gr.Timer(2, active=c)
+
+    def complete_fn(c):
+        result = c+"\n"+generate_completion(c)
+        return result, analyzer.analyze(result)
+    def explain_fn(c):
+        e=explain_code(c); fs.save_file(c); m=f'"""\nEXPLANATION:\n{e}\n"""\n\n{c}'
+        return create_diff_view(c,m),c,m
+    def refactor_fn(c):
+        r=refactor_code(c); fs.save_file(c); return create_diff_view(c,r),c,r
+    def generate_fn(p,h):
+        g=generate_code(p); d=create_diff_view("",g)
+        nh=h+[{"role":"user","content":p},{"role":"assistant","content":"Code generated → DIFF tab"}]
+        return d,"",g,nh,""
+
+    # Snippets
+    def save_snippet(name, tags, editor_content):
+        msg = snippets.add(name, editor_content, tags)
+        return msg, gr.update(choices=snippets.get_names())
+
+    def insert_snippet(name):
+        code = snippets.get(name)
+        return code if code else gr.update()
+
+    def delete_snippet(name):
+        msg = snippets.delete(name)
+        return msg, gr.update(choices=snippets.get_names())
+
+    def search_snippets(query):
+        results = snippets.search(query)
+        return gr.update(choices=results)
+
+    # Find & Replace
+    def do_find(code, query, case):
+        return finder.find_in_file(code, query, case)
+
+    def do_find_all(query):
+        return finder.find_in_all_files(fs.files, query)
+
+    def do_replace(code, find_q, replace_q, case):
+        new_code, msg = finder.replace_in_file(code, find_q, replace_q, case)
+        fs.save_file(new_code)
+        return new_code, msg, analyzer.analyze(new_code)
+
+    # ═══════════════════════════════════════
+    # WIRING
+    # ═══════════════════════════════════════
+
+    # File operations
+    editor.change(update_file, editor, structure_view)
+    file_list.change(load_file, file_list, [editor, editor, structure_view])
+    new_file_btn.click(create_file_fn, new_file_name, [file_list, editor, editor, structure_view])
+    del_file_btn.click(delete_file_fn, None, [file_list, editor, editor, structure_view])
+
+    # Terminal
     terminal_input.submit(terminal_cmd, terminal_input, [terminal_output, terminal_input])
     terminal_run_btn.click(terminal_cmd, terminal_input, [terminal_output, terminal_input])
     clear_btn.click(clear_term, None, terminal_output)
+    history_refresh.click(refresh_history, None, history_dd)
+    history_dd.change(select_history, history_dd, terminal_input)
 
+    # Run
     run_btn.click(run_editor, editor, terminal_output)
-    complete_btn.click(complete_fn, editor, editor)
+    run_gui_btn.click(run_gui, editor, [terminal_output, display_image, gui_status])
+    stop_gui_btn.click(stop_gui, None, [terminal_output, gui_status])
 
-    explain_btn.click(explain_fn, editor,
-        [diff_view, diff_original_state, diff_modified_state]
+    # AI
+    complete_btn.click(complete_fn, editor, [editor, structure_view])
+    explain_btn.click(explain_fn, editor, [diff_view, diff_original_state, diff_modified_state]
     ).then(lambda: gr.Tabs(selected="diff-tab"), None, bottom_tabs)
-
-    refactor_btn.click(refactor_fn, editor,
-        [diff_view, diff_original_state, diff_modified_state]
+    refactor_btn.click(refactor_fn, editor, [diff_view, diff_original_state, diff_modified_state]
     ).then(lambda: gr.Tabs(selected="diff-tab"), None, bottom_tabs)
-
     chat_input.submit(generate_fn, [chat_input, chat_history],
         [diff_view, diff_original_state, diff_modified_state, chat_history, chat_input]
     ).then(lambda: gr.Tabs(selected="diff-tab"), None, bottom_tabs)
-
     send_btn.click(generate_fn, [chat_input, chat_history],
         [diff_view, diff_original_state, diff_modified_state, chat_history, chat_input]
     ).then(lambda: gr.Tabs(selected="diff-tab"), None, bottom_tabs)
 
-    apply_btn.click(lambda mod: mod, diff_modified_state, editor
+    # Diff
+    apply_btn.click(lambda mod: (mod, analyzer.analyze(mod)), diff_modified_state, [editor, structure_view]
     ).then(lambda: gr.Tabs(selected="terminal-tab"), None, bottom_tabs)
-
-    discard_btn.click(lambda: gr.update(), None, editor
+    discard_btn.click(lambda: (gr.update(), gr.update()), None, [editor, structure_view]
     ).then(lambda: gr.Tabs(selected="terminal-tab"), None, bottom_tabs)
 
+    # Snippets
+    snippet_save_btn.click(save_snippet, [snippet_name, snippet_tags, editor], [snippet_status, snippet_list])
+    snippet_insert_btn.click(insert_snippet, snippet_list, editor)
+    snippet_del_btn.click(delete_snippet, snippet_list, [snippet_status, snippet_list])
+    snippet_search.change(search_snippets, snippet_search, snippet_list)
+
+    # Find & Replace
+    find_btn.click(do_find, [editor, find_query, find_case], find_results)
+    find_all_btn.click(do_find_all, find_query, find_results)
+    replace_btn.click(do_replace, [editor, find_query, replace_query, find_case],
+                      [editor, find_results, structure_view])
+
+    # Display
     capture_btn.click(capture_display, None, display_image)
+    auto_capture.change(toggle_auto, auto_capture, auto_timer)
+    auto_timer.tick(auto_capture_tick, None, display_image)
 
 if __name__ == "__main__":
     import atexit
     atexit.register(terminal.cleanup)
+    atexit.register(gui_mgr.stop)
     atexit.register(vdisplay.cleanup)
     demo.launch(server_name="0.0.0.0", server_port=7860,
                 theme=theme, css=css, ssr_mode=False)