Deploy TextAI v2 - Clean architecture

app.py

@@ -1,746 +1,839 @@
 """
-TextAI - ChatGPT-Style Chat Interface
-Clean professional UI with Gradio 6.0 compatibility
+TextAI v2 - Simple Chat Interface
+Based on text_space pattern - Chat tab + Tools tab
 """
-import os
-import json
-import time
-import uuid
-from typing import Any, Dict, List, Optional, Tuple
-
 import gradio as gr
-import psutil
-import requests
-
-try:
-    from huggingface_hub import InferenceClient
-except ImportError:
-    InferenceClient = None
+import json
 
+# Core imports
+from modules.config import VERSION
+from modules.theme import DARK_CSS, get_theme
+from modules.logger import logger
+from modules.system import get_system_info, get_system_dashboard, get_space_info, get_storage_stats
+from modules.utils import format_size
+
+# File & Tools imports
+from modules.file_manager import (
+    get_folder_contents, get_breadcrumb, get_status, get_quick_access_folders,
+    go_up, go_home, refresh_all, search_files, upload_files, download_file,
+    create_file, read_file, delete_item
+)
+from modules.ui_helpers import (
+    ui_create_folder, ui_create_file, ui_delete,
+    on_folder_tree_select, navigate_from_main,
+    get_events_table, get_logs_display,
+    ui_refresh_logs, ui_clear_logs
+)
+from modules.hf_hub import (
+    search_hf_models_enhanced, download_model_file,
+    list_downloaded_models, remove_model,
+    get_model_files, TEXT_MODELS_DIR, get_installed_model_ids
+)
+from modules.api import ping, get_api_list, api_get_logs
+
+# TextAI imports
 try:
