Delete app.py

app.py

@@ -1,722 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-open_image_ai_hivemind.py
-Single-file, open-source suite:
-- Image AI (offline-capable) with bilingual GUI (FA/EN)
-- Code Learner Worm (self-improving patcher with tests/linters)
-- Open-Source Harvester (local+URL indexing and modular plug-in loader)
-No paid APIs; no accounts; uses local and open tools only.
-
-Run:
-  python open_image_ai_hivemind.py
-
-Build onefile (optional):
-  python -m pip install pyinstaller
-  pyinstaller --onefile open_image_ai_hivemind.py
-"""
-
-import os
-import sys
-import json
-import time
-import math
-import hashlib
-import random
-import threading
-import subprocess
-import shutil
-import re
-from datetime import datetime
-from pathlib import Path
-import importlib.util
-
-# Lazy installer (open-source libs only)
-def _lazy_install(pkg):
-    try:
-        __import__(pkg)
-    except ImportError:
-        os.system(f"{sys.executable} -m pip install --quiet {pkg}")
-
-for pkg in ("torch", "diffusers", "accelerate", "safetensors", "Pillow"):
-    _lazy_install(pkg)
-
-import tkinter as tk
-from tkinter import ttk, filedialog, messagebox
-import torch
-from PIL import Image, ImageOps, ImageFilter, ImageDraw
-from diffusers import StableDiffusionPipeline, DiffusionPipeline
-
-# ---------------------------
-# Paths & Directories
-# ---------------------------
-APP_NAME = "Open Image AI Hivemind"
-ROOT_DIR = Path(__file__).parent.resolve()
-OUTPUT_DIR = Path(os.environ.get("OIA_OUT", ROOT_DIR / "outputs")).resolve()
-META_DIR = OUTPUT_DIR / "meta"
-CACHE_DIR = OUTPUT_DIR / "cache"
-TMP_DIR = OUTPUT_DIR / "tmp"
-PLUGINS_DIR = ROOT_DIR / "plugins"
-HARVEST_DIR = ROOT_DIR / "harvest"
-for d in (OUTPUT_DIR, META_DIR, CACHE_DIR, TMP_DIR, PLUGINS_DIR, HARVEST_DIR):
-    d.mkdir(parents=True, exist_ok=True)
-
-# ---------------------------
-# Image AI Config
-# ---------------------------
-DEFAULT_STEPS = int(os.environ.get("OIA_STEPS", "30"))
-DEFAULT_GUIDANCE = float(os.environ.get("OIA_GUIDANCE", "7.5"))
-MAX_QUEUE = int(os.environ.get("OIA_MAX_QUEUE", "64"))
-SEED_AUTOMATIC = -1
-
-OPEN_MODELS = {
-    "SDXL (base)": "stabilityai/stable-diffusion-xl-base-1.0",
-    "SD 1.5 (classic)": "runwayml/stable-diffusion-v1-5",
-    # Add more open models if diffusers supports them
-    # "Stable Cascade": "stabilityai/stable-cascade",
-    # "OpenJourney": "prompthero/openjourney-v4",
-}
-
-# ---------------------------
-# Prompt utilities
-# ---------------------------
-OPTICAL_ILLUSION_PRESETS = [
-    "high-contrast black and white optical illusion, impossible geometry, Penrose stairs, concentric lines, parallax shifts",
-    "moiré patterns, nested grids, Escher-inspired recursion, tilt-shift depth cues, perspective ambiguity",
-    "rotational symmetry, non-Euclidean corridor, variable line thickness, alternating diagonals, dizzying parallax",
-    "spiral tunnels, zigzag pathways, impossible cube, nested frames, sharp edges, stark contrast",
-]
-
-WEIGHTS = [
-    "hyper-detailed", "vector-sharp edges", "ultra high resolution",
-    "minimal noise", "geometric precision", "dynamic parallax",
-    "photorealistic lighting"
-]
-
-MODS = [
-    "isometric view", "45-degree inclination", "multi-angle perception",
-    "viewer-dependent illusion", "top-down perspective"
-]
-
-def vary_prompt(base: str) -> str:
-    extra = ", ".join(random.sample(OPTICAL_ILLUSION_PRESETS, k=random.randint(1, 3)))
-    hint = ", ".join(random.sample(WEIGHTS, k=random.randint(2, 4)))
-    mod = random.choice(MODS)
-    return f"{base}, {extra}, {hint}, {mod}"
-
-def prompt_hash(p: str) -> str:
-    return hashlib.sha256(p.encode("utf-8")).hexdigest()[:16]
-
-# ---------------------------
-# Cache & Meta
-# ---------------------------
-def cache_path_for(prompt: str) -> Path:
-    return CACHE_DIR / f"{prompt_hash(prompt)}.png"
-
-def cached(prompt: str) -> Path | None:
-    p = cache_path_for(prompt)
-    return p if p.exists() else None
-
-def write_meta(meta: dict, fname: Path):
-    meta["timestamp"] = datetime.utcnow().isoformat()
-    with open(META_DIR / (fname.stem + ".json"), "w", encoding="utf-8") as f:
-        json.dump(meta, f, ensure_ascii=False, indent=2)
-
-# ---------------------------
-# Anti-error (Image AI)
-# ---------------------------
-class AntiError:
-    def __init__(self):
-        self.fail_count = 0
-        self.circuit_open = False
-        self.warned_no_model = False
-
-    def reset(self):
-        self.fail_count = 0
-        self.circuit_open = False
-
-    def bump(self):
-        self.fail_count += 1
-        if self.fail_count >= 5:
-            self.circuit_open = True
-
-    def warn_model_missing(self):
-        if not self.warned_no_model:
-            print("[!] No model loaded. Using local illusion fallback.")
-            self.warned_no_model = True
-
-anti = AntiError()
-
-# ---------------------------
-# Local illusion generator
-# ---------------------------
-def local_illusion(size=1024) -> Image.Image:
-    img = Image.new("RGB", (size, size), "white")
-    draw = ImageDraw.Draw(img)
-    step = 6
-    for r in range(24, size//2, step):
-        val = 0 if (r//step) % 2 == 0 else 255
-        for x in range(size):
-            if abs(x - size//2) == r:
-                draw.line([(x, 0), (x, size)], fill=(val, val, val))
-        for y in range(size):
-            if abs(y - size//2) == r:
-                draw.line([(0, y), (size, y)], fill=(val, val, val))
-    hatch = Image.new("L", (size, size), color=255)
-    hpx = hatch.load()
-    for x in range(size):
-        for y in range(size):
-            if (x + y) % 18 == 0:
-                hpx[x, y] = 0
-    merged = Image.merge("RGB", (ImageOps.autocontrast(hatch), ImageOps.autocontrast(hatch), ImageOps.autocontrast(hatch)))
-    merged = Image.blend(img, merged, 0.35).filter(ImageFilter.SHARPEN)
-    merged = merged.rotate(random.choice([4, -6, 8, -10]), resample=Image.BICUBIC, expand=False)
-    return merged
-
-# ---------------------------
-# Post-process filters
-# ---------------------------
-POST_MODES = [
-    "illusion_boost", "bw_high", "moire_mix", "invert", "edge_halo",
-    "soft_glow", "posterize4", "contrast_max", "rotate_slight", "grain_fine"
-]
-
-def post_process(img: Image.Image, mode: str) -> Image.Image:
-    if mode == "illusion_boost":
-        out = ImageOps.autocontrast(img).filter(ImageFilter.UnsharpMask(radius=2, percent=180, threshold=3))
-    elif mode == "bw_high":
-        out = ImageOps.autocontrast(ImageOps.grayscale(img)).convert("RGB")
-    elif mode == "moire_mix":
-        out = ImageOps.posterize(img.filter(ImageFilter.DETAIL).filter(ImageFilter.SHARPEN), bits=4)
-    elif mode == "invert":
-        out = ImageOps.invert(img)
-    elif mode == "edge_halo":
-        out = img.filter(ImageFilter.UnsharpMask(radius=3, percent=240, threshold=2))
-    elif mode == "soft_glow":
-        blur = img.filter(ImageFilter.GaussianBlur(radius=2))
-        out = Image.blend(img, blur, alpha=0.3)
-    elif mode == "posterize4":
-        out = ImageOps.posterize(img, bits=4)
-    elif mode == "contrast_max":
-        out = ImageOps.autocontrast(img)
-    elif mode == "rotate_slight":
-        out = img.rotate(random.choice([-3, 3, -2, 2]), resample=Image.BICUBIC, expand=False)
-    elif mode == "grain_fine":
-        out = img.filter(ImageFilter.SMOOTH_MORE)
-    else:
-        out = img
-    return out
-
-# ---------------------------
-# Model Hub
-# ---------------------------
-class ModelHub:
-    def __init__(self):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.pipe = None
-        self.model_id = None
-
-    def load(self, model_id: str, fp16=True):
-        self.model_id = model_id
-        dtype = torch.float16 if (fp16 and self.device == "cuda") else torch.float32
-        try:
-            if "stable-diffusion-xl" in model_id:
-                self.pipe = DiffusionPipeline.from_pretrained(model_id, torch_dtype=dtype, variant="fp16" if dtype==torch.float16 else None)
-            else:
-                self.pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=dtype)
-            self.pipe = self.pipe.to(self.device)
-            if self.device == "cuda":
-                self.pipe.enable_attention_slicing()
-            anti.reset()
-            return True
-        except Exception as e:
-            print(f"[!] Model load error: {e}")
-            self.pipe = None
-            return False
-
-    def generate(self, prompt: str, steps: int, guidance: float, seed: int | None, height=768, width=768) -> Image.Image:
-        if self.pipe is None:
-            anti.warn_model_missing()
-            return local_illusion(size=min(height, width))
-        generator = torch.Generator(device=self.device)
-        if seed is not None and seed >= 0:
-            generator = generator.manual_seed(seed)
-        try:
-            out = self.pipe(prompt, height=height, width=width, num_inference_steps=steps, guidance_scale=guidance, generator=generator)
-            return out.images[0]
-        except Exception as e:
-            print(f"[!] Generate error: {e}")
-            anti.bump()
-            return local_illusion(size=min(height, width))
-
-hub = ModelHub()
-
-# ---------------------------
-# Orchestrator (Image Queue)
-# ---------------------------
-class Orchestrator:
-    def __init__(self):
-        self.queue = []
-        self.running = False
-
-    def enqueue(self, prompt, count, vary, steps, guidance, seed, size, post_mode):
-        for _ in range(count):
-            if len(self.queue) >= MAX_QUEUE:
-                break
-            self.queue.append({
-                "prompt": prompt,
-                "vary": vary,
-                "steps": steps,
-                "guidance": guidance,
-                "seed": seed,
-                "size": size,
-                "post_mode": post_mode
-            })
-
-    def _do_item(self, item):
-        p = item["prompt"]
-        if item["vary"]:
-            p = vary_prompt(p)
-        cp = cached(p)
-        if cp:
-            img = Image.open(cp).convert("RGB")
-        else:
-            img = hub.generate(p, item["steps"], item["guidance"], item["seed"], item["size"], item["size"])
-            try:
-                cache_path = cache_path_for(p)
-                img.save(cache_path, "PNG", optimize=True)
-            except Exception as e:
-                print(f"[!] Cache save error: {e}")
-        if item["post_mode"]:
-            img = post_process(img, item["post_mode"])
-        fname = OUTPUT_DIR / f"{datetime.utcnow().strftime('%Y%m%d_%H%M%S_%f')}_{prompt_hash(p)}.png"
-        img.save(fname, "PNG", optimize=True)
-        write_meta({"prompt": p, "model": hub.model_id or "local_illusion", "post_mode": item["post_mode"]}, fname)
-        return fname
-
-    def run(self, on_log):
-        if self.running:
-            return
-        self.running = True
-        try:
-            while self.queue:
-                item = self.queue.pop(0)
-                try:
-                    path = self._do_item(item)
-                    on_log(f"    -> Saved: {path}")
-                except Exception as e:
-                    on_log(f"    x Failed: {e}")
-        finally:
-            self.running = False
-
-orch = Orchestrator()
-
-# ---------------------------
-# Code Learner Worm
-# ---------------------------
-class CodeLearner:
-    """
-    A self-improving patcher:
-    - Scans this file and plugins for improvement opportunities.
-    - Runs tests/health checks (syntax, import, basic run).
-    - Generates small patches (safe transformations) and applies if all checks pass.
-    - Keeps history in harvest/patches.json.
-    """
-    def __init__(self, root: Path):
-        self.root = root
-        self.target_file = root / Path(__file__).name
-        self.patches_file = HARVEST_DIR / "patches.json"
-        if not self.patches_file.exists():
-            self._write_json(self.patches_file, [])
-
-    def _read(self, p: Path) -> str:
-        return p.read_text(encoding="utf-8")
-
-    def _write(self, p: Path, s: str):
-        p.write_text(s, encoding="utf-8")
-
-    def _write_json(self, p: Path, obj):
-        with open(p, "w", encoding="utf-8") as f:
-            json.dump(obj, f, ensure_ascii=False, indent=2)
-
-    def _record_patch(self, summary, diff_preview):
-        data = json.loads(self.patches_file.read_text(encoding="utf-8"))
-        data.append({
-            "time": datetime.utcnow().isoformat(),
-            "summary": summary,
-            "preview": diff_preview[:1000]
-        })
-        self._write_json(self.patches_file, data)
-
-    def _basic_health(self) -> bool:
-        # Syntax check by importing this file as a module
-        try:
-            spec = importlib.util.spec_from_file_location("oiah", self.target_file)
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)  # type: ignore
-            return True
-        except Exception as e:
-            print(f"[WORM] Health check failed: {e}")
-            return False
-
-    def _safe_transforms(self, code: str) -> list[tuple[str, str]]:
-        transforms = []
-        # Example 1: ensure UI theme fallback exists (idempotent)
-        if "style.theme_use(\"clam\")" not in code:
-            transforms.append(("Add clam theme fallback",
-                               "style = ttk.Style()\n    try:\n        style.theme_use(\"clam\")\n    except Exception:\n        pass\n"))
-        # Example 2: add plugin loader hook if missing
-        if "load_plugins()" not in code:
-            transforms.append(("Add plugin loader hook", "load_plugins()\n"))
-        # Example 3: add Open Models expansion comment marker
-        if "# Add more open models" not in code:
-            transforms.append(("Add models marker", "# Add more open models if diffusers supports them\n"))
-        return transforms
-
-    def _apply_transform(self, original: str, transform_snippet: str) -> str:
-        # Simple heuristic: insert before main()
-        insertion_point = original.rfind("def main():")
-        if insertion_point == -1:
-            return original + "\n" + transform_snippet
-        head = original[:insertion_point]
-        tail = original[insertion_point:]
-        return head + "\n" + transform_snippet + "\n" + tail
-
-    def improve(self, on_log):
-        code = self._read(self.target_file)
-        transforms = self._safe_transforms(code)
-        if not transforms:
-            on_log("[WORM] Nothing to improve (idempotent).")
-            return
-        for summary, snippet in transforms:
-            on_log(f"[WORM] Proposing patch: {summary}")
-            patched = self._apply_transform(code, snippet)
-            backup = self.target_file.with_suffix(".bak")
-            shutil.copyfile(self.target_file, backup)
-            self._write(self.target_file, patched)
-            if self._basic_health():
-                diff_preview = self._diff_preview(code, patched)
-                self._record_patch(summary, diff_preview)
-                on_log(f"[WORM] Patch applied: {summary}")
-                code = patched  # continue from patched version
-            else:
-                on_log(f"[WORM] Patch reverted: {summary}")
-                shutil.copyfile(backup, self.target_file)
-            backup.unlink(missing_ok=True)
-
-    def _diff_preview(self, old: str, new: str) -> str:
-        import difflib
-        return "\n".join(difflib.unified_diff(old.splitlines(), new.splitlines(), lineterm=""))
-
-# ---------------------------
-# Open-Source Harvester
-# ---------------------------
-class Harvester:
-    """
-    Finds and connects open resources:
-    - Index local folders and user-provided URLs (git/http) without any paid APIs.
-    - Clones git repos and downloads raw files into harvest/.
-    - Loads plugin modules from plugins/ to extend functionality.
-    """
-    def __init__(self, harvest_dir: Path, plugins_dir: Path):
-        self.harvest_dir = harvest_dir
-        self.plugins_dir = plugins_dir
-
-    def index_local(self, paths: list[Path]) -> list[Path]:
-        indexed = []
-        for p in paths:
-            if p.exists():
-                for root, dirs, files in os.walk(p):
-                    for f in files:
-                        indexed.append(Path(root) / f)
-        (self.harvest_dir / "index.json").write_text(json.dumps([str(x) for x in indexed], indent=2), encoding="utf-8")
-        return indexed
-
-    def clone_git(self, url: str, name_hint: str | None = None) -> Path | None:
-        # Requires git installed; no accounts; open repos only
-        out = self.harvest_dir / (name_hint or f"repo_{prompt_hash(url)}")
-        try:
-            subprocess.check_call(["git", "clone", "--depth", "1", url, str(out)])
-            return out
-        except Exception as e:
-            print(f"[HARVEST] Git clone failed: {e}")
-            return None
-
-    def http_fetch(self, url: str, name: str | None = None) -> Path | None:
-        # Simple open HTTP fetch (no paid API); may need allowlist
-        import urllib.request
-        try:
-            data = urllib.request.urlopen(url, timeout=30).read()
-            target = self.harvest_dir / (name or f"file_{prompt_hash(url)}")
-            target.write_bytes(data)
-            return target
-        except Exception as e:
-            print(f"[HARVEST] HTTP fetch failed: {e}")
-            return None
-
-    def load_plugins(self) -> list[str]:
-        loaded = []
-        for py in self.plugins_dir.glob("*.py"):
-            try:
-                spec = importlib.util.spec_from_file_location(py.stem, py)
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)  # type: ignore
-                loaded.append(py.stem)
-            except Exception as e:
-                print(f"[PLUGINS] Failed to load {py}: {e}")
-        (self.harvest_dir / "plugins_loaded.json").write_text(json.dumps(loaded, indent=2), encoding="utf-8")
-        return loaded
-
-harvester = Harvester(HARVEST_DIR, PLUGINS_DIR)
-
-def load_plugins():
-    harvester.load_plugins()
-
-# ---------------------------
-# GUI (Bilingual)
-# ---------------------------
-class App:
-    def __init__(self, root):
-        self.root = root
-        root.title(APP_NAME)
-        root.geometry("1080x780")
-
-        self.lang = tk.StringVar(value="FA")
-        self.prompt = tk.StringVar()
-        self.count = tk.IntVar(value=3)
-        self.vary = tk.BooleanVar(value=True)
-        self.steps = tk.IntVar(value=DEFAULT_STEPS)
-        self.guidance = tk.DoubleVar(value=DEFAULT_GUIDANCE)
-        self.seed = tk.IntVar(value=SEED_AUTOMATIC)
-        self.size = tk.IntVar(value=768)
-        self.post_mode = tk.StringVar(value="")
-        self.model_choice = tk.StringVar(value=list(OPEN_MODELS.keys())[0])
-
-        # Harvester inputs
-        self.harvest_url = tk.StringVar()
-        self.harvest_local = tk.StringVar()
-
-        self._build_ui()
-        self._set_texts()
-        self._log_header()
-
-    def _build_ui(self):
-        top = ttk.Frame(self.root)
-        top.pack(fill="x", padx=10, pady=10)
-        ttk.Label(top, text="Language / زبان").pack(side="left")
-        ttk.Combobox(top, textvariable=self.lang, values=["FA", "EN"], width=5, state="readonly").pack(side="left", padx=8)
-        ttk.Button(top, text="Apply/اعمال", command=self._set_texts).pack(side="left", padx=8)
-
-        model_frame = ttk.LabelFrame(self.root, text="Model / مدل")
-        model_frame.pack(fill="x", padx=10, pady=6)
-        ttk.Label(model_frame, text="Select model:").grid(row=0, column=0, sticky="w", padx=6, pady=6)
-        ttk.Combobox(model_frame, textvariable=self.model_choice, values=list(OPEN_MODELS.keys()), width=28, state="readonly").grid(row=0, column=1, sticky="w", padx=6, pady=6)
-        ttk.Button(model_frame, text="Load model", command=self.load_model).grid(row=0, column=2, padx=6, pady=6)
-
-        mid = ttk.LabelFrame(self.root, text="Controls / کنترل‌ها")
-        mid.pack(fill="x", padx=10, pady=6)
-        self.lbl_prompt = ttk.Label(mid, text="")
-        self.lbl_prompt.grid(row=0, column=0, sticky="w", padx=6, pady=6)
-        ttk.Entry(mid, textvariable=self.prompt, width=72).grid(row=0, column=1, sticky="we", padx=6, pady=6)
-
-        self.lbl_count = ttk.Label(mid, text="")
-        self.lbl_count.grid(row=1, column=0, sticky="w", padx=6, pady=6)
-        ttk.Spinbox(mid, from_=1, to=50, textvariable=self.count, width=6).grid(row=1, column=1, sticky="w", padx=6, pady=6)
-
-        self.lbl_vary = ttk.Label(mid, text="")
-        self.lbl_vary.grid(row=2, column=0, sticky="w", padx=6, pady=6)
-        ttk.Checkbutton(mid, text="", variable=self.vary).grid(row=2, column=1, sticky="w", padx=6, pady=6)
-
-        self.lbl_steps = ttk.Label(mid, text="")
-        self.lbl_steps.grid(row=3, column=0, sticky="w", padx=6, pady=6)
-        ttk.Spinbox(mid, from_=5, to=100, textvariable=self.steps, width=6).grid(row=3, column=1, sticky="w", padx=6, pady=6)
-
-        self.lbl_guidance = ttk.Label(mid, text="")
-        self.lbl_guidance.grid(row=4, column=0, sticky="w", padx=6, pady=6)
-        ttk.Spinbox(mid, from_=0.0, to=20.0, increment=0.5, textvariable=self.guidance, width=6).grid(row=4, column=1, sticky="w", padx=6, pady=6)
-
-        self.lbl_seed = ttk.Label(mid, text="")
-        self.lbl_seed.grid(row=5, column=0, sticky="w", padx=6, pady=6)
-        ttk.Spinbox(mid, from_=-1, to=2**31-1, textvariable=self.seed, width=12).grid(row=5, column=1, sticky="w", padx=6, pady=6)
-
-        self.lbl_size = ttk.Label(mid, text="")
-        self.lbl_size.grid(row=6, column=0, sticky="w", padx=6, pady=6)
-        ttk.Spinbox(mid, from_=256, to=1024, increment=64, textvariable=self.size, width=6).grid(row=6, column=1, sticky="w", padx=6, pady=6)
-
-        self.lbl_pp = ttk.Label(mid, text="")
-        self.lbl_pp.grid(row=7, column=0, sticky="w", padx=6, pady=6)
-        ttk.Combobox(mid, textvariable=self.post_mode, values=[""] + POST_MODES, width=20, state="readonly").grid(row=7, column=1, sticky="w", padx=6, pady=6)
-
-        btns = ttk.Frame(mid)
-        btns.grid(row=8, column=0, columnspan=2, sticky="we", padx=6, pady=6)
-        self.btn_run = ttk.Button(btns, text="", command=self.run_queue)
-        self.btn_run.pack(side="left", padx=6)
-        ttk.Button(btns, text="Open outputs", command=self.open_outputs).pack(side="left", padx=6)
-        ttk.Button(btns, text="Illusion offline test", command=self.make_offline_illusion).pack(side="left", padx=6)
-
-        # Harvester panel
-        hframe = ttk.LabelFrame(self.root, text="Open-Source Harvester")
-        hframe.pack(fill="x", padx=10, pady=10)
-        ttk.Label(hframe, text="Git/HTTP URL:").grid(row=0, column=0, sticky="w", padx=6, pady=6)
-        ttk.Entry(hframe, textvariable=self.harvest_url, width=60).grid(row=0, column=1, sticky="we", padx=6, pady=6)
-        ttk.Button(hframe, text="Clone/Fetch", command=self.harvest_fetch).grid(row=0, column=2, padx=6, pady=6)
-
-        ttk.Label(hframe, text="Local path to index:").grid(row=1, column=0, sticky="w", padx=6, pady=6)
-        ttk.Entry(hframe, textvariable=self.harvest_local, width=60).grid(row=1, column=1, sticky="we", padx=6, pady=6)
-        ttk.Button(hframe, text="Index", command=self.harvest_index).grid(row=1, column=2, padx=6, pady=6)
-
-        # Learner panel
-        lframe = ttk.LabelFrame(self.root, text="Code Learner Worm")
-        lframe.pack(fill="x", padx=10, pady=10)
-        ttk.Button(lframe, text="Analyze & Improve", command=self.run_worm).grid(row=0, column=0, padx=6, pady=6)
-        ttk.Button(lframe, text="Load plugins", command=load_plugins).grid(row=0, column=1, padx=6, pady=6)
-
-        self.log = tk.Text(self.root, height=18, wrap="word")
-        self.log.pack(fill="both", expand=True, padx=10, pady=10)
-
-        status_bar = ttk.Frame(self.root)
-        status_bar.pack(fill="x", padx=10, pady=5)
-        self.status = tk.StringVar(value="Ready")
-        self.lbl_status = ttk.Label(status_bar, textvariable=self.status)
-        self.lbl_status.pack(side="left")
-
-    def _set_texts(self):
-        if self.lang.get() == "FA":
-            self.lbl_prompt.config(text="متن راهنمای تصویر (پرومپت):")
-            self.lbl_count.config(text="تعداد تولید:")
-            self.lbl_vary.config(text="تنوع‌دهی خودکار پرومپت:")
-            self.lbl_steps.config(text="تعداد گام‌ها:")
-            self.lbl_guidance.config(text="راهنمایی (Guidance):")
-            self.lbl_seed.config(text="Seed (برای تکرارپذیری، -1 خودکار):")
-            self.lbl_size.config(text="اندازه (پیکسل مربع):")
-            self.lbl_pp.config(text="پس‌پردازش:")
-            self.btn_run.config(text="شروع تولید")
-            self.root.title(f"{APP_NAME} - رابط فارسی")
-        else:
-            self.lbl_prompt.config(text="Image prompt:")
-            self.lbl_count.config(text="Count:")
-            self.lbl_vary.config(text="Auto prompt variation:")
-            self.lbl_steps.config(text="Steps:")
-            self.lbl_guidance.config(text="Guidance:")
-            self.lbl_seed.config(text="Seed (-1 automatic):")
-            self.lbl_size.config(text="Size (square px):")
-            self.lbl_pp.config(text="Post-process:")
-            self.btn_run.config(text="Start")
-            self.root.title(f"{APP_NAME} - English UI")
-
-    def _log_header(self):
-        self.append_log(f"[{APP_NAME}] Ready. Select a model, enter prompt, and start.")
-
-    def append_log(self, s):
-        self.log.insert("end", s + "\n")
-        self.log.see("end")
-
-    def open_outputs(self):
-        path = str(OUTPUT_DIR)
-        try:
-            if os.name == "nt":
-                os.startfile(path)
-            elif sys.platform == "darwin":
-                os.system(f'open "{path}"')
-            else:
-                os.system(f'xdg-open "{path}"')
-        except Exception:
-            messagebox.showinfo("Info", f"Outputs at: {path}")
-
-    def load_model(self):
-        name = self.model_choice.get()
-        model_id = OPEN_MODELS.get(name)
-        if not model_id:
-            messagebox.showerror("Error", "Model id not found.")
-            return
-        self.status.set("Loading model...")
-        self.append_log(f"[+] Loading: {name} -> {model_id}")
-        self.root.update_idletasks()
-        ok = hub.load(model_id, fp16=True)
-        if ok:
-            self.status.set("Model loaded")
-            self.append_log("    -> Model ready.")
-        else:
-            self.status.set("Model load failed (fallback active)")
-            self.append_log("    x Model load failed; using local illusion fallback.")
-
-    def run_queue(self):
-        base_prompt = self.prompt.get().strip()
-        if not base_prompt:
-            messagebox.showwarning("Warn", "Please enter a prompt / لطفاً پرومپت را وارد کنید")
-            return
-        count = self.count.get()
-        vary = self.vary.get()
-        steps = self.steps.get()
-        guidance = self.guidance.get()
-        seed = self.seed.get()
-        size = self.size.get()
-        pp = self.post_mode.get()
-
-        orch.enqueue(base_prompt, count, vary, steps, guidance, seed, size, pp)
-        self.status.set("Running...")
-        self.append_log(f"[+] {datetime.now().strftime('%H:%M:%S')} Enqueued: {base_prompt} x {count} vary={vary} steps={steps} guidance={guidance} seed={seed} size={size} pp={pp}")
-
-        def worker():
-            try:
-                orch.run(self.append_log)
-            finally:
-                self.status.set("Done")
-        threading.Thread(target=worker, daemon=True).start()
-
-    def make_offline_illusion(self):
-        img = local_illusion(size=self.size.get())
-        fname = OUTPUT_DIR / f"{datetime.utcnow().strftime('%Y%m%d_%H%M%S_%f')}_offline_illusion.png"
-        img.save(fname, "PNG", optimize=True)
-        write_meta({"prompt": "offline_illusion", "model": "local_illusion"}, fname)
-        self.append_log(f"    -> Saved offline illusion: {fname}")
-
-    def harvest_fetch(self):
-        url = self.harvest_url.get().strip()
-        if not url:
-            messagebox.showwarning("Warn", "Enter Git/HTTP URL / لطفاً URL را وارد کنید")
-            return
-        self.append_log(f"[HARVEST] Fetching: {url}")
-        if url.endswith(".git"):
-            path = harvester.clone_git(url)
-        else:
-            name = Path(url).name
-            path = harvester.http_fetch(url, name=name)
-        if path:
-            self.append_log(f"    -> Stored at: {path}")
-        else:
-            self.append_log("    x Fetch failed")
-
-    def harvest_index(self):
-        p = self.harvest_local.get().strip()
-        if not p:
-            messagebox.showwarning("Warn", "Enter local path / لطفاً مسیر محلی را وارد کنید")
-            return
-        path = Path(p).resolve()
-        self.append_log(f"[HARVEST] Indexing: {path}")
-        files = harvester.index_local([path])
-        self.append_log(f"    -> Indexed {len(files)} files")
-
-    def run_worm(self):
-        self.append_log("[WORM] Starting self-improvement...")
-        worm = CodeLearner(ROOT_DIR)
-        worm.improve(self.append_log)
-        self.append_log("[WORM] Done.")
-
-# ---------------------------
-# Entry
-# ---------------------------
-def main():
-    # Optional: load plugins at start if present
-    load_plugins()
-    root = tk.Tk()
-    style = ttk.Style()
-    try:
-        style.theme_use("clam")
-    except Exception:
-        pass
-    app = App(root)
-    root.mainloop()
-
-if __name__ == "__main__":
-    main()