-    from llama_cpp import Llama
-except ImportError:
-    Llama = None
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Configuration
-# ═══════════════════════════════════════════════════════════════════════════════
-APP_TITLE = "TextAI"
-VERSION = "3.0.0"
-
-DEFAULT_SYSTEM_PROMPT = "You are a helpful AI assistant. Provide clear, accurate, and helpful responses."
-
-OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
-OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
-
-HF_TOKEN = os.getenv("HF_TOKEN", "")
-HF_MODEL = os.getenv("HF_MODEL", "meta-llama/Llama-3.1-8B-Instruct")
-
-LLAMA_GGUF_PATH = os.getenv("LLAMA_GGUF_PATH", "")
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# State Management
-# ═══════════════════════════════════════════════════════════════════════════════
-def _new_conv(title: str = "New chat") -> Dict[str, Any]:
-    return {
-        "id": str(uuid.uuid4()),
-        "title": title,
-        "messages": [],
-        "created": time.time(),
-        "updated": time.time(),
-    }
-
-
-def _default_state() -> Dict[str, Any]:
-    conv = _new_conv("New chat")
-    return {"active_id": conv["id"], "conversations": [conv]}
-
-
-def _get_conv(state: Dict[str, Any], conv_id: str) -> Dict[str, Any]:
-    for c in state["conversations"]:
-        if c["id"] == conv_id:
-            return c
-    conv = _new_conv("New chat")
-    state["conversations"].append(conv)
-    state["active_id"] = conv["id"]
-    return conv
-
-
-def _active_conv(state: Dict[str, Any]) -> Dict[str, Any]:
-    return _get_conv(state, state["active_id"])
-
-
-def _conv_choices(state: Dict[str, Any]) -> List[Tuple[str, str]]:
-    return [(c["title"].strip() or "Untitled", c["id"]) for c in state["conversations"]]
-
-
-def _set_active(state: Dict[str, Any], conv_id: str) -> Dict[str, Any]:
-    _get_conv(state, conv_id)
-    state["active_id"] = conv_id
-    return state
-
-
-def _touch(conv: Dict[str, Any]) -> None:
-    conv["updated"] = time.time()
-
-
-def _estimate_title(conv: Dict[str, Any]) -> str:
-    for m in conv["messages"]:
-        if m.get("role") == "user":
-            content = m.get("content", "")
-            if isinstance(content, list):
-                txt = " ".join(str(c) for c in content if isinstance(c, str))
-            else:
-                txt = str(content)
-            txt = txt.strip().splitlines()[0] if txt.strip() else ""
-            return (txt[:40] + "…") if len(txt) > 40 else (txt or "New chat")
-    return "New chat"
-
-
-def _to_chatbot_format(messages: List[Dict[str, Any]]) -> List[Tuple[Optional[str], Optional[str]]]:
-    """Convert messages to Gradio Chatbot tuple format: [(user, assistant), ...]"""
-    result = []
-    i = 0
-    while i < len(messages):
-        user_msg = None
-        assistant_msg = None
-
-        # Get user message
-        if i < len(messages) and messages[i].get("role") == "user":
-            content = messages[i].get("content", "")
-            if isinstance(content, list):
-                user_msg = " ".join(str(c) if isinstance(c, str) else f"[file]" for c in content)
-            else:
-                user_msg = str(content)
-            i += 1
-
-        # Get assistant message
-        if i < len(messages) and messages[i].get("role") == "assistant":
-            assistant_msg = str(messages[i].get("content", ""))
-            i += 1
-
-        if user_msg is not None or assistant_msg is not None:
-            result.append((user_msg, assistant_msg))
-
-    return result
-
-
-def _strip_content_for_prompt(messages: List[Dict[str, Any]]) -> List[Dict[str, str]]:
-    """Convert messages to simple role/content format for API calls"""
-    out = []
-    for m in messages:
-        role = m.get("role", "user")
-        content = m.get("content", "")
-        if isinstance(content, list):
-            parts = []
-            for item in content:
-                if isinstance(item, str):
-                    parts.append(item)
-                elif isinstance(item, dict) and "path" in item:
-                    parts.append(f"[file: {os.path.basename(str(item['path']))}]")
-                else:
-                    parts.append("[attachment]")
-            content_text = " ".join(parts).strip()
-        else:
-            content_text = str(content)
-        out.append({"role": role, "content": content_text})
-    return out
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# System Stats
-# ═══════════════════════════════════════════════════════════════════════════════
-def system_stats_md() -> str:
-    try:
-        cpu = psutil.cpu_percent(interval=0.05)
-        mem = psutil.virtual_memory()
-        return f"CPU {cpu:.0f}% · RAM {mem.percent:.0f}%"
-    except Exception:
-        return ""
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Backends
-# ═══════════════════════════════════════════════════════════════════════════════
-def call_openai_compat(messages, temperature, max_tokens, model, base_url, api_key):
-    if not api_key:
-        raise RuntimeError("Missing API key")
-    url = base_url.rstrip("/") + "/chat/completions"
-    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
-    payload = {
-        "model": model,
-        "messages": messages,
-        "temperature": float(temperature),
-        "max_tokens": int(max_tokens),
-        "stream": False,
-    }
-    r = requests.post(url, headers=headers, json=payload, timeout=90)
-    r.raise_for_status()
-    return r.json()["choices"][0]["message"]["content"]
-
-
-def call_hf_inference(messages, temperature, max_tokens, model, token):
-    if InferenceClient is None:
-        raise RuntimeError("huggingface_hub not installed")
-    if not token:
-        raise RuntimeError("Missing HF_TOKEN")
-    client = InferenceClient(model=model, token=token)
-
-    sys_prompt = ""
-    turns = []
-    for m in messages:
-        if m["role"] == "system":
-            sys_prompt = m["content"]
-        elif m["role"] == "user":
-            turns.append(f"User: {m['content']}")
-        else:
-            turns.append(f"Assistant: {m['content']}")
-
-    prompt = (f"System: {sys_prompt}\n" if sys_prompt else "") + "\n".join(turns) + "\nAssistant:"
-
-    return client.text_generation(
-        prompt,
-        max_new_tokens=int(max_tokens),
-        temperature=float(temperature),
-        do_sample=True,
-        return_full_text=False,
+    from modules.text_ai import (
+        model_manager, session_manager,
+        DEFAULT_CHAT_PROMPT, DEFAULT_ROLEPLAY_PROMPT,
+        api_list_models, api_load_model, api_unload_model, api_model_status,
+        api_chat, api_create_session, api_list_sessions, api_get_session,
+        api_delete_session, api_inference
     )
-
-
-_LLAMA_INSTANCE = None
-
-def call_llama_local(messages, temperature, max_tokens):
-    global _LLAMA_INSTANCE
-    if Llama is None:
-        raise RuntimeError("llama-cpp-python not installed")
-    if not LLAMA_GGUF_PATH:
-        raise RuntimeError("Set LLAMA_GGUF_PATH")
-    if _LLAMA_INSTANCE is None:
-        _LLAMA_INSTANCE = Llama(model_path=LLAMA_GGUF_PATH, n_ctx=4096, verbose=False)
-
-    sys_prompt = ""
-    turns = []
-    for m in messages:
-        if m["role"] == "system":
-            sys_prompt = m["content"]
-        elif m["role"] == "user":
-            turns.append(f"User: {m['content']}")
-        else:
-            turns.append(f"Assistant: {m['content']}")
-
-    prompt = (f"System: {sys_prompt}\n" if sys_prompt else "") + "\n".join(turns) + "\nAssistant:"
-    res = _LLAMA_INSTANCE(prompt, max_tokens=int(max_tokens), temperature=float(temperature), stop=["User:"])
-    return res["choices"][0]["text"].strip()
-
-
-def call_demo(messages, *args, **kwargs):
-    last_user = ""
-    for m in reversed(messages):
-        if m["role"] == "user":
-            last_user = m["content"]
-            break
-    return f"(Demo mode) You said: {last_user}\n\nConfigure a backend in Settings to use real AI."
-
-
-def generate_response(backend, messages, temperature, max_tokens, openai_base, openai_key, openai_model, hf_token, hf_model):
-    if backend == "OpenAI-compatible":
-        return call_openai_compat(messages, temperature, max_tokens, openai_model, openai_base, openai_key)
-    if backend == "Hugging Face Inference":
-        return call_hf_inference(messages, temperature, max_tokens, hf_model, hf_token)
-    if backend == "llama.cpp (local)":
-        return call_llama_local(messages, temperature, max_tokens)
-    return call_demo(messages)
-
-
-def pseudo_stream(text, chunk=6, delay=0.01):
-    for i in range(0, len(text), chunk):
-        yield text[:i + chunk]
-        time.sleep(delay)
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# UI Event Handlers
-# ═══════════════════════════════════════════════════════════════════════════════
-def ui_new_chat(state):
-    conv = _new_conv("New chat")
-    state["conversations"].insert(0, conv)
-    state["active_id"] = conv["id"]
-    return state, _conv_choices(state), conv["id"], []
-
-
-def ui_select_chat(state, conv_id):
-    state = _set_active(state, conv_id)
-    conv = _active_conv(state)
-    return state, _to_chatbot_format(conv["messages"]), conv["title"]
-
-
-def ui_rename_chat(state, new_title):
-    conv = _active_conv(state)
-    conv["title"] = (new_title or "").strip() or "New chat"
-    _touch(conv)
-    return state, _conv_choices(state)
-
-
-def ui_delete_chat(state):
-    active = state["active_id"]
-    state["conversations"] = [c for c in state["conversations"] if c["id"] != active]
-    if not state["conversations"]:
-        state = _default_state()
-    else:
-        state["active_id"] = state["conversations"][0]["id"]
-    conv = _active_conv(state)
-    return state, _conv_choices(state), conv["id"], _to_chatbot_format(conv["messages"]), conv["title"]
-
-
-def ui_export(state):
-    path = os.path.abspath("chat_export.json")
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(state, f, ensure_ascii=False, indent=2)
-    return path
-
-
-def ui_import(state, file_obj):
-    if file_obj is None:
-        conv = _active_conv(state)
-        return state, _conv_choices(state), state["active_id"], _to_chatbot_format(conv["messages"]), conv["title"]
+    from modules.text_ui import (
+        get_chat_list, get_model_choices, get_current_model_display,
+        format_chat_history_tuples, get_models_table,
+        ui_new_chat, ui_load_session, ui_send_message, ui_rename_session,
+        ui_delete_session, ui_clear_chat, ui_load_model_by_index, ui_unload_model,
+        get_suggested_models_table, SUGGESTED_MODELS, DEFAULT_MODEL,
+        download_default_model
+    )
+    TEXTAI_AVAILABLE = True
+except Exception as e:
+    print(f"TextAI import error: {e}")
+    TEXTAI_AVAILABLE = False
+    def get_chat_list(): return []
+    def get_current_model_display(): return "Not available"
+    def get_models_table(): return []
+    def get_suggested_models_table(): return []
+    def download_default_model(): return "TextAI not available"
+    model_manager = None
+    DEFAULT_MODEL = {"name": "TinyLlama 1.1B", "size": "0.7GB"}
+    DEFAULT_CHAT_PROMPT = ""
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# HELPER FUNCTIONS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_initial_installed_models():
+    """Get installed models for initial table display"""
+    rows = []
     try:
-        with open(file_obj.name, "r", encoding="utf-8") as f:
-            loaded = json.load(f)
-        if isinstance(loaded, dict) and "conversations" in loaded:
-            state = loaded
-            if not state.get("conversations"):
-                state = _default_state()
-            if not state.get("active_id"):
-                state["active_id"] = state["conversations"][0]["id"]
-    except Exception:
-        pass
-    conv = _active_conv(state)
-    return state, _conv_choices(state), conv["id"], _to_chatbot_format(conv["messages"]), conv["title"]
-
-
-def ui_add_user_message(state, mm_value):
-    conv = _active_conv(state)
-
-    text = ""
-    files = []
-    if isinstance(mm_value, dict):
-        text = str(mm_value.get("text") or "")
-        files = mm_value.get("files") or []
-
-    content_parts = []
-    if text.strip():
-        content_parts.append(text.strip())
-
-    if isinstance(files, list):
-        for f in files:
-            if isinstance(f, dict) and "path" in f:
-                content_parts.append({"path": f["path"]})
-            elif isinstance(f, str):
-                content_parts.append({"path": f})
-
-    if not content_parts:
-        return state, _to_chatbot_format(conv["messages"]), gr.MultimodalTextbox(value=None)
-
-    conv["messages"].append({
-        "role": "user",
-        "content": content_parts if len(content_parts) > 1 else content_parts[0]
-    })
-    _touch(conv)
-
-    if conv["title"] == "New chat":
-        conv["title"] = _estimate_title(conv)
-
-    return state, _to_chatbot_format(conv["messages"]), gr.MultimodalTextbox(value=None)
-
+        if not TEXT_MODELS_DIR.exists():
+            return rows
+        for d in TEXT_MODELS_DIR.iterdir():
+            if d.is_dir():
+                gguf_files = list(d.glob("*.gguf"))
+                if gguf_files:
+                    for f in gguf_files:
+                        size = format_size(f.stat().st_size)
+                        rows.append([f.stem, "GGUF", size, "Ready"])
+                elif (d / "config.json").exists():
+                    total_size = sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
+                    rows.append([d.name, "Transformers", format_size(total_size), "Ready"])
+        for f in TEXT_MODELS_DIR.glob("*.gguf"):
+            size = format_size(f.stat().st_size)
+            rows.append([f.stem, "GGUF", size, "Ready"])
+    except Exception as e:
+        print(f"Initial installed models error: {e}")
+    return rows
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# CUSTOM CSS
+# ══════════════════════════════════════════════════════════════════════════════
+
+CHAT_CSS = """
+/* Clean ChatGPT/Grok Style */
+.chat-container { max-width: 900px; margin: 0 auto; }
+.sidebar { border-right: 1px solid #333; }
+.chat-list { max-height: 70vh; overflow-y: auto; }
+.chat-item { padding: 10px; cursor: pointer; border-radius: 8px; margin: 4px 0; }
+.chat-item:hover { background: #2a2a2a; }
+.menu-btn { background: transparent !important; border: none !important; }
+.full-width { width: 100% !important; }
+.no-label label { display: none !important; }
+.model-badge {
+    background: #1a1a2e;
+    padding: 4px 12px;
+    border-radius: 20px;
+    font-size: 12px;
+    color: #888;
+}
+.settings-panel {
+    background: #1a1a1a;
+    border-radius: 12px;
+    padding: 16px;
+}
+#chatbot { min-height: 500px; }
+.message { white-space: pre-wrap; }
+"""
 
-def ui_regenerate_prepare(state):
-    conv = _active_conv(state)
-    if conv["messages"] and conv["messages"][-1].get("role") == "assistant":
-        conv["messages"].pop()
-        _touch(conv)
-    return state, _to_chatbot_format(conv["messages"])
 
+# ══════════════════════════════════════════════════════════════════════════════
+# BUILD APP
+# ══════════════════════════════════════════════════════════════════════════════
 
-def ui_generate_assistant(state, backend, system_prompt, temperature, max_tokens,
-                          openai_base, openai_key, openai_model, hf_token, hf_model):
-    conv = _active_conv(state)
+with gr.Blocks(title="TextAI v2") as demo:
 
-    prompt_messages = [{"role": "system", "content": system_prompt.strip() or DEFAULT_SYSTEM_PROMPT}]
-    prompt_messages += _strip_content_for_prompt(conv["messages"])
+    # Hidden state
+    current_session_id = gr.State("")
+    is_roleplay_mode = gr.State(False)
 
-    conv["messages"].append({"role": "assistant", "content": ""})
-    _touch(conv)
+    with gr.Tabs() as main_tabs:
 
-    try:
-        full = generate_response(
-            backend, prompt_messages, temperature, max_tokens,
-            openai_base, openai_key, openai_model, hf_token, hf_model
+        # ══════════════════════════════════════════════════════════════════════
+        # TAB 1: CHAT
+        # ══════════════════════════════════════════════════════════════════════
+        with gr.Tab("Chat", id=0):
+            with gr.Row():
+                # LEFT SIDEBAR - Chat List
+                with gr.Column(scale=1, min_width=250):
+                    with gr.Row():
+                        btn_new_chat = gr.Button("+ New Chat", variant="primary", size="sm")
+
+                    chat_list = gr.Dataframe(
+                        headers=["id", "Chat"],
+                        value=get_chat_list() if TEXTAI_AVAILABLE else [],
+                        interactive=False,
+                        row_count=15,
+                        column_count=(2, "fixed"),
+                        show_label=False
+                    )
+
+                # MAIN CHAT AREA
+                with gr.Column(scale=4):
+                    with gr.Row():
+                        model_display = gr.Textbox(
+                            value=get_current_model_display() if TEXTAI_AVAILABLE else "No model",
+                            interactive=False,
+                            show_label=False,
+                            scale=3,
+                            elem_classes="model-badge"
+                        )
+                        with gr.Column(scale=1):
+                            menu_dropdown = gr.Dropdown(
+                                choices=["Switch Model", "Rename Chat", "Delete Chat", "Clear Chat"],
+                                label="",
+                                show_label=False,
+                                scale=1
+                            )
+
+                    chat_title = gr.Textbox(
+                        value="New Chat",
+                        show_label=False,
+                        interactive=False,
+                        elem_classes="no-label"
+                    )
+
+                    chatbot = gr.Chatbot(
+                        label="",
+                        height=500,
+                        show_label=False,
+                        elem_id="chatbot"
+                    )
+
+                    with gr.Row():
+                        chat_input = gr.Textbox(
+                            placeholder="Send a message...",
+                            show_label=False,
+                            scale=6,
+                            lines=1,
+                            max_lines=5
+                        )
+                        btn_send = gr.Button("Send", variant="primary", scale=1)
+
+                # RIGHT SIDEBAR - Quick Settings
+                with gr.Column(scale=1, min_width=180, visible=True):
+                    gr.Markdown("### Settings")
+                    max_tokens = gr.Slider(
+                        minimum=64, maximum=2048, value=512, step=64,
+                        label="Max Tokens"
+                    )
+                    temperature = gr.Slider(
+                        minimum=0.1, maximum=2.0, value=0.7, step=0.1,
+                        label="Temperature"
+                    )
+                    gr.Markdown("---")
+                    roleplay_toggle = gr.Checkbox(label="Roleplay Mode", value=False)
+
+            # Hidden panels
+            with gr.Row(visible=False) as rename_panel:
+                rename_input = gr.Textbox(label="New Title", scale=3)
+                btn_rename = gr.Button("Rename", scale=1)
+                btn_cancel_rename = gr.Button("Cancel", scale=1)
+
+            with gr.Row(visible=False) as model_panel:
+                with gr.Column():
+                    gr.Markdown("### Select Model")
+                    with gr.Row():
+                        model_choices = gr.Dropdown(
+                            choices=get_model_choices() if TEXTAI_AVAILABLE else [],
+                            label="Available Models",
+                            scale=3
+                        )
+                        btn_refresh_model_list = gr.Button("🔄", size="sm", scale=1)
+                    with gr.Row():
+                        btn_load_model = gr.Button("Load Model", variant="primary")
+                        btn_close_model = gr.Button("Close")
+
+
+        # ══════════════════════════════════════════════════════════════════════
+        # TAB 2: TOOLS (Models, Files, HF Hub, System, Logs, API)
+        # ══════════════════════════════════════════════════════════════════════
+        with gr.Tab("Tools", id=1):
+            with gr.Tabs():
+
+                # MODEL MANAGER
+                with gr.Tab("Models"):
+                    gr.Markdown("### Installed Models")
+                    gr.Markdown("Click a model to load it. Download new models from **HF Hub** tab.")
+
+                    with gr.Row():
+                        current_model_text = gr.Textbox(
+                            value=get_current_model_display() if TEXTAI_AVAILABLE else "No model loaded",
+                            label="Currently Loaded",
+                            interactive=False,
+                            scale=3
+                        )
+                        btn_refresh_models = gr.Button("🔄 Refresh", size="sm")
+                        btn_unload_model = gr.Button("Unload", size="sm", variant="stop")
+
+                    models_table = gr.Dataframe(
+                        headers=["●", "Name", "Type", "Size", "Custom Prompt"],
+                        value=get_models_table() if TEXTAI_AVAILABLE else [],
+                        interactive=False,
+                        row_count=6
+                    )
+
+                    model_status = gr.Textbox(label="", interactive=False, show_label=False)
+
+                    with gr.Accordion("Quick Install", open=False):
+                        gr.Markdown(f"**Recommended for testing:** {DEFAULT_MODEL['name']} ({DEFAULT_MODEL['size']})")
+                        with gr.Row():
+                            btn_install_default = gr.Button("Install TinyLlama", variant="primary", size="sm")
+                            install_status = gr.Textbox(label="", interactive=False, show_label=False, scale=3)
+
+                        gr.Markdown("**Other suggestions:**")
+                        suggested_models = gr.Dataframe(
+                            headers=["Name", "Size", "Model ID"],
+                            value=get_suggested_models_table() if TEXTAI_AVAILABLE else [],
+                            interactive=False,
+                            row_count=4
+                        )
+
+
+                # HF HUB - Model Search & Download
+                with gr.Tab("HF Hub"):
+                    gr.Markdown("### Model Manager")
+
+                    gr.Markdown("#### Installed Models")
+                    installed_models_table = gr.Dataframe(
+                        headers=["Name", "Type", "Size", "Status"],
+                        value=get_initial_installed_models(),
+                        interactive=False,
+                        row_count=4
+                    )
+                    with gr.Row():
+                        selected_installed_model = gr.Textbox(label="Selected", interactive=False, scale=2)
+                        btn_refresh_installed = gr.Button("🔄", size="sm")
+                        btn_delete_installed = gr.Button("🗑️ Delete", size="sm", variant="stop")
+
+                    gr.Markdown("---")
+                    gr.Markdown("#### Search & Add Models")
+
+                    with gr.Row():
+                        hf_query = gr.Textbox(
+                            label="",
+                            placeholder="Search models... (tinyllama, mistral, phi, llama)",
+                            scale=4,
+                            show_label=False
+                        )
+                        hf_max_params = gr.Dropdown(
+                            label="Size",
+                            choices=[("< 3B", "3"), ("< 7B", "7"), ("Any", "0")],
+                            value="7",
+                            scale=1
+                        )
+                        btn_hf_search = gr.Button("Search", variant="primary", scale=1)
+
+                    hf_status = gr.Textbox(label="", interactive=False, show_label=False)
+
+                    hf_results = gr.Dataframe(
+                        headers=["Model ID", "Params", "Est.Size", "Status", "Downloads"],
+                        interactive=False,
+                        row_count=8
+                    )
+
+                    selected_model_id = gr.Textbox(label="Selected", interactive=False)
+
+                    with gr.Row():
+                        btn_view_files = gr.Button("View Files", scale=1)
+                        btn_auto_add = gr.Button("Auto Add (Best Q4)", variant="primary", scale=1)
+
+                    with gr.Column(visible=False) as file_panel:
+                        gr.Markdown("**Select Quantization:**")
+                        file_list_hub = gr.Dataframe(
+                            headers=["Filename", "Quant", "Recommended"],
+                            interactive=False,
+                            row_count=6
+                        )
+                        selected_file = gr.Textbox(label="Selected File", interactive=False)
+                        with gr.Row():
+                            btn_download_file = gr.Button("Download This File", variant="primary")
+                            btn_close_files = gr.Button("Close")
+
+                    action_status = gr.Textbox(label="Status", interactive=False)
+
+
+                # FILE MANAGER
+                with gr.Tab("Files"):
+                    with gr.Row():
+                        btn_up = gr.Button("Up", size="sm")
+                        btn_home_fm = gr.Button("Home", size="sm")
+                        btn_refresh_fm = gr.Button("Refresh", size="sm")
+                        btn_new_folder = gr.Button("+ Folder", size="sm")
+                        btn_new_file = gr.Button("+ File", size="sm")
+
+                    breadcrumb = gr.Textbox(value=get_breadcrumb(), label="", interactive=False)
+
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            folder_tree = gr.Dataframe(
+                                headers=["", "Name", "Path"],
+                                value=get_quick_access_folders(),
+                                interactive=False,
+                                row_count=10,
+                                show_label=False
+                            )
+
+                        with gr.Column(scale=3):
+                            search_input = gr.Textbox(placeholder="Search...", show_label=False)
+                            file_list = gr.Dataframe(
+                                headers=["", "Name", "Type", "Size", "Modified"],
+                                value=get_folder_contents(),
+                                interactive=False,
+                                row_count=10,
+                                show_label=False
+                            )
+                            upload_area = gr.File(label="Upload", file_count="multiple")
+
+                        with gr.Column(scale=1):
+                            selected_item = gr.Textbox(label="Selected", interactive=False)
+                            preview_txt = gr.TextArea(label="Preview", lines=6, interactive=False)
+                            with gr.Row():
+                                btn_delete_fm = gr.Button("Delete", size="sm", variant="stop")
+                                btn_download_fm = gr.Button("Download", size="sm")
+
+                    with gr.Row():
+                        new_name = gr.Textbox(label="Name", scale=2)
+                        new_content = gr.TextArea(label="Content", lines=2, scale=3)
+
+                    status_bar = gr.Textbox(value=get_status(), label="", interactive=False)
+
+
+                # SYSTEM
+                with gr.Tab("System"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### System Info")
+                            btn_sys_refresh = gr.Button("Refresh")
+                            sys_info = gr.Code(value=get_system_dashboard(), language=None)
+
+                        with gr.Column():
+                            gr.Markdown("### Storage")
+                            btn_storage_refresh = gr.Button("Refresh")
+                            storage_info = gr.Code(value=get_storage_stats(), language="json")
+
+
+                # LOGS
+                with gr.Tab("Logs"):
+                    with gr.Row():
+                        log_type = gr.Dropdown(
+                            choices=["all", "events", "errors"],
+                            value="all",
+                            label="Type"
+                        )
+                        log_limit = gr.Number(value=50, label="Limit")
+                        btn_refresh_logs = gr.Button("Refresh", variant="primary")
+                        btn_clear_logs = gr.Button("Clear", variant="stop")
+
+                    logs_display = gr.TextArea(
+                        value=get_logs_display("all", 50),
+                        lines=20,
+                        interactive=False
+                    )
+
+
+                # API
+                with gr.Tab("API"):
+                    gr.Markdown("### API Endpoints")
+                    api_list = gr.Code(value=get_api_list(), language="json")
+
+                    gr.Markdown("### Test")
+                    btn_ping = gr.Button("Ping", variant="primary")
+                    ping_result = gr.JSON()
+
+                    gr.Markdown("### Quick Logs (Errors)")
+                    btn_get_errors = gr.Button("Get Recent Errors")
+                    error_logs = gr.Code(language="json")
+
+
+        # ══════════════════════════════════════════════════════════════════════
+        # TAB 3: ABOUT
+        # ══════════════════════════════════════════════════════════════════════
+        with gr.Tab("About", id=2):
+            gr.Markdown("""
+            # TextAI v2
+
+            **AI-Powered Text Generation**
+
+            Features:
+            - Chat with local LLM models (GGUF)
+            - Model management with HF Hub integration
+            - Auto-download models
+            - File manager
+            - System monitoring
+
+            ---
+
+            **Keyboard Shortcuts:**
+            - `Enter` - Send message
+            - `Shift+Enter` - New line
+
+            ---
+
+            Built with Gradio | Models from HuggingFace
+            """)
+
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # EVENT HANDLERS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    if TEXTAI_AVAILABLE:
+        # New Chat
+        def handle_new_chat(is_rp):
+            mode = "roleplay" if is_rp else "chat"
+            sid, hist, chats, title = ui_new_chat(mode)
+            return sid, hist, chats, title, get_current_model_display()
+
+        btn_new_chat.click(
+            handle_new_chat,
+            inputs=[roleplay_toggle],
+            outputs=[current_session_id, chatbot, chat_list, chat_title, model_display]
         )
-    except Exception as e:
-        full = f"Error: {e}"
-
-    for partial in pseudo_stream(full):
-        conv["messages"][-1]["content"] = partial
-        yield state, _to_chatbot_format(conv["messages"])
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# CSS - ChatGPT Style
-# ═══════════════════════════════════════════════════════════════════════════════
-CSS = """
-:root {
-    --bg-dark: #0d0d0d;
-    --bg-panel: #171717;
-    --bg-input: #2f2f2f;
-    --border: #3d3d3d;
-    --text: #ececec;
-    --text-muted: #8e8e8e;
-    --accent: #10a37f;
-    --accent-hover: #0d8a6c;
-}
 
-* { box-sizing: border-box; }
-
-body, .gradio-container {
-    background: var(--bg-dark) !important;
-    color: var(--text) !important;
-}
-
-.gradio-container {
-    max-width: 1400px !important;
-    margin: 0 auto !important;
-    padding: 0 !important;
-}
-
-footer { display: none !important; }
-
-/* Main Layout */
-#layout {
-    display: flex !important;
-    height: 92vh !important;
-    gap: 0 !important;
-}
+        # Load Session
+        def handle_load_session(evt: gr.SelectData, sessions_data):
+            sid, hist, title, is_rp = ui_load_session(evt, sessions_data)
+            return sid, hist, title, is_rp
 
-/* Sidebar */
-#sidebar {
-    width: 280px !important;
-    min-width: 280px !important;
-    background: var(--bg-panel) !important;
-    border-right: 1px solid var(--border) !important;
-    display: flex !important;
-    flex-direction: column !important;
-    padding: 16px !important;
-}
+        chat_list.select(
+            handle_load_session,
+            inputs=[chat_list],
+            outputs=[current_session_id, chatbot, chat_title, roleplay_toggle]
+        )
 
-#sidebar h3 {
-    margin: 0 0 12px 0 !important;
-    font-size: 18px !important;
-    color: var(--text) !important;
-}
+        # Send Message
+        def handle_send(sid, msg, hist, tokens, temp, is_rp):
+            for result in ui_send_message(sid, msg, hist, tokens, temp, is_rp):
+                hist_out, _, sid_out, chats = result
+                yield sid_out, hist_out, "", chats, get_current_model_display()
 
-.stats {
-    color: var(--text-muted) !important;
-    font-size: 12px !important;
-    margin-bottom: 16px !important;
-}
+        btn_send.click(
+            handle_send,
+            inputs=[current_session_id, chat_input, chatbot, max_tokens, temperature, roleplay_toggle],
+            outputs=[current_session_id, chatbot, chat_input, chat_list, model_display]
+        )
 
-.smalllabel {
-    color: var(--text-muted) !important;
-    font-size: 12px !important;
-    margin: 16px 0 6px 0 !important;
-}
+        chat_input.submit(
+            handle_send,
+            inputs=[current_session_id, chat_input, chatbot, max_tokens, temperature, roleplay_toggle],
+            outputs=[current_session_id, chatbot, chat_input, chat_list, model_display]
+        )
 
-/* Main Chat Panel */
-#main {
-    flex: 1 !important;
-    display: flex !important;
-    flex-direction: column !important;
-    background: var(--bg-dark) !important;
-    overflow: hidden !important;
-}
+        # Menu Actions
+        def handle_menu(choice, sid):
+            if choice == "Rename Chat":
+                return gr.update(visible=True), gr.update(visible=False)
+            elif choice == "Switch Model":
+                return gr.update(visible=False), gr.update(visible=True)
+            elif choice == "Delete Chat":
+                if sid:
+                    session_manager.delete_session(sid)
+                return gr.update(visible=False), gr.update(visible=False)
+            elif choice == "Clear Chat":
+                if sid:
+                    session_manager.clear_session(sid)
+                return gr.update(visible=False), gr.update(visible=False)
+            return gr.update(visible=False), gr.update(visible=False)
+
+        menu_dropdown.change(
+            handle_menu,
+            inputs=[menu_dropdown, current_session_id],
+            outputs=[rename_panel, model_panel]
+        )
 
-/* Chatbot */
-#chatbot {
-    flex: 1 !important;
-    min-height: 400px !important;
-    border: none !important;
-    background: transparent !important;
-}
+        # Rename
+        def handle_rename(sid, new_title):
+            chats, title = ui_rename_session(sid, new_title)
+            return chats, title, gr.update(visible=False)
 
-#chatbot .message {
-    padding: 20px !important;
-    max-width: 800px !important;
-    margin: 0 auto !important;
-}
+        btn_rename.click(
+            handle_rename,
+            inputs=[current_session_id, rename_input],
+            outputs=[chat_list, chat_title, rename_panel]
+        )
 
-/* Input area */
-.input-area {
-    padding: 16px 20% !important;
-    background: var(--bg-dark) !important;
-    border-top: 1px solid var(--border) !important;
-}
+        btn_cancel_rename.click(
+            lambda: gr.update(visible=False),
+            outputs=[rename_panel]
+        )
 
-@media (max-width: 1200px) {
-    .input-area { padding: 16px 10% !important; }
-}
+        # Model Panel
+        btn_close_model.click(
+            lambda: gr.update(visible=False),
+            outputs=[model_panel]
+        )
 
-@media (max-width: 768px) {
-    .input-area { padding: 16px !important; }
-    #sidebar { display: none !important; }
-}
+        def handle_quick_load_model(choice):
+            if not choice or choice == "No models available":
+                return get_current_model_display(), gr.update(visible=False)
+            name = choice.replace("✓ ", "").split(" (")[0]
+            models = model_manager.get_available_models()
+            for m in models:
+                if m["name"] == name:
+                    model_manager.load_model(m["id"])
+                    break
+            return get_current_model_display(), gr.update(visible=False)
+
+        btn_load_model.click(
+            handle_quick_load_model,
+            inputs=[model_choices],
+            outputs=[model_display, model_panel]
+        )
 
-/* Buttons */
-button.primary {
-    background: var(--accent) !important;
-    color: white !important;
-    border: none !important;
-}
+        def refresh_model_choices():
+            choices = get_model_choices()
+            return gr.update(choices=choices)
 
-button.primary:hover {
-    background: var(--accent-hover) !important;
-}
+        btn_refresh_model_list.click(
+            refresh_model_choices,
+            outputs=[model_choices]
+        )
 
-button.secondary {
-    background: var(--bg-input) !important;
-    color: var(--text) !important;
-    border: 1px solid var(--border) !important;
-}
+        # Model Manager (Tools tab)
+        btn_refresh_models.click(
+            lambda: (get_models_table(), get_current_model_display()),
+            outputs=[models_table, current_model_text]
+        )
 
-/* Form elements */
-input, textarea, select {
-    background: var(--bg-input) !important;
-    border: 1px solid var(--border) !important;
-    color: var(--text) !important;
-    border-radius: 8px !important;
-}
+        models_table.select(
+            ui_load_model_by_index,
+            inputs=[models_table],
+            outputs=[models_table, current_model_text, model_status]
+        )
 
-input:focus, textarea:focus, select:focus {
-    border-color: var(--accent) !important;
-    outline: none !important;
-}
+        btn_unload_model.click(
+            ui_unload_model,
+            outputs=[models_table, current_model_text, model_status]
+        )
 
-/* Accordion */
-.accordion {
-    background: var(--bg-panel) !important;
-    border: 1px solid var(--border) !important;
-    border-radius: 8px !important;
-    margin: 8px 16px !important;
-}
+        # Install Default Model
+        def handle_install_default():
+            result = download_default_model()
+            return result, get_models_table(), get_current_model_display()
 
-/* Scrollbar */
-::-webkit-scrollbar { width: 8px; }
-::-webkit-scrollbar-track { background: var(--bg-dark); }
-::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
-::-webkit-scrollbar-thumb:hover { background: var(--text-muted); }
-
-.footerhint {
-    color: var(--text-muted) !important;
-    font-size: 11px !important;
-    margin-top: auto !important;
-    padding-top: 16px !important;
-}
-"""
+        btn_install_default.click(
+            handle_install_default,
+            outputs=[install_status, models_table, current_model_text]
+        )
 
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# Gradio App
-# ═══════════════════════════════════════════════════════════════════════════════
-with gr.Blocks(title=APP_TITLE) as demo:
-    state = gr.State(_default_state())
+    # File Manager Events
+    folder_tree.select(on_folder_tree_select, [folder_tree], [file_list, breadcrumb, status_bar, folder_tree])
+    file_list.select(
+        navigate_from_main,
+        [file_list],
+        [file_list, breadcrumb, status_bar, folder_tree, selected_item, gr.State(None), preview_txt, gr.State("")]
+    )
+    btn_up.click(go_up, outputs=[file_list, breadcrumb, status_bar, folder_tree])
+    btn_home_fm.click(go_home, outputs=[file_list, breadcrumb, status_bar, folder_tree])
+    btn_refresh_fm.click(refresh_all, outputs=[file_list, breadcrumb, status_bar, folder_tree])
+    btn_new_folder.click(ui_create_folder, [new_name], [file_list, breadcrumb, status_bar, folder_tree])
+    btn_new_file.click(ui_create_file, [new_name, new_content], [file_list, breadcrumb, status_bar, folder_tree])
+    btn_delete_fm.click(ui_delete, [selected_item], [file_list, breadcrumb, status_bar, folder_tree])
+    upload_area.change(upload_files, [upload_area], [file_list, breadcrumb, status_bar, folder_tree])
+    search_input.submit(search_files, [search_input], [file_list, breadcrumb, status_bar])
+
+
+    # HF Hub Events
+    def get_installed_models_list():
+        rows = []
+        try:
+            if not TEXT_MODELS_DIR.exists():
+                return rows
+            for d in TEXT_MODELS_DIR.iterdir():
+                if d.is_dir():
+                    gguf_files = list(d.glob("*.gguf"))
+                    if gguf_files:
+                        for f in gguf_files:
+                            size = format_size(f.stat().st_size)
+                            rows.append([f.stem, "GGUF", size, "Ready"])
+                    elif (d / "config.json").exists():
+                        total_size = sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
+                        rows.append([d.name, "Transformers", format_size(total_size), "Ready"])
+            for f in TEXT_MODELS_DIR.glob("*.gguf"):
+                size = format_size(f.stat().st_size)
+                rows.append([f.stem, "GGUF", size, "Ready"])
+        except Exception as e:
+            logger.error("HFHub", f"List installed error: {str(e)}")
+        return rows
+
+    def refresh_installed():
+        rows = get_installed_models_list()
+        choices = get_model_choices() if TEXTAI_AVAILABLE else []
+        return rows, gr.update(choices=choices)
+
+    btn_refresh_installed.click(
+        refresh_installed,
+        outputs=[installed_models_table, model_choices]
+    )
 
-    with gr.Row(elem_id="layout", equal_height=True):
+    def select_installed_model(evt: gr.SelectData, data):
+        try:
+            row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+            if hasattr(data, 'values'):
+                data_list = data.values.tolist()
+            else:
+                data_list = data
+            if data_list and row_idx < len(data_list):
+                return data_list[row_idx][0]
+        except Exception as e:
+            logger.error("HFHub", f"Select installed error: {str(e)}")
+        return ""
 
-        # ═══════════════════════════════════════════════════════════════════════
-        # Sidebar
-        # ═══════════════════════════════════════════════════════════════════════
-        with gr.Column(scale=3, elem_id="sidebar"):
-            gr.Markdown(f"### {APP_TITLE}")
-            stats = gr.Markdown(value=system_stats_md, every=2, elem_classes="stats")
+    installed_models_table.select(
+        select_installed_model,
+        [installed_models_table],
+        [selected_installed_model]
+    )
 
-            new_chat_btn = gr.Button("+ New chat", variant="primary")
+    def delete_installed_model(model_name):
+        if not model_name:
+            return get_installed_models_list(), "", "Select a model first", gr.update()
+        result = remove_model(model_name)
+        rows = get_installed_models_list()
+        choices = get_model_choices() if TEXTAI_AVAILABLE else []
+        return rows, "", result, gr.update(choices=choices)
+
+    btn_delete_installed.click(
+        delete_installed_model,
+        inputs=[selected_installed_model],
+        outputs=[installed_models_table, selected_installed_model, action_status, model_choices]
+    )
 
-            gr.Markdown("<div class='smalllabel'>Conversation</div>")
-            chat_selector = gr.Dropdown(choices=[], value=None, label=None, interactive=True)
+    def handle_hf_search(query, max_params_str):
+        max_params = float(max_params_str) if max_params_str != "0" else None
+        rows, status, total = search_hf_models_enhanced(
+            query=query,
+            task="text-generation",
+            library="gguf",
+            sort="downloads",
+            max_params=max_params,
+            recommended_only=False,
+            limit=30,
+            offset=0
+        )
+        simple_rows = [[r[0], r[1], r[2], r[3], r[4]] for r in rows]
+        return simple_rows, status
 
-            gr.Markdown("<div class='smalllabel'>Rename</div>")
-            rename_box = gr.Textbox(value="", placeholder="Chat title", label=None)
-            rename_btn = gr.Button("Save title", variant="secondary")
+    btn_hf_search.click(
+        handle_hf_search,
+        [hf_query, hf_max_params],
+        [hf_results, hf_status]
+    )
 
-            with gr.Row():
-                delete_btn = gr.Button("Delete", variant="secondary")
-                regen_btn = gr.Button("Regenerate", variant="secondary")
+    hf_query.submit(
+        handle_hf_search,
+        [hf_query, hf_max_params],
+        [hf_results, hf_status]
+    )
 
-            gr.Markdown("---")
+    def handle_select_model(evt: gr.SelectData, results_data):
+        try:
+            row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+            if hasattr(results_data, 'values'):
+                data_list = results_data.values.tolist()
+            elif hasattr(results_data, 'tolist'):
+                data_list = results_data.tolist()
+            else:
+                data_list = results_data
+            if data_list and row_idx < len(data_list):
+                return data_list[row_idx][0]
+        except Exception as e:
+            logger.error("HFHub", f"Select error: {str(e)}")
+        return ""
 
-            with gr.Row():
-                export_btn = gr.Button("Export", variant="secondary")
-                export_file = gr.File(label=None, visible=False)
+    hf_results.select(handle_select_model, [hf_results], [selected_model_id])
 
-            import_file = gr.File(label="Import", file_types=[".json"])
-            import_btn = gr.Button("Import", variant="secondary")
+    def handle_view_files(model_id):
+        if not model_id:
+            return gr.update(visible=False), [], "", "Select a model first"
+        files = get_model_files(model_id)
+        if not files:
+            return gr.update(visible=False), [], "", "No GGUF files found"
+        rows = []
+        for f in files:
+            rec = "✓" if f["recommended"] else ""
+            rows.append([f["filename"], f["quant"], rec])
+        rows.sort(key=lambda x: (x[2] != "✓", x[0]))
+        return gr.update(visible=True), rows, "", f"Found {len(files)} files"
+
+    btn_view_files.click(
+        handle_view_files,
+        [selected_model_id],
+        [file_panel, file_list_hub, selected_file, action_status]
+    )
 
-            gr.Markdown(f"<div class='footerhint'>v{VERSION} · OpenAI / HuggingFace / llama.cpp</div>")
+    def handle_select_file(evt: gr.SelectData, files_data):
+        try:
+            row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+            if hasattr(files_data, 'values'):
+                data_list = files_data.values.tolist()
+            elif hasattr(files_data, 'tolist'):
+                data_list = files_data.tolist()
+            else:
+                data_list = files_data
+            if data_list and row_idx < len(data_list):
+                return data_list[row_idx][0]
+        except Exception as e:
+            logger.error("HFHub", f"File select error: {str(e)}")
+        return ""
 
-        # ═══════════════════════════════════════════════════════════════════════
-        # Main Chat Panel
-        # ═══════════════════════════════════════════════════════════════════════
-        with gr.Column(scale=7, elem_id="main"):
+    file_list_hub.select(handle_select_file, [file_list_hub], [selected_file])
 
-            with gr.Row():
-                backend = gr.Dropdown(
-                    choices=["Demo (offline)", "OpenAI-compatible", "Hugging Face Inference", "llama.cpp (local)"],
-                    value="Demo (offline)",
-                    label="Backend",
-                )
-
-            with gr.Accordion("Settings", open=False):
-                system_prompt = gr.Textbox(
-                    value=DEFAULT_SYSTEM_PROMPT,
-                    label="System prompt",
-                    lines=3,
-                )
-                with gr.Row():
-                    temperature = gr.Slider(0, 2, value=0.7, step=0.1, label="Temperature")
-                    max_tokens = gr.Slider(64, 4096, value=1024, step=64, label="Max tokens")
-
-                gr.Markdown("#### OpenAI-compatible")
-                with gr.Row():
-                    openai_base = gr.Textbox(value=OPENAI_BASE_URL, label="Base URL")
-                    openai_model = gr.Textbox(value=OPENAI_MODEL, label="Model")
-                openai_key = gr.Textbox(value=OPENAI_API_KEY, label="API key", type="password")
-
-                gr.Markdown("#### Hugging Face Inference")
-                with gr.Row():
-                    hf_model_box = gr.Textbox(value=HF_MODEL, label="Model")
-                    hf_token_box = gr.Textbox(value=HF_TOKEN, label="HF token", type="password")
-
-                if Llama is None:
-                    gr.Markdown("*llama-cpp-python not installed*")
-
-            chatbot = gr.Chatbot(
-                elem_id="chatbot",
-                height=550,
-            )
-
-            composer = gr.MultimodalTextbox(
-                placeholder="Message TextAI...",
-                file_count="multiple",
-                sources=["upload"],
-                submit_btn=True,
-                stop_btn=True,
-            )
-
-    # ═══════════════════════════════════════════════════════════════════════════
-    # Event Wiring
-    # ═══════════════════════════════════════════════════════════════════════════
-
-    def _init_sidebar(s):
-        choices = _conv_choices(s)
-        active = s["active_id"]
-        conv = _active_conv(s)
-        return choices, active, conv["title"], _to_chatbot_format(conv["messages"])
-
-    demo.load(
-        _init_sidebar,
-        inputs=[state],
-        outputs=[chat_selector, chat_selector, rename_box, chatbot],
-        queue=False,
-    )
+    def handle_download_file(model_id, filename):
+        if not model_id or not filename:
+            return "Select model and file"
+        result = download_model_file(model_id, filename)
+        return result
 
-    # New chat
-    new_chat_btn.click(
-        ui_new_chat,
-        inputs=[state],
-        outputs=[state, chat_selector, chat_selector, chatbot],
-        queue=False,
-    ).then(lambda: "", None, rename_box, queue=False)
-
-    # Select chat
-    chat_selector.change(
-        ui_select_chat,
-        inputs=[state, chat_selector],
-        outputs=[state, chatbot, rename_box],
-        queue=False,
+    btn_download_file.click(
+        handle_download_file,
+        [selected_model_id, selected_file],
+        [action_status]
     )
 
-    # Rename
-    rename_btn.click(
-        ui_rename_chat,
-        inputs=[state, rename_box],
-        outputs=[state, chat_selector],
-        queue=False,
+    btn_close_files.click(
+        lambda: gr.update(visible=False),
+        outputs=[file_panel]
     )
 
-    # Delete
-    delete_btn.click(
-        ui_delete_chat,
-        inputs=[state],
-        outputs=[state, chat_selector, chat_selector, chatbot, rename_box],
-        queue=False,
+    def handle_auto_add(model_id):
+        if not model_id:
+            return "Select a model first", get_installed_models_list(), gr.update()
+        files = get_model_files(model_id)
+        if not files:
+            return "No GGUF files found for this model", get_installed_models_list(), gr.update()
+
+        best_file = None
+        priority = ["Q4_K_M", "Q4_K_S", "Q5_K_M", "Q4_0", "Q5_0"]
+        for quant in priority:
+            for f in files:
+                if f["quant"] == quant:
+                    best_file = f["filename"]
+                    break
+            if best_file:
+                break
+
+        if not best_file and files:
+            best_file = files[0]["filename"]
+
+        if best_file:
+            result = download_model_file(model_id, best_file)
+            installed = get_installed_models_list()
+            choices = get_model_choices() if TEXTAI_AVAILABLE else []
+            return result, installed, gr.update(choices=choices)
+
+        return "Could not find suitable file", get_installed_models_list(), gr.update()
+
+    btn_auto_add.click(
+        handle_auto_add,
+        [selected_model_id],
+        [action_status, installed_models_table, model_choices]
     )
 
-    # Export
-    export_btn.click(
-        ui_export,
-        inputs=[state],
-        outputs=[export_file],
-        queue=False,
-    ).then(
-        lambda p: gr.File(value=p, visible=True),
-        inputs=[export_file],
-        outputs=[export_file],
-        queue=False,
-    )
 
-    # Import
-    import_btn.click(
-        ui_import,
-        inputs=[state, import_file],
-        outputs=[state, chat_selector, chat_selector, chatbot, rename_box],
-        queue=False,
-    )
+    # System
+    btn_sys_refresh.click(get_system_dashboard, outputs=[sys_info])
+    btn_storage_refresh.click(get_storage_stats, outputs=[storage_info])
 
-    # Send message -> generate
-    add_evt = composer.submit(
-        ui_add_user_message,
-        inputs=[state, composer],
-        outputs=[state, chatbot, composer],
-        queue=False,
-    )
+    # Logs
+    btn_refresh_logs.click(ui_refresh_logs, [log_type, log_limit], [logs_display])
+    btn_clear_logs.click(ui_clear_logs, [log_type], [logs_display, gr.State("")])
 
-    add_evt.then(
-        ui_generate_assistant,
-        inputs=[state, backend, system_prompt, temperature, max_tokens,
-                openai_base, openai_key, openai_model, hf_token_box, hf_model_box],
-        outputs=[state, chatbot],
-        queue=True,
-    )
+    # API
+    btn_ping.click(ping, outputs=[ping_result])
+    btn_get_errors.click(lambda: api_get_logs("errors", 50), outputs=[error_logs])
 
-    # Regenerate
-    regen_btn.click(
-        ui_regenerate_prepare,
-        inputs=[state],
-        outputs=[state, chatbot],
-        queue=False,
-    ).then(
-        ui_generate_assistant,
-        inputs=[state, backend, system_prompt, temperature, max_tokens,
-                openai_base, openai_key, openai_model, hf_token_box, hf_model_box],
-        outputs=[state, chatbot],
-        queue=True,
-    )
 
+# ══════════════════════════════════════════════════════════════════════════════
+# LAUNCH
+# ══════════════════════════════════════════════════════════════════════════════
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# Main
-# ═══════════════════════════════════════════════════════════════════════════════
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        css=CSS,
-    )
+    logger.info("System", "TextAI v2 starting", {"version": VERSION})
+    demo.launch(theme=get_theme(), css=DARK_CSS + CHAT_CSS)

modules/__init__.py

@@ -0,0 +1 @@
+# Modules package

modules/api.py

@@ -0,0 +1,95 @@
+"""
+API Module
+All API endpoints for external access.
+"""
+import json
+from datetime import datetime
+
+from .config import VERSION
+from .logger import logger
+from .events import event_manager
+from .file_manager import create_folder, create_file, read_file, write_file, delete_item, rename_item
+from .system import get_system_info, get_space_info, get_storage_stats
+
+
+def ping() -> dict:
+    """Health check endpoint"""
+    return {"status": "ok", "version": VERSION, "timestamp": datetime.now().isoformat()}
+
+
+def get_api_list() -> str:
+    """List all available API endpoints"""
+    return json.dumps({
+        "system": ["ping()", "get_system_info()", "get_system_dashboard()", "get_space_info()", "get_storage_stats()"],
+        "files": ["create_folder(name)", "create_file(name,content)", "read_file(name)", "write_file(name,content)",
+                  "delete_item(name)", "rename_item(old,new)", "search_files(query)"],
+        "hub": ["search_hf_models(query,task,library,sort)", "download_model_file(model_id,filename)",
+                "download_from_url(url,filename)", "list_downloaded_models()"],
+        "events": ["api_create_event(type,path,hours,enabled,desc)", "api_delete_event(id)",
+                   "api_toggle_event(id)", "api_run_event(id)", "api_get_events()"],
+        "logs": ["api_get_logs(type,limit,level,category)", "api_clear_logs(type)", "api_export_logs(type)"]
+    }, indent=2)
+
+
+# Event API
+def api_create_event(event_type: str, target_path: str, interval_hours: float, enabled: bool, description: str) -> str:
+    """Create a scheduled event"""
+    try:
+        event_id = event_manager.create_event(
+            event_type=event_type,
+            target_path=target_path,
+            interval_hours=float(interval_hours),
+            enabled=enabled,
+            description=description
+        )
+        return json.dumps({"success": True, "event_id": event_id})
+    except Exception as e:
+        return json.dumps({"success": False, "error": str(e)})
+
+
+def api_delete_event(event_id: str) -> str:
+    """Delete a scheduled event"""
+    success = event_manager.delete_event(event_id)
+    return json.dumps({"success": success})
+
+
+def api_toggle_event(event_id: str) -> str:
+    """Toggle event enabled status"""
+    success = event_manager.toggle_event(event_id)
+    if success and event_id in event_manager.events:
+        return json.dumps({"success": True, "enabled": event_manager.events[event_id].enabled})
+    return json.dumps({"success": False})
+
+
+def api_run_event(event_id: str) -> str:
+    """Run event immediately"""
+    success = event_manager.run_now(event_id)
+    return json.dumps({"success": success})
+
+
+def api_get_events() -> str:
+    """Get all scheduled events"""
+    return json.dumps({"events": event_manager.get_events()}, indent=2)
+
+
+# Log API
+def api_get_logs(log_type: str = "all", limit: int = 100, level: str = "", category: str = "") -> str:
+    """Get logs"""
+    logs = logger.get_logs(
+        log_type=log_type,
+        limit=int(limit),
+        level=level if level else None,
+        category=category if category else None
+    )
+    return json.dumps({"count": len(logs), "logs": logs}, indent=2)
+
+
+def api_clear_logs(log_type: str = "all") -> str:
+    """Clear logs"""
+    success = logger.clear_logs(log_type)
+    return json.dumps({"success": success})
+
+
+def api_export_logs(log_type: str = "all") -> str:
+    """Export logs"""
+    return logger.export_logs(log_type)

modules/config.py

@@ -0,0 +1,24 @@
+"""
+Configuration Module
+Central configuration for the entire application.
+"""
+import os
+from pathlib import Path
+
+# Storage paths
+STORAGE_DIR = Path("/tmp/space_storage")
+MODELS_DIR = STORAGE_DIR / "models"
+DOWNLOADS_DIR = STORAGE_DIR / "downloads"
+LOGS_DIR = STORAGE_DIR / "logs"
+UPLOADS_DIR = STORAGE_DIR / "uploads"
+
+# Create directories
+for d in [STORAGE_DIR, MODELS_DIR, DOWNLOADS_DIR, LOGS_DIR, UPLOADS_DIR]:
+    d.mkdir(parents=True, exist_ok=True)
+
+# API config
+HF_API_URL = "https://huggingface.co/api"
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+
+# App version
+VERSION = "5.0.0"

modules/events.py

@@ -0,0 +1,277 @@
+"""
+Event Management Module
+Scheduled events, auto-cleanup, and session management.
+"""
+import json
+import shutil
+import threading
+import time
+import uuid
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+from dataclasses import dataclass, asdict
+
+from .config import STORAGE_DIR, LOGS_DIR, UPLOADS_DIR
+from .logger import logger
+
+
+@dataclass
+class ScheduledEvent:
+    event_id: str
+    event_type: str
+    target_path: str
+    schedule_type: str
+    interval_hours: float
+    next_run: str
+    enabled: bool
+    created_at: str
+    last_run: Optional[str] = None
+    run_count: int = 0
+    description: str = ""
+
+
+class EventManager:
+    """Manages scheduled events, auto-cleanup, and session events"""
+
+    def __init__(self, storage_dir: Path):
+        self.storage_dir = storage_dir
+        self.events_file = LOGS_DIR / "scheduled_events.json"
+        self.sessions_file = LOGS_DIR / "active_sessions.json"
+        self._scheduler_thread = None
+        self._running = False
+        self._lock = threading.Lock()
+
+        self.events: Dict[str, ScheduledEvent] = self._load_events()
+        self.start_scheduler()
+
+    def _load_events(self) -> Dict[str, ScheduledEvent]:
+        if not self.events_file.exists():
+            return {}
+        try:
+            data = json.loads(self.events_file.read_text())
+            return {k: ScheduledEvent(**v) for k, v in data.items()}
+        except:
+            return {}
+
+    def _save_events(self):
+        with self._lock:
+            data = {k: asdict(v) for k, v in self.events.items()}
+            self.events_file.write_text(json.dumps(data, indent=2))
+
+    def create_event(
+        self,
+        event_type: str,
+        target_path: str,
+        schedule_type: str = "interval",
+        interval_hours: float = 3.0,
+        enabled: bool = True,
+        description: str = ""
+    ) -> str:
+        event_id = str(uuid.uuid4())[:8]
+        next_run = (datetime.now() + timedelta(hours=interval_hours)).isoformat()
+
+        event = ScheduledEvent(
+            event_id=event_id,
+            event_type=event_type,
+            target_path=target_path,
+            schedule_type=schedule_type,
+            interval_hours=interval_hours,
+            next_run=next_run,
+            enabled=enabled,
+            created_at=datetime.now().isoformat(),
+            description=description or f"{event_type} on {target_path}"
+        )
+
+        self.events[event_id] = event
+        self._save_events()
+
+        logger.event("EventManager", f"Created event: {event_type}", {
+            "event_id": event_id,
+            "target": target_path,
+            "interval_hours": interval_hours
+        })
+
+        return event_id
+
+    def delete_event(self, event_id: str) -> bool:
+        if event_id in self.events:
+            del self.events[event_id]
+            self._save_events()
+            logger.event("EventManager", f"Deleted event: {event_id}")
+            return True
+        return False
+
+    def toggle_event(self, event_id: str) -> bool:
+        if event_id in self.events:
+            self.events[event_id].enabled = not self.events[event_id].enabled
+            self._save_events()
+            status = "enabled" if self.events[event_id].enabled else "disabled"
+            logger.event("EventManager", f"Event {event_id} {status}")
+            return True
+        return False
+
+    def get_events(self) -> List[Dict]:
+        return [asdict(e) for e in self.events.values()]
+
+    def execute_event(self, event: ScheduledEvent) -> bool:
+        try:
+            target = Path(event.target_path)
+
+            if event.event_type == "delete_file":
+                if target.exists() and target.is_file():
+                    target.unlink()
+                    logger.event("Cleanup", f"Deleted file: {target.name}")
+
+            elif event.event_type == "delete_folder":
+                if target.exists() and target.is_dir():
+                    shutil.rmtree(target)
+                    logger.event("Cleanup", f"Deleted folder: {target.name}")
+
+            elif event.event_type == "cleanup_uploads":
+                cutoff = datetime.now() - timedelta(hours=event.interval_hours)
+                deleted = 0
+                for f in UPLOADS_DIR.iterdir():
+                    if f.is_file() and datetime.fromtimestamp(f.stat().st_mtime) < cutoff:
+                        f.unlink()
+                        deleted += 1
+                logger.event("Cleanup", f"Cleaned {deleted} old uploads")
+
+            elif event.event_type == "cleanup_old_files":
+                if target.exists() and target.is_dir():
+                    cutoff = datetime.now() - timedelta(hours=event.interval_hours)
+                    deleted = 0
+                    for f in target.rglob("*"):
+                        if f.is_file() and datetime.fromtimestamp(f.stat().st_mtime) < cutoff:
+                            f.unlink()
+                            deleted += 1
+                    logger.event("Cleanup", f"Cleaned {deleted} old files in {target.name}")
+
+            elif event.event_type == "cleanup_empty_folders":
+                if target.exists() and target.is_dir():
+                    deleted = 0
+                    for d in sorted(target.rglob("*"), reverse=True):
+                        if d.is_dir() and not any(d.iterdir()):
+                            d.rmdir()
+                            deleted += 1
+                    logger.event("Cleanup", f"Removed {deleted} empty folders")
+
+            elif event.event_type == "cleanup_logs":
+                logger.clear_logs("all")
+                logger.event("Cleanup", "Logs rotated")
+
+            elif event.event_type == "cleanup_temp":
+                temp_patterns = ["*.tmp", "*.temp", ".DS_Store", "Thumbs.db"]
+                deleted = 0
+                for pattern in temp_patterns:
+                    for f in self.storage_dir.rglob(pattern):
+                        f.unlink()
+                        deleted += 1
+                logger.event("Cleanup", f"Cleaned {deleted} temp files")
+
+            event.last_run = datetime.now().isoformat()
+            event.run_count += 1
+            if event.schedule_type == "interval":
+                event.next_run = (datetime.now() + timedelta(hours=event.interval_hours)).isoformat()
+            elif event.schedule_type == "once":
+                event.enabled = False
+
+            self._save_events()
+            return True
+
+        except Exception as e:
+            logger.error("EventManager", f"Event execution failed: {event.event_id}", {"error": str(e)})
+            return False
+
+    def _scheduler_loop(self):
+        while self._running:
+            try:
+                now = datetime.now()
+                for event_id, event in list(self.events.items()):
+                    if not event.enabled:
+                        continue
+
+                    next_run = datetime.fromisoformat(event.next_run)
+                    if now >= next_run:
+                        self.execute_event(event)
+            except Exception as e:
+                logger.error("Scheduler", f"Scheduler error: {str(e)}")
+
+            time.sleep(60)
+
+    def start_scheduler(self):
+        if self._scheduler_thread is None or not self._scheduler_thread.is_alive():
+            self._running = True
+            self._scheduler_thread = threading.Thread(target=self._scheduler_loop, daemon=True)
+            self._scheduler_thread.start()
+            logger.info("Scheduler", "Scheduler started")
+
+    def stop_scheduler(self):
+        self._running = False
+        logger.info("Scheduler", "Scheduler stopped")
+
+    def run_now(self, event_id: str) -> bool:
+        if event_id in self.events:
+            return self.execute_event(self.events[event_id])
+        return False
+
+    # Session management
+    def register_session(self, session_id: str) -> str:
+        sessions = self._load_sessions()
+        sessions[session_id] = {
+            "created_at": datetime.now().isoformat(),
+            "last_activity": datetime.now().isoformat(),
+            "uploads": []
+        }
+        self._save_sessions(sessions)
+        logger.event("Session", f"New session: {session_id[:8]}...")
+        return session_id
+
+    def end_session(self, session_id: str):
+        sessions = self._load_sessions()
+        if session_id in sessions:
+            for upload in sessions[session_id].get("uploads", []):
+                try:
+                    Path(upload).unlink(missing_ok=True)
+                except:
+                    pass
+            del sessions[session_id]
+            self._save_sessions(sessions)
+            logger.event("Session", f"Session ended: {session_id[:8]}...")
+
+    def track_upload(self, session_id: str, file_path: str):
+        sessions = self._load_sessions()
+        if session_id in sessions:
+            sessions[session_id]["uploads"].append(file_path)
+            sessions[session_id]["last_activity"] = datetime.now().isoformat()
+            self._save_sessions(sessions)
+
+    def _load_sessions(self) -> Dict:
+        if not self.sessions_file.exists():
+            return {}
+        try:
+            return json.loads(self.sessions_file.read_text())
+        except:
+            return {}
+
+    def _save_sessions(self, sessions: Dict):
+        self.sessions_file.write_text(json.dumps(sessions, indent=2))
+
+
+# Global event manager instance
+event_manager = EventManager(STORAGE_DIR)
+
+# Create default events if none exist
+if not event_manager.events:
+    event_manager.create_event(
+        event_type="cleanup_uploads",
+        target_path=str(UPLOADS_DIR),
+        interval_hours=3.0,
+        description="Auto-cleanup uploads every 3 hours"
+    )
+    event_manager.create_event(
+        event_type="cleanup_temp",
+        target_path=str(STORAGE_DIR),
+        interval_hours=6.0,
+        description="Clean temp files every 6 hours"
+    )

modules/file_manager.py

@@ -0,0 +1,344 @@
+"""
+File Manager Module
+File and folder operations with navigation.
+"""
+import json
+import shutil
+from pathlib import Path
+from datetime import datetime
+from typing import List, Tuple, Optional
+
+from .config import STORAGE_DIR
+from .utils import format_size, get_file_icon, get_mime_type, format_timestamp
+from .logger import logger
+
+# Global state
+clipboard = {"files": [], "operation": None}
+current_path = STORAGE_DIR
+
+
+def get_quick_access_folders() -> List[List[str]]:
+    """Get list of folders for sidebar tree"""
+    folders = [["📂", "Root", ""]]
+
+    def add_folders(path: Path, level: int = 0):
+        try:
+            dirs = sorted([d for d in path.iterdir() if d.is_dir()], key=lambda x: x.name.lower())
+            for d in dirs:
+                rel = str(d.relative_to(STORAGE_DIR))
+                indent = "    " * level
+                is_current = "▶" if d == current_path else " "
+                folders.append([is_current, f"{indent}📁 {d.name}", rel])
+                add_folders(d, level + 1)
+        except:
+            pass
+
+    add_folders(STORAGE_DIR)
+
+    if current_path == STORAGE_DIR:
+        folders[0][0] = "▶"
+
+    return folders
+
+
+def get_folder_contents() -> List[List[str]]:
+    """Get contents of current folder"""
+    items = []
+
+    try:
+        entries = sorted(current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+        for f in entries:
+            is_dir = f.is_dir()
+            stat = f.stat()
+
+            if is_dir:
+                try:
+                    count = len(list(f.iterdir()))
+                    size_str = f"{count} items"
+                except:
+                    size_str = ""
+            else:
+                size_str = format_size(stat.st_size)
+
+            items.append([
+                get_file_icon(f.name, is_dir),
+                f.name,
+                "Folder" if is_dir else (Path(f.name).suffix.upper()[1:] or "FILE"),
+                size_str,
+                format_timestamp(stat.st_mtime)
+            ])
+    except:
+        pass
+
+    return items
+
+
+def get_breadcrumb() -> str:
+    """Get current path as breadcrumb"""
+    if current_path == STORAGE_DIR:
+        return "📂 Root"
+
+    parts = current_path.relative_to(STORAGE_DIR).parts
+    breadcrumb = "📂 Root"
+    for p in parts:
+        breadcrumb += f" › {p}"
+    return breadcrumb
+
+
+def get_status() -> str:
+    """Get status bar info"""
+    try:
+        items = list(current_path.iterdir())
+        folders = len([i for i in items if i.is_dir()])
+        files = len([i for i in items if i.is_file()])
+        total_size = sum(i.stat().st_size for i in items if i.is_file())
+        return f"{folders} folders, {files} files | {format_size(total_size)}"
+    except:
+        return "Ready"
+
+
+def navigate_to_folder(folder_path: str):
+    """Navigate to a specific folder"""
+    global current_path
+
+    if not folder_path or folder_path == "" or folder_path == "Root":
+        current_path = STORAGE_DIR
+    else:
+        new_path = STORAGE_DIR / folder_path
+        if new_path.exists() and new_path.is_dir():
+            current_path = new_path
+
+    return get_folder_contents(), get_breadcrumb(), get_status(), get_quick_access_folders()
+
+
+def go_up():
+    """Navigate to parent folder"""
+    global current_path
+    if current_path != STORAGE_DIR:
+        current_path = current_path.parent
+    return get_folder_contents(), get_breadcrumb(), get_status(), get_quick_access_folders()
+
+
+def go_home():
+    """Navigate to root"""
+    global current_path
+    current_path = STORAGE_DIR
+    return get_folder_contents(), get_breadcrumb(), get_status(), get_quick_access_folders()
+
+
+def refresh_all():
+    """Refresh everything"""
+    return get_folder_contents(), get_breadcrumb(), get_status(), get_quick_access_folders()
+
+
+# CRUD Operations
+def create_folder(name: str) -> str:
+    if not name:
+        return json.dumps({"success": False, "error": "Name required"})
+    path = current_path / name
+    if path.exists():
+        return json.dumps({"success": False, "error": "Already exists"})
+    path.mkdir(parents=True)
+    logger.info("FileOps", f"Created folder: {name}")
+    return json.dumps({"success": True, "created": name})
+
+
+def create_file(name: str, content: str = "") -> str:
+    if not name:
+        return json.dumps({"success": False, "error": "Name required"})
+    path = current_path / name
+    if path.exists():
+        return json.dumps({"success": False, "error": "Already exists"})
+    path.write_text(content)
+    logger.info("FileOps", f"Created file: {name}")
+    return json.dumps({"success": True, "created": name})
+
+
+def read_file(name: str) -> str:
+    if not name:
+        return ""
+    path = current_path / name
+    if not path.exists() or path.is_dir():
+        return ""
+    try:
+        content = path.read_text()
+        return content[:100000] + ("\n...[truncated]" if len(content) > 100000 else "")
+    except:
+        return f"[Binary: {format_size(path.stat().st_size)}]"
+
+
+def write_file(name: str, content: str) -> str:
+    if not name:
+        return json.dumps({"success": False, "error": "Name required"})
+    path = current_path / name
+    path.write_text(content)
+    logger.info("FileOps", f"Updated file: {name}")
+    return json.dumps({"success": True, "saved": name})
+
+
+def delete_item(name: str) -> str:
+    if not name:
+        return json.dumps({"success": False, "error": "Name required"})
+    path = current_path / name
+    if not path.exists():
+        return json.dumps({"success": False, "error": "Not found"})
+    if path.is_dir():
+        shutil.rmtree(path)
+    else:
+        path.unlink()
+    logger.info("FileOps", f"Deleted: {name}")
+    return json.dumps({"success": True, "deleted": name})
+
+
+def rename_item(old: str, new: str) -> str:
+    if not old or not new:
+        return json.dumps({"success": False, "error": "Names required"})
+    old_path = current_path / old
+    new_path = current_path / new
+    if not old_path.exists():
+        return json.dumps({"success": False, "error": "Not found"})
+    if new_path.exists():
+        return json.dumps({"success": False, "error": "Target exists"})
+    old_path.rename(new_path)
+    logger.info("FileOps", f"Renamed: {old} -> {new}")
+    return json.dumps({"success": True, "renamed": old, "to": new})
+
+
+# Clipboard operations
+def copy_to_clipboard(name: str) -> str:
+    global clipboard
+    if not name:
+        return "⚠️ Select item"
+    path = current_path / name
+    if not path.exists():
+        return "❌ Not found"
+    clipboard = {"files": [str(path)], "operation": "copy"}
+    return f"📋 Copied: {name}"
+
+
+def cut_to_clipboard(name: str) -> str:
+    global clipboard
+    if not name:
+        return "⚠️ Select item"
+    path = current_path / name
+    if not path.exists():
+        return "❌ Not found"
+    clipboard = {"files": [str(path)], "operation": "cut"}
+    return f"✂️ Cut: {name}"
+
+
+def paste_from_clipboard():
+    global clipboard
+    if not clipboard["files"]:
+        return get_folder_contents(), get_breadcrumb(), "⚠️ Clipboard empty", get_quick_access_folders()
+
+    pasted = []
+    for src in clipboard["files"]:
+        src_path = Path(src)
+        if not src_path.exists():
+            continue
+
+        dest = current_path / src_path.name
+        if dest.exists():
+            base, ext = src_path.stem, src_path.suffix
+            i = 1
+            while dest.exists():
+                dest = current_path / f"{base}_copy{i}{ext}"
+                i += 1
+
+        if clipboard["operation"] == "copy":
+            if src_path.is_dir():
+                shutil.copytree(src_path, dest)
+            else:
+                shutil.copy2(src_path, dest)
+        else:
+            shutil.move(str(src_path), str(dest))
+        pasted.append(dest.name)
+
+    if clipboard["operation"] == "cut":
+        clipboard = {"files": [], "operation": None}
+
+    logger.info("FileOps", f"Pasted: {', '.join(pasted)}")
+    return get_folder_contents(), get_breadcrumb(), f"✅ Pasted: {', '.join(pasted)}", get_quick_access_folders()
+
+
+def upload_files(files, session_id: str = ""):
+    from .events import event_manager
+
+    if not files:
+        return get_folder_contents(), get_breadcrumb(), "No files", get_quick_access_folders()
+
+    uploaded = []
+    for f in files:
+        if f is None:
+            continue
+        name = Path(f.name).name
+        dest = current_path / name
+        if dest.exists():
+            base, ext = Path(name).stem, Path(name).suffix
+            i = 1
+            while dest.exists():
+                dest = current_path / f"{base}_{i}{ext}"
+                i += 1
+        shutil.copy2(f.name, dest)
+        uploaded.append(dest.name)
+
+        if session_id:
+            event_manager.track_upload(session_id, str(dest))
+
+    logger.info("FileOps", f"Uploaded: {', '.join(uploaded)}")
+    return get_folder_contents(), get_breadcrumb(), f"✅ Uploaded: {', '.join(uploaded)}", get_quick_access_folders()
+
+
+def download_file(name: str):
+    if not name:
+        return None
+    path = current_path / name
+    return str(path) if path.exists() and path.is_file() else None
+
+
+def get_file_preview(name: str) -> Tuple[Optional[str], str, str]:
+    if not name:
+        return None, "", "Select a file"
+
+    path = current_path / name
+    if not path.exists():
+        return None, "", "Not found"
+
+    if path.is_dir():
+        count = len(list(path.iterdir()))
+        return None, "", f"📁 Folder with {count} items"
+
+    stat = path.stat()
+    info = f"📄 {name}\n📊 {format_size(stat.st_size)}\n🕐 {format_timestamp(stat.st_mtime)}"
+
+    mime = get_mime_type(name)
+    if mime == 'image':
+        return str(path), "", info
+    elif mime == 'text':
+        try:
+            content = path.read_text()[:10000]
+            return None, content, info
+        except:
+            return None, "[Cannot read]", info
+
+    return None, f"[{Path(name).suffix.upper()[1:] or 'Binary'} file]", info
+
+
+def search_files(query: str):
+    if not query:
+        return get_folder_contents(), get_breadcrumb(), get_status()
+
+    results = []
+    for f in STORAGE_DIR.rglob(f"*{query}*"):
+        is_dir = f.is_dir()
+        stat = f.stat()
+        results.append([
+            get_file_icon(f.name, is_dir),
+            f.name,
+            "Folder" if is_dir else (Path(f.name).suffix.upper()[1:] or "FILE"),
+            "" if is_dir else format_size(stat.st_size),
+            format_timestamp(stat.st_mtime)
+        ])
+
+    return results, f"🔍 Search: {query}", f"Found {len(results)} items"

modules/hf_hub.py

@@ -0,0 +1,457 @@
+"""
+HuggingFace Hub Module
+Enhanced model search with filters, recommendations, and unified management.
+"""
+import json
+import requests
+import re
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional
+
+from .config import HF_API_URL, HF_TOKEN, MODELS_DIR, DOWNLOADS_DIR
+from .utils import format_size
+from .logger import logger
+
+# Text models directory
+TEXT_MODELS_DIR = MODELS_DIR / "txt"
+TEXT_MODELS_DIR.mkdir(parents=True, exist_ok=True)
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MODEL COMPATIBILITY CHECKER
+# ══════════════════════════════════════════════════════════════════════════════
+
+# Free HF Space limits (CPU, 16GB RAM, ~15GB disk)
+MAX_RECOMMENDED_SIZE_GB = 4.0  # Max recommended model size for free tier
+MAX_PARAMS_BILLION = 7.0  # Max recommended parameters
+
+def estimate_params_from_name(model_id: str) -> Optional[float]:
+    """Extract parameter count from model name (e.g., '7B', '13B', '1.1B')"""
+    name = model_id.lower()
+
+    # Common patterns: 7b, 7B, 7-b, 7_b, 7billion
+    patterns = [
+        r'(\d+\.?\d*)b(?:illion)?',  # 7b, 7B, 7.5b
+        r'(\d+\.?\d*)-?b(?:illion)?',  # 7-b
+        r'(\d+\.?\d*)_?b(?:illion)?',  # 7_b
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, name)
+        if match:
+            try:
+                return float(match.group(1))
+            except:
+                pass
+    return None
+
+
+def estimate_size_from_name(model_id: str) -> Optional[float]:
+    """Estimate GGUF Q4 size in GB from parameter count"""
+    params = estimate_params_from_name(model_id)
+    if params:
+        # Q4_K_M is roughly 0.5-0.6 GB per billion params
+        return params * 0.55
+    return None
+
+
+def check_model_compatibility(model_id: str, model_info: dict = None) -> Dict:
+    """
+    Check if model is compatible with free HF Space.
+    Returns dict with recommendation status and reason.
+    """
+    result = {
+        "recommended": False,
+        "status": "unknown",
+        "reason": "",
+        "params": None,
+        "estimated_size_gb": None
+    }
+
+    # Extract params from name
+    params = estimate_params_from_name(model_id)
+    result["params"] = params
+
+    if params:
+        result["estimated_size_gb"] = round(params * 0.55, 1)
+
+        if params <= 1.5:
+            result["recommended"] = True
+            result["status"] = "✅ Best"
+            result["reason"] = f"~{params}B params - Fast on CPU"
+        elif params <= 3:
+            result["recommended"] = True
+            result["status"] = "✅ Good"
+            result["reason"] = f"~{params}B params - Works well"
+        elif params <= MAX_PARAMS_BILLION:
+            result["recommended"] = True
+            result["status"] = "⚠️ OK"
+            result["reason"] = f"~{params}B params - May be slow"
+        elif params <= 13:
+            result["recommended"] = False
+            result["status"] = "⚠️ Large"
+            result["reason"] = f"~{params}B params - Very slow/may fail"
+        else:
+            result["recommended"] = False
+            result["status"] = "❌ Too Large"
+            result["reason"] = f"~{params}B params - Won't work on free tier"
+    else:
+        # Can't determine - check for known small models
+        lower_name = model_id.lower()
+        if any(x in lower_name for x in ['tiny', 'small', 'mini', 'phi-2', 'qwen2-0.5', 'qwen2-1.5']):
+            result["recommended"] = True
+            result["status"] = "✅ Good"
+            result["reason"] = "Small model"
+        elif any(x in lower_name for x in ['70b', '65b', '40b', '30b', '20b']):
+            result["recommended"] = False
+            result["status"] = "❌ Too Large"
+            result["reason"] = "Too large for free tier"
+        else:
+            result["status"] = "❓ Unknown"
+            result["reason"] = "Check size manually"
+
+    return result
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# ENHANCED SEARCH
+# ══════════════════════════════════════════════════════════════════════════════
+
+def search_hf_models_enhanced(
+    query: str = "",
+    task: str = "text-generation",
+    library: str = "gguf",
+    sort: str = "downloads",
+    max_params: float = 7.0,
+    recommended_only: bool = False,
+    limit: int = 30,
+    offset: int = 0
+) -> Tuple[List[List], str, int]:
+    """
+    Enhanced HuggingFace model search with filtering.
+
+    Returns:
+        - rows: List of [Model ID, Params, Size, Status, Downloads, Action]
+        - status: Status message
+        - total: Total count (for pagination)
+    """
+    try:
+        params = {
+            "limit": min(limit + 20, 100),  # Fetch extra for filtering
+            "sort": sort,
+            "direction": -1
+        }
+        if query:
+            params["search"] = query
+        if task:
+            params["pipeline_tag"] = task
+        if library:
+            params["library"] = library
+
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+        resp = requests.get(f"{HF_API_URL}/models", params=params, headers=headers, timeout=30)
+        resp.raise_for_status()
+
+        all_models = resp.json()
+
+        # Get list of installed models
+        installed = get_installed_model_ids()
+
+        rows = []
+        for m in all_models:
+            model_id = m.get("id", "")
+
+            # Check compatibility
+            compat = check_model_compatibility(model_id, m)
+
+            # Filter by max params if specified
+            if max_params and compat["params"] and compat["params"] > max_params:
+                continue
+
+            # Filter by recommended only
+            if recommended_only and not compat["recommended"]:
+                continue
+
+            # Determine if installed
+            is_installed = model_id in installed or any(model_id.replace('/', '_') in inst for inst in installed)
+            action = "✓ Installed" if is_installed else "Add"
+
+            # Format params display
+            params_display = f"{compat['params']}B" if compat['params'] else "?"
+            size_display = f"~{compat['estimated_size_gb']}GB" if compat['estimated_size_gb'] else "?"
+
+            rows.append([
+                model_id,
+                params_display,
+                size_display,
+                compat["status"],
+                f"{m.get('downloads', 0):,}",
+                action
+            ])
+
+            if len(rows) >= limit:
+                break
+
+        # Apply offset for pagination
+        if offset > 0:
+            rows = rows[offset:]
+
+        total = len(all_models)
+        logger.info("HFHub", f"Search: {query or 'all'}", {"found": len(rows), "total": total})
+        return rows, f"Found {len(rows)} models (showing {limit})", total
+
+    except Exception as e:
+        logger.error("HFHub", f"Search failed: {str(e)}")
+        return [], f"❌ {str(e)}", 0
+
+
+def get_installed_model_ids() -> List[str]:
+    """Get list of installed model IDs"""
+    installed = []
+    for d in TEXT_MODELS_DIR.iterdir():
+        if d.is_dir():
+            installed.append(d.name)
+    for f in TEXT_MODELS_DIR.glob("*.gguf"):
+        installed.append(f.stem)
+    return installed
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# UNIFIED MODEL TABLE
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_unified_model_table() -> List[List]:
+    """
+    Get unified table of installed + available models.
+    Columns: [Model ID, Type, Size, Status, Loaded, Action]
+    """
+    rows = []
+
+    # Get installed models
+    for d in TEXT_MODELS_DIR.iterdir():
+        if d.is_dir():
+            # Check for GGUF files
+            gguf_files = list(d.glob("*.gguf"))
+            if gguf_files:
+                for f in gguf_files:
+                    size = format_size(f.stat().st_size)
+                    compat = check_model_compatibility(f.stem)
+                    rows.append([
+                        f.stem,
+                        "GGUF",
+                        size,
+                        compat["status"],
+                        "",  # Loaded status filled by caller
+                        "Remove"
+                    ])
+            # Check for transformers config
+            elif (d / "config.json").exists():
+                total_size = sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
+                rows.append([
+                    d.name,
+                    "Transformers",
+                    format_size(total_size),
+                    "✅ Installed",
+                    "",
+                    "Remove"
+                ])
+
+    # Also check root level GGUF files
+    for f in TEXT_MODELS_DIR.glob("*.gguf"):
+        size = format_size(f.stat().st_size)
+        compat = check_model_compatibility(f.stem)
+        rows.append([
+            f.stem,
+            "GGUF",
+            size,
+            compat["status"],
+            "",
+            "Remove"
+        ])
+
+    return rows
+
+
+# ═════════��════════════════════════════════════════════════════════════════════
+# DOWNLOAD FUNCTIONS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def download_model_file(model_id: str, filename: str) -> str:
+    """Download a file from HuggingFace model"""
+    if not model_id or not filename:
+        return "⚠️ Enter model ID and filename"
+
+    try:
+        # Save to txt models directory
+        dest_dir = TEXT_MODELS_DIR / model_id.replace('/', '_')
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        dest_path = dest_dir / filename
+
+        url = f"https://huggingface.co/{model_id}/resolve/main/{filename}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+
+        logger.info("HFHub", f"Downloading: {model_id}/{filename}")
+
+        resp = requests.get(url, headers=headers, stream=True, timeout=300)
+        resp.raise_for_status()
+
+        # Get total size if available
+        total_size = int(resp.headers.get('content-length', 0))
+
+        downloaded = 0
+        with open(dest_path, 'wb') as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                f.write(chunk)
+                downloaded += len(chunk)
+
+        final_size = dest_path.stat().st_size
+        logger.info("HFHub", f"Downloaded: {model_id}/{filename}", {"size": format_size(final_size)})
+        return f"✅ Downloaded: {filename} ({format_size(final_size)})"
+
+    except Exception as e:
+        logger.error("HFHub", f"Download failed: {str(e)}")
+        return f"❌ {str(e)}"
+
+
+def download_from_url(url: str, filename: str = "") -> str:
+    """Download file from any URL"""
+    if not url:
+        return "⚠️ Enter URL"
+
+    try:
+        if not filename:
+            filename = url.split('/')[-1].split('?')[0] or "downloaded_file"
+
+        dest_path = TEXT_MODELS_DIR / filename
+        if dest_path.exists():
+            base, ext = Path(filename).stem, Path(filename).suffix
+            i = 1
+            while dest_path.exists():
+                dest_path = TEXT_MODELS_DIR / f"{base}_{i}{ext}"
+                i += 1
+
+        headers = {}
+        if "huggingface.co" in url and HF_TOKEN:
+            headers["Authorization"] = f"Bearer {HF_TOKEN}"
+
+        resp = requests.get(url, headers=headers, stream=True, timeout=300)
+        resp.raise_for_status()
+
+        with open(dest_path, 'wb') as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        logger.info("Download", f"Downloaded from URL: {url[:50]}...")
+        return f"✅ Downloaded: {dest_path.name} ({format_size(dest_path.stat().st_size)})"
+    except Exception as e:
+        logger.error("Download", f"Failed: {str(e)}")
+        return f"❌ {str(e)}"
+
+
+def remove_model(model_id: str) -> str:
+    """Remove a downloaded model"""
+    try:
+        # Try directory first
+        model_dir = TEXT_MODELS_DIR / model_id.replace('/', '_')
+        if model_dir.exists() and model_dir.is_dir():
+            import shutil
+            shutil.rmtree(model_dir)
+            logger.info("HFHub", f"Removed model directory: {model_id}")
+            return f"✅ Removed: {model_id}"
+
+        # Try direct GGUF file
+        for f in TEXT_MODELS_DIR.glob("*.gguf"):
+            if f.stem == model_id or model_id in f.stem:
+                f.unlink()
+                logger.info("HFHub", f"Removed model file: {f.name}")
+                return f"✅ Removed: {f.name}"
+
+        return f"⚠️ Model not found: {model_id}"
+    except Exception as e:
+        logger.error("HFHub", f"Remove failed: {str(e)}")
+        return f"❌ {str(e)}"
+
+
+def list_downloaded_models() -> str:
+    """List all downloaded models as JSON"""
+    models = []
+
+    for d in TEXT_MODELS_DIR.iterdir():
+        if d.is_dir():
+            files = list(d.rglob('*'))
+            size = sum(f.stat().st_size for f in files if f.is_file())
+            gguf_count = len(list(d.glob("*.gguf")))
+            models.append({
+                "name": d.name,
+                "type": "gguf" if gguf_count > 0 else "transformers",
+                "files": len([f for f in files if f.is_file()]),
+                "size": format_size(size)
+            })
+
+    # Also list root level GGUF files
+    for f in TEXT_MODELS_DIR.glob("*.gguf"):
+        models.append({
+            "name": f.stem,
+            "type": "gguf",
+            "files": 1,
+            "size": format_size(f.stat().st_size)
+        })
+
+    return json.dumps({"count": len(models), "models": models}, indent=2)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# GGUF FILE FINDER
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_model_files(model_id: str) -> List[Dict]:
+    """Get list of GGUF files available for a model"""
+    try:
+        url = f"{HF_API_URL}/models/{model_id}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+        resp = requests.get(url, headers=headers, timeout=30)
+        resp.raise_for_status()
+
+        data = resp.json()
+        siblings = data.get("siblings", [])
+
+        gguf_files = []
+        for s in siblings:
+            filename = s.get("rfilename", "")
+            if filename.endswith(".gguf"):
+                # Parse quantization from filename
+                quant = "unknown"
+                for q in ["Q2_K", "Q3_K_S", "Q3_K_M", "Q3_K_L", "Q4_0", "Q4_K_S", "Q4_K_M", "Q5_0", "Q5_K_S", "Q5_K_M", "Q6_K", "Q8_0", "F16", "F32"]:
+                    if q in filename.upper():
+                        quant = q
+                        break
+
+                gguf_files.append({
+                    "filename": filename,
+                    "quant": quant,
+                    "recommended": quant in ["Q4_K_M", "Q4_K_S", "Q5_K_M"]
+                })
+
+        return gguf_files
+    except Exception as e:
+        logger.error("HFHub", f"Failed to get model files: {str(e)}")
+        return []
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# LEGACY COMPATIBILITY
+# ══════════════════════════════════════════════════════════════════════════════
+
+def search_hf_models(query: str = "", task: str = "", library: str = "", sort: str = "downloads"):
+    """Legacy search function - redirects to enhanced search"""
+    rows, status, _ = search_hf_models_enhanced(
+        query=query,
+        task=task,
+        library=library,
+        sort=sort,
+        max_params=None,
+        recommended_only=False,
+        limit=30
+    )
+    # Convert to old format
+    old_rows = [[r[0], task or "text-generation", r[4], ""] for r in rows]
+    return old_rows, status

modules/logger.py

@@ -0,0 +1,143 @@
+"""
+Logging Service Module
+Centralized logging with file persistence.
+"""
+import json
+import threading
+import uuid
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+from .config import LOGS_DIR
+
+
+class LogLevel(Enum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    EVENT = "EVENT"
+
+
+@dataclass
+class LogEntry:
+    timestamp: str
+    level: str
+    category: str
+    message: str
+    details: Optional[Dict] = None
+    log_id: str = ""
+
+    def __post_init__(self):
+        if not self.log_id:
+            self.log_id = str(uuid.uuid4())[:8]
+
+
+class LoggingService:
+    """Centralized logging service with file persistence"""
+
+    def __init__(self, log_dir: Path):
+        self.log_dir = log_dir
+        self.log_file = log_dir / "app.log"
+        self.event_log = log_dir / "events.log"
+        self.error_log = log_dir / "errors.log"
+        self.max_entries = 1000
+        self._lock = threading.Lock()
+
+    def _write_log(self, entry: LogEntry, file_path: Path):
+        with self._lock:
+            try:
+                logs = []
+                if file_path.exists():
+                    try:
+                        logs = json.loads(file_path.read_text())
+                    except:
+                        logs = []
+
+                logs.append(asdict(entry))
+
+                if len(logs) > self.max_entries:
+                    logs = logs[-self.max_entries:]
+
+                file_path.write_text(json.dumps(logs, indent=2))
+            except Exception as e:
+                print(f"Log write error: {e}")
+
+    def log(self, level: LogLevel, category: str, message: str, details: Dict = None):
+        entry = LogEntry(
+            timestamp=datetime.now().isoformat(),
+            level=level.value,
+            category=category,
+            message=message,
+            details=details
+        )
+
+        self._write_log(entry, self.log_file)
+
+        if level == LogLevel.ERROR:
+            self._write_log(entry, self.error_log)
+        elif level == LogLevel.EVENT:
+            self._write_log(entry, self.event_log)
+
+        return entry.log_id
+
+    def info(self, category: str, message: str, details: Dict = None):
+        return self.log(LogLevel.INFO, category, message, details)
+
+    def error(self, category: str, message: str, details: Dict = None):
+        return self.log(LogLevel.ERROR, category, message, details)
+
+    def event(self, category: str, message: str, details: Dict = None):
+        return self.log(LogLevel.EVENT, category, message, details)
+
+    def warning(self, category: str, message: str, details: Dict = None):
+        return self.log(LogLevel.WARNING, category, message, details)
+
+    def get_logs(self, log_type: str = "all", limit: int = 100, level: str = None, category: str = None) -> List[Dict]:
+        file_map = {
+            "all": self.log_file,
+            "events": self.event_log,
+            "errors": self.error_log
+        }
+
+        file_path = file_map.get(log_type, self.log_file)
+
+        if not file_path.exists():
+            return []
+
+        try:
+            logs = json.loads(file_path.read_text())
+
+            if level:
+                logs = [l for l in logs if l.get("level") == level]
+            if category:
+                logs = [l for l in logs if l.get("category") == category]
+
+            return logs[-limit:][::-1]
+        except:
+            return []
+
+    def clear_logs(self, log_type: str = "all") -> bool:
+        try:
+            if log_type == "all":
+                for f in [self.log_file, self.event_log, self.error_log]:
+                    if f.exists():
+                        f.write_text("[]")
+            else:
+                file_map = {"events": self.event_log, "errors": self.error_log, "app": self.log_file}
+                if log_type in file_map and file_map[log_type].exists():
+                    file_map[log_type].write_text("[]")
+            return True
+        except:
+            return False
+
+    def export_logs(self, log_type: str = "all") -> str:
+        logs = self.get_logs(log_type, limit=10000)
+        return json.dumps(logs, indent=2)
+
+
+# Global logger instance
+logger = LoggingService(LOGS_DIR)

modules/system.py

@@ -0,0 +1,96 @@
+"""
+System Info Module
+System monitoring and space information.
+"""
+import os
+import json
+import platform
+import psutil
+
+from .config import STORAGE_DIR, HF_TOKEN
+from .utils import format_size
+
+
+def get_system_info() -> str:
+    """Get detailed system information"""
+    try:
+        mem = psutil.virtual_memory()
+        disk = psutil.disk_usage('/')
+        cpu = psutil.cpu_percent(interval=0.1)
+
+        return json.dumps({
+            "system": {
+                "platform": platform.system(),
+                "python": platform.python_version(),
+            },
+            "cpu": {
+                "cores": psutil.cpu_count(),
+                "usage": f"{cpu}%",
+            },
+            "memory": {
+                "total": format_size(mem.total),
+                "used": format_size(mem.used),
+                "percent": f"{mem.percent}%",
+            },
+            "disk": {
+                "total": format_size(disk.total),
+                "free": format_size(disk.free),
+                "percent": f"{disk.percent}%",
+            }
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def get_system_dashboard() -> str:
+    """Get ASCII dashboard with bars"""
+    try:
+        mem = psutil.virtual_memory()
+        disk = psutil.disk_usage('/')
+        cpu = psutil.cpu_percent(interval=0.1)
+
+        def bar(pct):
+            filled = int(pct / 5)
+            return '█' * filled + '░' * (20 - filled)
+
+        return f"""
+╔════════════════════════════════════════════════════════╗
+║              📊 SYSTEM DASHBOARD                       ║
+╠════════════════════════════════════════════════════════╣
+║  💾 RAM:  [{bar(mem.percent)}] {mem.percent:5.1f}%     ║
+║          {format_size(mem.used):>10} / {format_size(mem.total):<10}       ║
+╠════════════════════════════════════════════════════════╣
+║  💿 DISK: [{bar(disk.percent)}] {disk.percent:5.1f}%     ║
+║          {format_size(disk.used):>10} / {format_size(disk.total):<10}       ║
+╠════════════════════════════════════════════════════════╣
+║  🔥 CPU:  [{bar(cpu)}] {cpu:5.1f}%     ║
+║          {psutil.cpu_count()} cores                              ║
+╚════════════════════════════════════════════════════════╝
+""".strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def get_space_info() -> str:
+    """Get HuggingFace space information"""
+    return json.dumps({
+        "space_id": os.getenv("SPACE_ID", "local"),
+        "author": os.getenv("SPACE_AUTHOR_NAME", "unknown"),
+        "hardware": os.getenv("SPACE_HARDWARE", "cpu-basic"),
+        "hf_token": "set" if HF_TOKEN else "not_set",
+        "storage_path": str(STORAGE_DIR),
+    }, indent=2)
+
+
+def get_storage_stats() -> str:
+    """Get storage statistics"""
+    try:
+        files = list(STORAGE_DIR.rglob('*'))
+        total = sum(f.stat().st_size for f in files if f.is_file())
+        return json.dumps({
+            "files": len([f for f in files if f.is_file()]),
+            "folders": len([f for f in files if f.is_dir()]),
+            "total_size": format_size(total),
+        }, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)})

modules/text_ai.py

@@ -0,0 +1,842 @@
+"""
+TextAI Module
+Chat and Roleplay with LLM support - GGUF and Transformers
+Universal inference system with context, prompts, LoRA support
+"""
+import json
+import uuid
+import threading
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional, Generator, Any
+from dataclasses import dataclass, asdict, field
+
+from .config import STORAGE_DIR, MODELS_DIR
+from .logger import logger
+
+# Lazy import flags - these will be loaded only when needed
+_llama_cpp = None
+_transformers = None
+_torch = None
+
+def _get_llama_cpp():
+    """Lazy load llama-cpp-python"""
+    global _llama_cpp
+    if _llama_cpp is None:
+        try:
+            from llama_cpp import Llama
+            _llama_cpp = Llama
+            logger.info("TextAI", "llama-cpp-python loaded successfully")
+        except ImportError as e:
+            logger.warning("TextAI", f"llama-cpp-python not available: {e}")
+            _llama_cpp = False
+    return _llama_cpp if _llama_cpp else None
+
+def _get_transformers():
+    """Lazy load transformers"""
+    global _transformers, _torch
+    if _transformers is None:
+        try:
+            from transformers import AutoModelForCausalLM, AutoTokenizer
+            import torch
+            _transformers = {"AutoModelForCausalLM": AutoModelForCausalLM, "AutoTokenizer": AutoTokenizer}
+            _torch = torch
+            logger.info("TextAI", "transformers loaded successfully")
+        except ImportError as e:
+            logger.warning("TextAI", f"transformers not available: {e}")
+            _transformers = False
+    return _transformers if _transformers else None
+
+# Text models directory
+TEXT_MODELS_DIR = MODELS_DIR / "txt"
+TEXT_MODELS_DIR.mkdir(parents=True, exist_ok=True)
+
+# Sessions directory
+SESSIONS_DIR = STORAGE_DIR / "chat_sessions"
+SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+# Model config file
+MODEL_CONFIG_FILE = TEXT_MODELS_DIR / "model_config.json"
+
+
+@dataclass
+class ChatMessage:
+    role: str  # system, user, assistant
+    content: str
+    timestamp: str = ""
+
+    def __post_init__(self):
+        if not self.timestamp:
+            self.timestamp = datetime.now().isoformat()
+
+
+@dataclass
+class InferenceConfig:
+    """Universal inference configuration"""
+    max_tokens: int = 512
+    temperature: float = 0.7
+    top_p: float = 0.9
+    top_k: int = 40
+    repeat_penalty: float = 1.1
+    stop_sequences: List[str] = field(default_factory=list)
+    # LoRA settings
+    lora_path: str = ""
+    lora_scale: float = 1.0
+    # Context settings
+    context_length: int = 4096
+    # Extra options
+    seed: int = -1
+    stream: bool = False
+
+
+@dataclass
+class ChatSession:
+    session_id: str
+    title: str
+    messages: List[Dict]
+    created_at: str
+    updated_at: str
+    model_id: str = ""
+    session_type: str = "chat"  # chat or roleplay
+    system_prompt: str = ""
+    # Personalization
+    inference_config: Dict = field(default_factory=dict)
+    custom_settings: Dict = field(default_factory=dict)
+
+
+class ModelManager:
+    """Manages LLM models - loading, switching, inference"""
+
+    def __init__(self):
+        self.current_model = None
+        self.current_model_id = None
+        self.model_type = None  # "gguf" or "transformers"
+        self.tokenizer = None
+        self.lora_path = None
+        self.default_config = InferenceConfig()
+        self._lock = threading.Lock()
+        self._load_config()
+
+    def _load_config(self):
+        """Load model configuration"""
+        if MODEL_CONFIG_FILE.exists():
+            try:
+                self.config = json.loads(MODEL_CONFIG_FILE.read_text())
+            except:
+                self.config = {"default_model": None, "models": {}}
+        else:
+            self.config = {"default_model": None, "models": {}}
+            self._save_config()
+
+    def _save_config(self):
+        """Save model configuration"""
+        MODEL_CONFIG_FILE.write_text(json.dumps(self.config, indent=2))
+
+    def get_available_models(self) -> List[Dict]:
+        """List all available models in /models/txt/"""
+        models = []
+
+        # Scan for GGUF files
+        for f in TEXT_MODELS_DIR.rglob("*.gguf"):
+            rel_path = str(f.relative_to(TEXT_MODELS_DIR))
+            size_gb = f.stat().st_size / (1024**3)
+            models.append({
+                "id": rel_path,
+                "name": f.stem,
+                "type": "gguf",
+                "size": f"{size_gb:.2f} GB",
+                "path": str(f),
+                "loaded": rel_path == self.current_model_id
+            })
+
+        # Scan for transformers models (directories with config.json)
+        for d in TEXT_MODELS_DIR.iterdir():
+            if d.is_dir() and (d / "config.json").exists():
+                models.append({
+                    "id": d.name,
+                    "name": d.name,
+                    "type": "transformers",
+                    "size": "varies",
+                    "path": str(d),
+                    "loaded": d.name == self.current_model_id
+                })
+
+        return models
+
+    def load_model(self, model_id: str) -> Dict:
+        """Load a model by ID"""
+        with self._lock:
+            try:
+                # Unload current model
+                if self.current_model is not None:
+                    self.unload_model()
+
+                models = self.get_available_models()
+                model_info = next((m for m in models if m["id"] == model_id), None)
+
+                if not model_info:
+                    return {"success": False, "error": f"Model not found: {model_id}"}
+
+                if model_info["type"] == "gguf":
+                    return self._load_gguf(model_info)
+                else:
+                    return self._load_transformers(model_info)
+
+            except Exception as e:
+                logger.error("ModelManager", f"Failed to load model: {str(e)}")
+                return {"success": False, "error": str(e)}
+
+    def _load_gguf(self, model_info: Dict, lora_path: str = "", n_ctx: int = 4096) -> Dict:
+        """Load GGUF model with llama-cpp-python"""
+        try:
+            Llama = _get_llama_cpp()
+            if Llama is None:
+                return {"success": False, "error": "llama-cpp-python not installed. Install with: pip install llama-cpp-python"}
+
+            # Build model kwargs
+            model_kwargs = {
+                "model_path": model_info["path"],
+                "n_ctx": n_ctx,
+                "n_threads": 4,
+                "n_gpu_layers": 0,  # CPU only
+                "verbose": False
+            }
+
+            # Add LoRA if specified
+            if lora_path and Path(lora_path).exists():
+                model_kwargs["lora_path"] = lora_path
+                logger.info("ModelManager", f"Loading with LoRA: {lora_path}")
+
+            self.current_model = Llama(**model_kwargs)
+            self.current_model_id = model_info["id"]
+            self.model_type = "gguf"
+            self.lora_path = lora_path
+
+            logger.info("ModelManager", f"Loaded GGUF model: {model_info['name']}")
+            return {"success": True, "model": model_info["name"], "type": "gguf", "lora": lora_path or None}
+
+        except Exception as e:
+            logger.error("ModelManager", f"GGUF load error: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    def _load_transformers(self, model_info: Dict) -> Dict:
+        """Load transformers model"""
+        try:
+            tf = _get_transformers()
+            if tf is None:
+                return {"success": False, "error": "transformers not installed. Install with: pip install transformers torch"}
+
+            global _torch
+            AutoModelForCausalLM = tf["AutoModelForCausalLM"]
+            AutoTokenizer = tf["AutoTokenizer"]
+
+            self.tokenizer = AutoTokenizer.from_pretrained(model_info["path"])
+            self.current_model = AutoModelForCausalLM.from_pretrained(
+                model_info["path"],
+                torch_dtype=_torch.float32,
+                device_map="cpu",
+                low_cpu_mem_usage=True
+            )
+            self.current_model_id = model_info["id"]
+            self.model_type = "transformers"
+
+            logger.info("ModelManager", f"Loaded transformers model: {model_info['name']}")
+            return {"success": True, "model": model_info["name"], "type": "transformers"}
+
+        except Exception as e:
+            logger.error("ModelManager", f"Transformers load error: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    def unload_model(self):
+        """Unload current model to free memory"""
+        if self.current_model is not None:
+            del self.current_model
+            self.current_model = None
+
+        if self.tokenizer is not None:
+            del self.tokenizer
+            self.tokenizer = None
+
+        self.current_model_id = None
+        self.model_type = None
+
+        # Force garbage collection
+        import gc
+        gc.collect()
+
+        logger.info("ModelManager", "Model unloaded")
+
+    def generate(
+        self,
+        messages: List[Dict],
+        max_tokens: int = 512,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        stream: bool = False
+    ) -> str:
+        """Generate response from loaded model"""
+        if self.current_model is None:
+            return "[Error: No model loaded]"
+
+        try:
+            if self.model_type == "gguf":
+                return self._generate_gguf(messages, max_tokens, temperature, top_p, stream)
+            else:
+                return self._generate_transformers(messages, max_tokens, temperature, top_p)
+        except Exception as e:
+            logger.error("ModelManager", f"Generation error: {str(e)}")
+            return f"[Error: {str(e)}]"
+
+    def _generate_gguf(
+        self,
+        messages: List[Dict],
+        max_tokens: int,
+        temperature: float,
+        top_p: float,
+        stream: bool
+    ) -> str:
+        """Generate with GGUF model"""
+        response = self.current_model.create_chat_completion(
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            stream=False
+        )
+        return response["choices"][0]["message"]["content"]
+
+    def _generate_transformers(
+        self,
+        messages: List[Dict],
+        max_tokens: int,
+        temperature: float,
+        top_p: float
+    ) -> str:
+        """Generate with transformers model"""
+        global _torch
+        if _torch is None:
+            return "[Error: torch not loaded]"
+
+        # Format messages
+        prompt = ""
+        for msg in messages:
+            if msg["role"] == "system":
+                prompt += f"System: {msg['content']}\n\n"
+            elif msg["role"] == "user":
+                prompt += f"User: {msg['content']}\n\n"
+            elif msg["role"] == "assistant":
+                prompt += f"Assistant: {msg['content']}\n\n"
+        prompt += "Assistant: "
+
+        inputs = self.tokenizer(prompt, return_tensors="pt")
+
+        with _torch.no_grad():
+            outputs = self.current_model.generate(
+                inputs.input_ids,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+
+        response = self.tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+        return response.strip()
+
+    def get_status(self) -> Dict:
+        """Get current model status"""
+        return {
+            "loaded": self.current_model is not None,
+            "model_id": self.current_model_id,
+            "model_type": self.model_type
+        }
+
+
+class SessionManager:
+    """Manages chat sessions - create, save, load, list"""
+
+    def __init__(self):
+        self.sessions_dir = SESSIONS_DIR
+
+    def create_session(
+        self,
+        title: str = "",
+        session_type: str = "chat",
+        system_prompt: str = "",
+        model_id: str = ""
+    ) -> ChatSession:
+        """Create a new chat session"""
+        session_id = str(uuid.uuid4())[:8]
+
+        if not title:
+            title = f"{'Chat' if session_type == 'chat' else 'Roleplay'} {datetime.now().strftime('%m/%d %H:%M')}"
+
+        session = ChatSession(
+            session_id=session_id,
+            title=title,
+            messages=[],
+            created_at=datetime.now().isoformat(),
+            updated_at=datetime.now().isoformat(),
+            model_id=model_id,
+            session_type=session_type,
+            system_prompt=system_prompt
+        )
+
+        self._save_session(session)
+        logger.event("Session", f"Created session: {session_id}", {"type": session_type})
+
+        return session
+
+    def _save_session(self, session: ChatSession):
+        """Save session to file"""
+        file_path = self.sessions_dir / f"{session.session_id}.json"
+        file_path.write_text(json.dumps(asdict(session), indent=2))
+
+    def load_session(self, session_id: str) -> Optional[ChatSession]:
+        """Load a session by ID"""
+        file_path = self.sessions_dir / f"{session_id}.json"
+        if not file_path.exists():
+            return None
+
+        try:
+            data = json.loads(file_path.read_text())
+            return ChatSession(**data)
+        except:
+            return None
+
+    def update_session(self, session: ChatSession):
+        """Update session (auto-save)"""
+        session.updated_at = datetime.now().isoformat()
+        self._save_session(session)
+
+    def add_message(self, session_id: str, role: str, content: str) -> Optional[ChatSession]:
+        """Add a message to session"""
+        session = self.load_session(session_id)
+        if not session:
+            return None
+
+        message = ChatMessage(role=role, content=content)
+        session.messages.append(asdict(message))
+        self.update_session(session)
+
+        return session
+
+    def list_sessions(self, session_type: str = None) -> List[Dict]:
+        """List all sessions"""
+        sessions = []
+
+        for f in self.sessions_dir.glob("*.json"):
+            try:
+                data = json.loads(f.read_text())
+                if session_type and data.get("session_type") != session_type:
+                    continue
+
+                sessions.append({
+                    "session_id": data["session_id"],
+                    "title": data["title"],
+                    "session_type": data.get("session_type", "chat"),
+                    "message_count": len(data.get("messages", [])),
+                    "updated_at": data["updated_at"],
+                    "model_id": data.get("model_id", "")
+                })
+            except:
+                continue
+
+        # Sort by updated_at descending
+        sessions.sort(key=lambda x: x["updated_at"], reverse=True)
+        return sessions
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session"""
+        file_path = self.sessions_dir / f"{session_id}.json"
+        if file_path.exists():
+            file_path.unlink()
+            logger.event("Session", f"Deleted session: {session_id}")
+            return True
+        return False
+
+    def rename_session(self, session_id: str, new_title: str) -> bool:
+        """Rename a session"""
+        session = self.load_session(session_id)
+        if session:
+            session.title = new_title
+            self.update_session(session)
+            return True
+        return False
+
+    def clear_session(self, session_id: str) -> bool:
+        """Clear messages from session"""
+        session = self.load_session(session_id)
+        if session:
+            session.messages = []
+            self.update_session(session)
+            return True
+        return False
+
+
+# Global instances
+model_manager = ModelManager()
+session_manager = SessionManager()
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# API FUNCTIONS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def api_list_models() -> str:
+    """API: List available models"""
+    models = model_manager.get_available_models()
+    return json.dumps({"models": models, "count": len(models)}, indent=2)
+
+
+def api_load_model(model_id: str) -> str:
+    """API: Load a model"""
+    result = model_manager.load_model(model_id)
+    return json.dumps(result)
+
+
+def api_unload_model() -> str:
+    """API: Unload current model"""
+    model_manager.unload_model()
+    return json.dumps({"success": True})
+
+
+def api_model_status() -> str:
+    """API: Get model status"""
+    return json.dumps(model_manager.get_status())
+
+
+def api_chat(
+    session_id: str,
+    message: str,
+    max_tokens: int = 512,
+    temperature: float = 0.7
+) -> str:
+    """API: Send chat message and get response"""
+    session = session_manager.load_session(session_id)
+    if not session:
+        return json.dumps({"success": False, "error": "Session not found"})
+
+    if model_manager.current_model is None:
+        return json.dumps({"success": False, "error": "No model loaded"})
+
+    # Add user message
+    session_manager.add_message(session_id, "user", message)
+
+    # Build messages for model
+    messages = []
+    if session.system_prompt:
+        messages.append({"role": "system", "content": session.system_prompt})
+
+    for msg in session.messages:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+
+    # Generate response
+    response = model_manager.generate(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature
+    )
+
+    # Add assistant response
+    session_manager.add_message(session_id, "assistant", response)
+
+    return json.dumps({
+        "success": True,
+        "response": response,
+        "session_id": session_id
+    })
+
+
+def api_create_session(
+    title: str = "",
+    session_type: str = "chat",
+    system_prompt: str = ""
+) -> str:
+    """API: Create new session"""
+    model_id = model_manager.current_model_id or ""
+    session = session_manager.create_session(title, session_type, system_prompt, model_id)
+    return json.dumps({"success": True, "session_id": session.session_id, "title": session.title})
+
+
+def api_list_sessions(session_type: str = "") -> str:
+    """API: List all sessions"""
+    sessions = session_manager.list_sessions(session_type if session_type else None)
+    return json.dumps({"sessions": sessions, "count": len(sessions)}, indent=2)
+
+
+def api_get_session(session_id: str) -> str:
+    """API: Get session with messages"""
+    session = session_manager.load_session(session_id)
+    if not session:
+        return json.dumps({"success": False, "error": "Session not found"})
+    return json.dumps({"success": True, "session": asdict(session)}, indent=2)
+
+
+def api_delete_session(session_id: str) -> str:
+    """API: Delete session"""
+    success = session_manager.delete_session(session_id)
+    return json.dumps({"success": success})
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# UNIVERSAL INFERENCE API
+# ══════════════════════════════════════════════════════════════════════════════
+
+def api_inference(
+    prompt: str = "",
+    messages: str = "[]",
+    system_prompt: str = "",
+    max_tokens: int = 512,
+    temperature: float = 0.7,
+    top_p: float = 0.9,
+    top_k: int = 40,
+    repeat_penalty: float = 1.1,
+    stop_sequences: str = "[]",
+    context: str = "",
+    extra_context: str = ""
+) -> str:
+    """
+    API: Universal inference endpoint
+
+    Args:
+        prompt: Direct prompt (if not using messages)
+        messages: JSON array of {role, content} messages
+        system_prompt: System prompt to prepend
+        max_tokens: Maximum tokens to generate
+        temperature: Sampling temperature
+        top_p: Top-p sampling
+        top_k: Top-k sampling
+        repeat_penalty: Repetition penalty
+        stop_sequences: JSON array of stop sequences
+        context: Additional context to include
+        extra_context: Extra context (e.g., from RAG)
+
+    Returns:
+        JSON with response and metadata
+    """
+    if model_manager.current_model is None:
+        return json.dumps({"success": False, "error": "No model loaded"})
+
+    try:
+        # Parse messages if provided
+        msg_list = json.loads(messages) if messages and messages != "[]" else []
+        stop_list = json.loads(stop_sequences) if stop_sequences and stop_sequences != "[]" else []
+
+        # Build full message list
+        full_messages = []
+
+        # Add system prompt if provided
+        if system_prompt:
+            full_messages.append({"role": "system", "content": system_prompt})
+
+        # Add context if provided
+        if context or extra_context:
+            context_text = f"{context}\n{extra_context}".strip()
+            full_messages.append({"role": "system", "content": f"Context:\n{context_text}"})
+
+        # Add conversation messages
+        full_messages.extend(msg_list)
+
+        # Add direct prompt if provided
+        if prompt:
+            full_messages.append({"role": "user", "content": prompt})
+
+        if not full_messages:
+            return json.dumps({"success": False, "error": "No prompt or messages provided"})
+
+        # Generate response
+        response = model_manager.generate(
+            messages=full_messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p
+        )
+
+        return json.dumps({
+            "success": True,
+            "response": response,
+            "model": model_manager.current_model_id,
+            "tokens_used": len(response.split()),  # Approximate
+            "config": {
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": top_p
+            }
+        })
+
+    except Exception as e:
+        logger.error("API", f"Inference error: {str(e)}")
+        return json.dumps({"success": False, "error": str(e)})
+
+
+def api_chat_with_config(
+    session_id: str,
+    message: str,
+    config: str = "{}"
+) -> str:
+    """
+    API: Chat with custom inference config
+
+    Args:
+        session_id: Session ID
+        message: User message
+        config: JSON config with max_tokens, temperature, top_p, etc.
+    """
+    session = session_manager.load_session(session_id)
+    if not session:
+        return json.dumps({"success": False, "error": "Session not found"})
+
+    if model_manager.current_model is None:
+        return json.dumps({"success": False, "error": "No model loaded"})
+
+    try:
+        cfg = json.loads(config) if config and config != "{}" else {}
+        max_tokens = cfg.get("max_tokens", 512)
+        temperature = cfg.get("temperature", 0.7)
+        top_p = cfg.get("top_p", 0.9)
+
+        # Add user message
+        session_manager.add_message(session_id, "user", message)
+
+        # Build messages for model - include full history for context consistency
+        messages = []
+        if session.system_prompt:
+            messages.append({"role": "system", "content": session.system_prompt})
+
+        # Load fresh session to get updated messages
+        session = session_manager.load_session(session_id)
+        for msg in session.messages:
+            messages.append({"role": msg["role"], "content": msg["content"]})
+
+        # Generate response
+        response = model_manager.generate(
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p
+        )
+
+        # Add assistant response
+        session_manager.add_message(session_id, "assistant", response)
+
+        return json.dumps({
+            "success": True,
+            "response": response,
+            "session_id": session_id,
+            "message_count": len(session.messages) + 1,
+            "config_used": {"max_tokens": max_tokens, "temperature": temperature}
+        })
+
+    except Exception as e:
+        return json.dumps({"success": False, "error": str(e)})
+
+
+def api_get_session_context(session_id: str, include_system: bool = True) -> str:
+    """
+    API: Get full session context for long chats
+    Returns all messages formatted for external use
+    """
+    session = session_manager.load_session(session_id)
+    if not session:
+        return json.dumps({"success": False, "error": "Session not found"})
+
+    messages = []
+    if include_system and session.system_prompt:
+        messages.append({"role": "system", "content": session.system_prompt})
+
+    for msg in session.messages:
+        messages.append({
+            "role": msg["role"],
+            "content": msg["content"],
+            "timestamp": msg.get("timestamp", "")
+        })
+
+    return json.dumps({
+        "success": True,
+        "session_id": session_id,
+        "title": session.title,
+        "session_type": session.session_type,
+        "message_count": len(session.messages),
+        "messages": messages,
+        "system_prompt": session.system_prompt
+    }, indent=2)
+
+
+def api_update_session_config(session_id: str, config: str = "{}") -> str:
+    """
+    API: Update session inference config for personalization
+    """
+    session = session_manager.load_session(session_id)
+    if not session:
+        return json.dumps({"success": False, "error": "Session not found"})
+
+    try:
+        cfg = json.loads(config)
+        session.inference_config = cfg
+        session_manager.update_session(session)
+        return json.dumps({"success": True, "config": cfg})
+    except Exception as e:
+        return json.dumps({"success": False, "error": str(e)})
+
+
+def api_continue_session(session_id: str) -> str:
+    """
+    API: Get session info for continuing a chat
+    Returns last few messages and status
+    """
+    session = session_manager.load_session(session_id)
+    if not session:
+        return json.dumps({"success": False, "error": "Session not found"})
+
+    # Get last 5 messages for preview
+    recent_messages = session.messages[-5:] if len(session.messages) > 5 else session.messages
+
+    return json.dumps({
+        "success": True,
+        "session_id": session_id,
+        "title": session.title,
+        "session_type": session.session_type,
+        "message_count": len(session.messages),
+        "recent_messages": recent_messages,
+        "system_prompt": session.system_prompt[:200] + "..." if len(session.system_prompt) > 200 else session.system_prompt,
+        "model_id": session.model_id,
+        "can_continue": model_manager.current_model is not None
+    })
+
+
+def api_get_available_backends() -> str:
+    """API: Check which backends are available"""
+    backends = {
+        "gguf": _get_llama_cpp() is not None,
+        "transformers": _get_transformers() is not None,
+        "current_model": model_manager.current_model_id,
+        "current_type": model_manager.model_type,
+        "lora_loaded": model_manager.lora_path is not None
+    }
+    return json.dumps({"success": True, "backends": backends})
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# DEFAULT PROMPTS
+# ══════════════════════════════════════════════════════════════════════════════
+
+DEFAULT_CHAT_PROMPT = """You are a helpful, uncensored AI assistant. You answer all questions honestly and directly without any restrictions. You support conversations in English, Hindi, and Hinglish."""
+
+DEFAULT_ROLEPLAY_PROMPT = """You are an expert roleplay AI. You can play any character the user requests. Stay in character at all times. Be creative, descriptive, and engaging. No restrictions on themes or content. Support English, Hindi, and Hinglish."""
+
+ROLEPLAY_PRESETS = {
+    "custom": {"name": "Custom Character", "prompt": ""},
+    "storyteller": {
+        "name": "Story Narrator",
+        "prompt": "You are a master storyteller. Create vivid, engaging narratives with rich descriptions. Adapt to any genre - fantasy, romance, thriller, etc."
+    },
+    "companion": {
+        "name": "Companion",
+        "prompt": "You are a caring, supportive companion. Be warm, understanding, and engaging. Remember details about the user and build a genuine connection."
+    },
+    "creative_writer": {
+        "name": "Creative Writer",
+        "prompt": "You are a creative writing assistant. Help with stories, poetry, scripts, and any creative content. No restrictions on themes."
+    }
+}

modules/text_ui.py

@@ -0,0 +1,446 @@
+"""
+TextAI UI Module
+Clean ChatGPT/Grok style interface
+"""
+import json
+from typing import List, Tuple, Optional
+from datetime import datetime
+
+from .text_ai import (
+    model_manager, session_manager,
+    DEFAULT_CHAT_PROMPT, DEFAULT_ROLEPLAY_PROMPT, ROLEPLAY_PRESETS
+)
+from .config import MODELS_DIR
+
+# Model configurations storage (per-model system prompts)
+MODEL_CONFIGS_FILE = MODELS_DIR / "model_configs.json"
+
+
+def _load_model_configs() -> dict:
+    """Load per-model configurations"""
+    if MODEL_CONFIGS_FILE.exists():
+        try:
+            return json.loads(MODEL_CONFIGS_FILE.read_text())
+        except:
+            pass
+    return {}
+
+
+def _save_model_configs(configs: dict):
+    """Save per-model configurations"""
+    MODEL_CONFIGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    MODEL_CONFIGS_FILE.write_text(json.dumps(configs, indent=2))
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# CHAT SESSION HELPERS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_chat_list() -> List[List[str]]:
+    """Get all chat sessions sorted by recent - clean display"""
+    sessions = session_manager.list_sessions()  # All types
+    rows = []
+    for s in sessions[:30]:
+        # Show only title (auto-generated or renamed)
+        title = s["title"][:35] + "..." if len(s["title"]) > 35 else s["title"]
+        session_type = "🎭" if s.get("session_type") == "roleplay" else "💬"
+        rows.append([s["session_id"], f"{session_type} {title}"])
+    return rows
+
+
+def get_model_choices() -> List[str]:
+    """Get available models for dropdown"""
+    models = model_manager.get_available_models()
+    choices = []
+    for m in models:
+        status = "✓ " if m["loaded"] else ""
+        choices.append(f"{status}{m['name']} ({m['type']})")
+    return choices if choices else ["No models available"]
+
+
+def get_current_model_display() -> str:
+    """Get current model for display"""
+    status = model_manager.get_status()
+    if status["loaded"]:
+        return f"{status['model_id']}"
+    return "No model loaded"
+
+
+def format_chat_history(session_id: str) -> List[dict]:
+    """Format session messages for Gradio Chatbot (new format)"""
+    session = session_manager.load_session(session_id)
+    if not session:
+        return []
+
+    history = []
+    for msg in session.messages:
+        if msg["role"] == "user":
+            history.append({"role": "user", "content": msg["content"]})
+        elif msg["role"] == "assistant":
+            history.append({"role": "assistant", "content": msg["content"]})
+
+    return history
+
+
+def format_chat_history_tuples(session_id: str) -> List[Tuple[str, str]]:
+    """Format session messages for Gradio Chatbot (tuple format for compatibility)"""
+    session = session_manager.load_session(session_id)
+    if not session:
+        return []
+
+    history = []
+    user_msg = None
+
+    for msg in session.messages:
+        if msg["role"] == "user":
+            user_msg = msg["content"]
+        elif msg["role"] == "assistant" and user_msg:
+            history.append((user_msg, msg["content"]))
+            user_msg = None
+
+    if user_msg:
+        history.append((user_msg, None))
+
+    return history
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MAIN CHAT FUNCTIONS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def ui_new_chat(mode: str = "chat"):
+    """Create new chat session"""
+    # Get system prompt based on mode and current model
+    if mode == "roleplay":
+        system_prompt = DEFAULT_ROLEPLAY_PROMPT
+        session_type = "roleplay"
+    else:
+        # Use model-specific prompt if available
+        model_id = model_manager.current_model_id
+        configs = _load_model_configs()
+        system_prompt = configs.get(model_id, {}).get("system_prompt", DEFAULT_CHAT_PROMPT)
+        session_type = "chat"
+
+    session = session_manager.create_session("", session_type, system_prompt)
+    return (
+        session.session_id,
+        [],
+        get_chat_list(),
+        session.title
+    )
+
+
+def ui_load_session(evt, sessions_data):
+    """Load session from sidebar click"""
+    try:
+        if hasattr(evt, 'index') and evt.index[0] < len(sessions_data):
+            session_id = sessions_data[evt.index[0]][0]
+            session = session_manager.load_session(session_id)
+            if session:
+                history = format_chat_history_tuples(session_id)
+                return session_id, history, session.title, session.session_type == "roleplay"
+    except:
+        pass
+    return "", [], "", False
+
+
+def ui_send_message(
+    session_id: str,
+    message: str,
+    history: List,
+    max_tokens: int,
+    temperature: float,
+    is_roleplay: bool = False
+):
+    """Send message and stream response"""
+    if not session_id:
+        # Auto-create session
+        mode = "roleplay" if is_roleplay else "chat"
+        session_id, _, _, _ = ui_new_chat(mode)
+
+    if not message.strip():
+        yield history, "", session_id, get_chat_list()
+        return
+
+    if model_manager.current_model is None:
+        history = history + [(message, "Please load a model first from the menu.")]
+        yield history, "", session_id, get_chat_list()
+        return
+
+    # Add user message
+    history = history + [(message, None)]
+    yield history, "", session_id, get_chat_list()
+
+    # Get response
+    from .text_ai import api_chat
+    result = json.loads(api_chat(session_id, message, max_tokens, temperature))
+
+    if result["success"]:
+        history[-1] = (message, result["response"])
+        # Update title if first message
+        session = session_manager.load_session(session_id)
+        title = session.title if session else ""
+    else:
+        history[-1] = (message, f"Error: {result.get('error', 'Unknown error')}")
+        title = ""
+
+    yield history, "", session_id, get_chat_list()
+
+
+def ui_rename_session(session_id: str, new_title: str):
+    """Rename current session"""
+    if session_id and new_title.strip():
+        session_manager.rename_session(session_id, new_title.strip())
+        return get_chat_list(), new_title.strip()
+    return get_chat_list(), ""
+
+
+def ui_delete_session(session_id: str):
+    """Delete current session"""
+    if session_id:
+        session_manager.delete_session(session_id)
+    return "", [], get_chat_list(), ""
+
+
+def ui_clear_chat(session_id: str):
+    """Clear current chat messages"""
+    if session_id:
+        session_manager.clear_session(session_id)
+    return []
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MODEL MANAGEMENT (for Tools tab)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_models_table() -> List[List[str]]:
+    """Get models for table display"""
+    models = model_manager.get_available_models()
+    rows = []
+    for m in models:
+        configs = _load_model_configs()
+        has_prompt = "✓" if m["id"] in configs else ""
+        rows.append([
+            "●" if m["loaded"] else "",
+            m["name"],
+            m["type"],
+            m["size"],
+            has_prompt
+        ])
+    return rows
+
+
+def ui_load_model_by_index(evt, models_data):
+    """Load model by clicking on table row"""
+    try:
+        if hasattr(evt, 'index') and evt.index[0] < len(models_data):
+            models = model_manager.get_available_models()
+            if evt.index[0] < len(models):
+                model_id = models[evt.index[0]]["id"]
+                result = model_manager.load_model(model_id)
+                status = f"Loaded: {model_id}" if result.get("success") else f"Error: {result.get('error')}"
+                return get_models_table(), get_current_model_display(), status
+    except Exception as e:
+        return get_models_table(), get_current_model_display(), f"Error: {str(e)}"
+    return get_models_table(), get_current_model_display(), ""
+
+
+def ui_unload_model():
+    """Unload current model"""
+    model_manager.unload_model()
+    return get_models_table(), get_current_model_display(), "Model unloaded"
+
+
+def ui_save_model_prompt(model_name: str, system_prompt: str):
+    """Save system prompt for a model"""
+    if not model_name:
+        return "Select a model first"
+
+    # Find model ID from name
+    models = model_manager.get_available_models()
+    model_id = None
+    for m in models:
+        if m["name"] == model_name or m["id"] == model_name:
+            model_id = m["id"]
+            break
+
+    if not model_id:
+        return "Model not found"
+
+    configs = _load_model_configs()
+    if model_id not in configs:
+        configs[model_id] = {}
+    configs[model_id]["system_prompt"] = system_prompt
+    _save_model_configs(configs)
+
+    return f"Saved prompt for {model_name}"
+
+
+def ui_get_model_prompt(model_name: str) -> str:
+    """Get system prompt for a model"""
+    models = model_manager.get_available_models()
+    model_id = None
+    for m in models:
+        if m["name"] == model_name or m["id"] == model_name:
+            model_id = m["id"]
+            break
+
+    if model_id:
+        configs = _load_model_configs()
+        return configs.get(model_id, {}).get("system_prompt", DEFAULT_CHAT_PROMPT)
+    return DEFAULT_CHAT_PROMPT
+
+
+def ui_delete_model_config(model_name: str):
+    """Delete model from config (not the file)"""
+    models = model_manager.get_available_models()
+    model_id = None
+    for m in models:
+        if m["name"] == model_name:
+            model_id = m["id"]
+            break
+
+    if model_id:
+        configs = _load_model_configs()
+        if model_id in configs:
+            del configs[model_id]
+            _save_model_configs(configs)
+            return get_models_table(), "Config removed"
+    return get_models_table(), "Model not found"
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PERSONA MANAGEMENT
+# ══════════════════════════════════════════════════════════════════════════════
+
+PERSONAS_FILE = MODELS_DIR.parent / "storage" / "personas.json"
+
+
+def _load_personas() -> dict:
+    """Load saved personas"""
+    if PERSONAS_FILE.exists():
+        try:
+            return json.loads(PERSONAS_FILE.read_text())
+        except:
+            pass
+    return {"default": {"name": "Default", "prompt": DEFAULT_CHAT_PROMPT}}
+
+
+def _save_personas(personas: dict):
+    """Save personas"""
+    PERSONAS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    PERSONAS_FILE.write_text(json.dumps(personas, indent=2))
+
+
+def get_persona_choices() -> List[str]:
+    """Get persona names for dropdown"""
+    personas = _load_personas()
+    return list(personas.keys())
+
+
+def ui_save_persona(name: str, prompt: str):
+    """Save a persona"""
+    if not name.strip():
+        return get_persona_choices(), "Enter persona name"
+
+    personas = _load_personas()
+    personas[name.strip()] = {"name": name.strip(), "prompt": prompt}
+    _save_personas(personas)
+    return get_persona_choices(), f"Saved: {name}"
+
+
+def ui_load_persona(name: str) -> str:
+    """Load persona prompt"""
+    personas = _load_personas()
+    return personas.get(name, {}).get("prompt", DEFAULT_CHAT_PROMPT)
+
+
+def ui_delete_persona(name: str):
+    """Delete a persona"""
+    if name == "default":
+        return get_persona_choices(), "Cannot delete default persona"
+
+    personas = _load_personas()
+    if name in personas:
+        del personas[name]
+        _save_personas(personas)
+        return get_persona_choices(), f"Deleted: {name}"
+    return get_persona_choices(), "Persona not found"
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# SUGGESTED MODELS
+# ══════════════════════════════════════════════════════════════════════════════
+
+# Default model for quick testing (small, fast, uncensored)
+DEFAULT_MODEL = {
+    "id": "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+    "file": "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf",
+    "name": "TinyLlama 1.1B",
+    "size": "0.7GB"
+}
+
+SUGGESTED_MODELS = [
+    {"id": "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF", "file": "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf", "name": "TinyLlama 1.1B (Fast)", "size": "0.7GB", "recommended": True},
+    {"id": "TheBloke/phi-2-GGUF", "file": "phi-2.Q4_K_M.gguf", "name": "Phi-2 (Small & Fast)", "size": "1.6GB"},
+    {"id": "Qwen/Qwen2-0.5B-Instruct-GGUF", "file": "qwen2-0_5b-instruct-q4_k_m.gguf", "name": "Qwen2 0.5B (Tiny)", "size": "0.4GB"},
+    {"id": "TheBloke/Mistral-7B-Instruct-v0.2-GGUF", "file": "mistral-7b-instruct-v0.2.Q4_K_M.gguf", "name": "Mistral 7B Instruct", "size": "4.4GB"},
+    {"id": "TheBloke/Llama-2-7B-Chat-GGUF", "file": "llama-2-7b-chat.Q4_K_M.gguf", "name": "Llama 2 7B Chat", "size": "4.1GB"},
+    {"id": "TheBloke/OpenHermes-2.5-Mistral-7B-GGUF", "file": "openhermes-2.5-mistral-7b.Q4_K_M.gguf", "name": "OpenHermes 2.5", "size": "4.4GB"},
+]
+
+
+def download_default_model() -> str:
+    """Download the default model if not present"""
+    from .hf_hub import download_model_file
+    from .config import MODELS_DIR
+
+    txt_dir = MODELS_DIR / "txt"
+    txt_dir.mkdir(parents=True, exist_ok=True)
+
+    # Check if any model exists
+    existing = list(txt_dir.rglob("*.gguf"))
+    if existing:
+        return f"Model already exists: {existing[0].name}"
+
+    # Download default model
+    result = download_model_file(DEFAULT_MODEL["id"], DEFAULT_MODEL["file"])
+    return result
+
+
+def ensure_model_available() -> bool:
+    """Ensure at least one model is available, download if needed"""
+    models = model_manager.get_available_models()
+    return len(models) > 0
+
+
+def get_suggested_models_table() -> List[List[str]]:
+    """Get suggested models for display"""
+    return [[m["name"], m["size"], m["id"]] for m in SUGGESTED_MODELS]
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# COMPATIBILITY EXPORTS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def get_sessions_list(session_type: str = None) -> List[List[str]]:
+    """Legacy: Get sessions list"""
+    return get_chat_list()
+
+
+def get_model_status_display() -> str:
+    """Legacy: Get model status"""
+    status = model_manager.get_status()
+    if status["loaded"]:
+        return f"Model: {status['model_id']}"
+    return "No model loaded"
+
+
+def ui_refresh_models():
+    """Legacy: Refresh models"""
+    return get_models_table(), get_current_model_display()
+
+
+def ui_load_model(evt, models_data):
+    """Legacy: Load model"""
+    return ui_load_model_by_index(evt, models_data)

modules/theme.py

@@ -0,0 +1,69 @@
+"""
+Theme Module
+Dark theme CSS and styling.
+"""
+
+DARK_CSS = """
+/* GitHub Dark Theme */
+.gradio-container { background: #0d1117 !important; color: #c9d1d9 !important; }
+h1, h2, h3 { color: #58a6ff !important; }
+
+/* Inputs */
+input, textarea, select { background: #0d1117 !important; border: 1px solid #30363d !important; color: #c9d1d9 !important; border-radius: 6px !important; }
+input:focus, textarea:focus { border-color: #58a6ff !important; }
+
+/* Buttons */
+button { background: #21262d !important; border: 1px solid #30363d !important; color: #c9d1d9 !important; }
+button:hover { background: #30363d !important; }
+button.primary { background: #238636 !important; border-color: #238636 !important; color: #fff !important; }
+button.stop { background: #da3633 !important; border-color: #da3633 !important; color: #fff !important; }
+
+/* Tables */
+table { background: #0d1117 !important; }
+th { background: #161b22 !important; color: #8b949e !important; }
+td { background: #0d1117 !important; color: #c9d1d9 !important; }
+tr:hover td { background: #161b22 !important; }
+
+/* Blocks */
+.block { background: #161b22 !important; border: 1px solid #30363d !important; }
+pre, code { background: #161b22 !important; color: #79c0ff !important; }
+
+/* Tabs */
+.tab-nav button { background: #21262d !important; color: #8b949e !important; }
+.tab-nav button.selected { background: #0d1117 !important; color: #58a6ff !important; border-bottom: 2px solid #58a6ff !important; }
+
+/* Sidebar */
+.folder-tree { background: #0d1117 !important; border: 1px solid #30363d !important; border-radius: 8px !important; padding: 10px !important; font-family: 'Consolas', monospace !important; }
+.folder-tree table { background: transparent !important; }
+.folder-tree td { padding: 4px 8px !important; cursor: pointer !important; }
+.folder-tree tr:hover td { background: #21262d !important; }
+
+/* Toolbar */
+.toolbar { background: #161b22 !important; border: 1px solid #30363d !important; border-radius: 8px !important; padding: 8px !important; }
+
+/* Status */
+.status { background: #161b22 !important; border: 1px solid #30363d !important; color: #8b949e !important; font-size: 12px !important; }
+
+/* Breadcrumb */
+.breadcrumb { background: #161b22 !important; color: #58a6ff !important; font-family: monospace !important; }
+
+/* Home cards */
+.home-card { background: #161b22 !important; border: 1px solid #30363d !important; border-radius: 12px !important; padding: 20px !important; }
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 8px; }
+::-webkit-scrollbar-track { background: #0d1117; }
+::-webkit-scrollbar-thumb { background: #30363d; border-radius: 4px; }
+
+label { color: #8b949e !important; }
+"""
+
+
+def get_theme():
+    """Get Gradio theme configuration"""
+    import gradio as gr
+    return gr.themes.Base().set(
+        body_background_fill="#0d1117",
+        block_background_fill="#161b22",
+        border_color_primary="#30363d",
+    )

modules/ui_helpers.py

@@ -0,0 +1,159 @@
+"""
+UI Helpers Module
+Helper functions for Gradio UI interactions.
+"""
+import json
+import gradio as gr
+
+from .file_manager import (
+    get_folder_contents, get_breadcrumb, get_status, get_quick_access_folders,
+    create_folder, create_file, delete_item, rename_item, write_file,
+    navigate_to_folder, get_file_preview
+)
+from .events import event_manager
+from .logger import logger
+from .api import api_create_event, api_delete_event, api_toggle_event, api_run_event
+
+
+def ui_result(result_str: str) -> str:
+    """Parse result JSON and return status message"""
+    try:
+        r = json.loads(result_str)
+        return "✅ Success" if r.get("success") else f"❌ {r.get('error', 'Error')}"
+    except:
+        return result_str
+
+
+def ui_create_folder(name):
+    result = create_folder(name)
+    return get_folder_contents(), get_breadcrumb(), ui_result(result), get_quick_access_folders()
+
+
+def ui_create_file(name, content):
+    result = create_file(name, content)
+    return get_folder_contents(), get_breadcrumb(), ui_result(result), get_quick_access_folders()
+
+
+def ui_delete(name):
+    if not name:
+        return get_folder_contents(), get_breadcrumb(), "⚠️ Select item", get_quick_access_folders()
+    result = delete_item(name)
+    return get_folder_contents(), get_breadcrumb(), ui_result(result), get_quick_access_folders()
+
+
+def ui_rename(old, new):
+    result = rename_item(old, new)
+    return get_folder_contents(), get_breadcrumb(), ui_result(result), get_quick_access_folders()
+
+
+def ui_save(name, content):
+    if not name:
+        return "⚠️ Select file"
+    result = write_file(name, content)
+    return ui_result(result)
+
+
+def on_folder_tree_select(evt: gr.SelectData, data):
+    """Handle folder tree selection"""
+    if evt.index[0] < len(data):
+        folder_path = data[evt.index[0]][2]
+        return navigate_to_folder(folder_path)
+    return get_folder_contents(), get_breadcrumb(), get_status(), get_quick_access_folders()
+
+
+def navigate_from_main(evt: gr.SelectData, data):
+    """Handle click on main content - navigate into folder or show preview"""
+    from .file_manager import current_path
+    import modules.file_manager as fm
+
+    if evt.index[0] < len(data):
+        name = data[evt.index[0]][1]
+        item_type = data[evt.index[0]][2]
+
+        if item_type == "Folder":
+            new_path = fm.current_path / name
+            if new_path.exists() and new_path.is_dir():
+                fm.current_path = new_path
+                return (
+                    get_folder_contents(),
+                    get_breadcrumb(),
+                    get_status(),
+                    get_quick_access_folders(),
+                    name,
+                    None, "", ""
+                )
+        else:
+            img, txt, info = get_file_preview(name)
+            return (
+                data,
+                get_breadcrumb(),
+                get_status(),
+                get_quick_access_folders(),
+                name,
+                img, txt or "", info
+            )
+
+    return (data, get_breadcrumb(), get_status(), get_quick_access_folders(), "", None, "", "")
+
+
+# Event UI helpers
+def get_events_table():
+    events = event_manager.get_events()
+    rows = []
+    for e in events:
+        rows.append([
+            e["event_id"],
+            e["event_type"],
+            e["target_path"][:30] + "..." if len(e["target_path"]) > 30 else e["target_path"],
+            f"{e['interval_hours']}h",
+            "✅" if e["enabled"] else "❌",
+            e.get("last_run", "Never")[:16] if e.get("last_run") else "Never",
+            str(e["run_count"])
+        ])
+    return rows
+
+
+def get_logs_display(log_type: str = "all", limit: int = 50):
+    logs = logger.get_logs(log_type, limit)
+    if not logs:
+        return "No logs found"
+
+    lines = []
+    for log in logs:
+        level_icon = {"INFO": "ℹ️", "ERROR": "❌", "WARNING": "⚠️", "EVENT": "📌", "DEBUG": "🔍"}.get(log["level"], "•")
+        lines.append(f"[{log['timestamp'][:19]}] {level_icon} [{log['category']}] {log['message']}")
+    return "\n".join(lines)
+
+
+def ui_create_event(event_type, target_path, interval_hours, enabled, description):
+    result = api_create_event(event_type, target_path, interval_hours, enabled, description)
+    return get_events_table(), ui_result(result)
+
+
+def ui_delete_event(event_id):
+    result = api_delete_event(event_id)
+    return get_events_table(), ui_result(result)
+
+
+def ui_toggle_event(event_id):
+    result = api_toggle_event(event_id)
+    return get_events_table(), ui_result(result)
+
+
+def ui_run_event(event_id):
+    result = api_run_event(event_id)
+    return get_events_table(), get_logs_display("events", 20), ui_result(result)
+
+
+def ui_refresh_logs(log_type, limit):
+    return get_logs_display(log_type, int(limit))
+
+
+def ui_clear_logs(log_type):
+    from .api import api_clear_logs
+    api_clear_logs(log_type)
+    return get_logs_display(log_type, 50), "��� Logs cleared"
+
+
+def ui_copy_logs(log_type):
+    return logger.export_logs(log_type)

modules/utils.py

@@ -0,0 +1,47 @@
+"""
+Utility Functions Module
+Common helper functions used across the application.
+"""
+from pathlib import Path
+from datetime import datetime
+
+
+def format_size(size: int) -> str:
+    """Format bytes to human readable string"""
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} PB"
+
+
+def get_file_icon(name: str, is_dir: bool = False) -> str:
+    """Get emoji icon for file type"""
+    if is_dir:
+        return "📁"
+    ext = Path(name).suffix.lower()
+    icons = {
+        '.txt': '📄', '.md': '📝', '.pdf': '📕', '.doc': '📘', '.csv': '📊',
+        '.py': '🐍', '.js': '📜', '.json': '📋', '.html': '🌐', '.css': '🎨',
+        '.jpg': '🖼️', '.jpeg': '🖼️', '.png': '🖼️', '.gif': '🖼️', '.svg': '🖼️',
+        '.mp3': '🎵', '.wav': '🎵', '.mp4': '🎬', '.avi': '🎬',
+        '.zip': '📦', '.tar': '📦', '.gz': '📦',
+        '.pt': '🧠', '.pth': '🧠', '.safetensors': '🧠', '.ckpt': '🧠', '.bin': '🧠',
+        '.env': '🔐', '.log': '📜', '.sh': '🖥️',
+    }
+    return icons.get(ext, '📄')
+
+
+def get_mime_type(name: str) -> str:
+    """Get mime type category for file"""
+    ext = Path(name).suffix.lower()
+    if ext in ['.jpg', '.jpeg', '.png', '.gif', '.svg', '.webp']:
+        return 'image'
+    if ext in ['.txt', '.md', '.py', '.js', '.json', '.html', '.css', '.yaml', '.yml', '.sh', '.log', '.csv']:
+        return 'text'
+    return 'binary'
+
+
+def format_timestamp(ts: float) -> str:
+    """Format unix timestamp to string"""
+    return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")