Deploy TextAI v2 - Clean architecture

api/__init__.py

@@ -0,0 +1,42 @@
+"""
+TextAI v2 API Module
+RESTful API endpoints for both Gradio and local app usage
+"""
+from .endpoints import (
+    # Model APIs
+    api_list_models,
+    api_get_model,
+    api_load_model,
+    api_unload_model,
+    api_delete_model,
+    api_search_models,
+    api_get_model_files,
+    api_download_model,
+
+    # Session APIs
+    api_list_sessions,
+    api_get_session,
+    api_create_session,
+    api_delete_session,
+    api_rename_session,
+    api_clear_session,
+
+    # Chat APIs
+    api_chat,
+    api_inference,
+    api_chat_with_config,
+
+    # System APIs
+    api_get_status,
+    api_get_backends,
+    api_health,
+)
+
+__all__ = [
+    'api_list_models', 'api_get_model', 'api_load_model', 'api_unload_model',
+    'api_delete_model', 'api_search_models', 'api_get_model_files', 'api_download_model',
+    'api_list_sessions', 'api_get_session', 'api_create_session',
+    'api_delete_session', 'api_rename_session', 'api_clear_session',
+    'api_chat', 'api_inference', 'api_chat_with_config',
+    'api_get_status', 'api_get_backends', 'api_health',
+]

api/endpoints.py

@@ -0,0 +1,372 @@
+"""
+API Endpoints
+All return JSON strings for consistency.
+Can be used by Gradio UI or external apps.
+"""
+import json
+from typing import Optional
+
+from ..core.models import get_model_service
+from ..core.sessions import get_session_service
+from ..core.state import get_state
+from ..core.logger import logger
+from ..core.config import VERSION
+
+
+def _json_response(success: bool, data: dict = None, error: str = None) -> str:
+    """Standard JSON response format"""
+    response = {"success": success}
+    if data:
+        response.update(data)
+    if error:
+        response["error"] = error
+    return json.dumps(response, indent=2)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MODEL APIs
+# ══════════════════════════════════════════════════════════════════════════════
+
+def api_list_models() -> str:
+    """List all installed models"""
+    service = get_model_service()
+    models = service.get_installed_models()
+    loaded_id = get_state().get_loaded_model_id()
+
+    return _json_response(True, {
+        "models": models,
+        "count": len(models),
+        "loaded_model_id": loaded_id
+    })
+
+
+def api_get_model(model_id: str) -> str:
+    """Get specific model details"""
+    model = get_state().get_model_by_id(model_id)
+    if model:
+        return _json_response(True, {"model": model})
+    return _json_response(False, error="Model not found")
+
+
+def api_load_model(model_id: str) -> str:
+    """Load a model"""
+    service = get_model_service()
+    result = service.load_model(model_id)
+    return json.dumps(result)
+
+
+def api_unload_model() -> str:
+    """Unload current model"""
+    service = get_model_service()
+    service.unload_model()
+    return _json_response(True, {"message": "Model unloaded"})
+
+
+def api_delete_model(model_id: str) -> str:
+    """Delete an installed model"""
+    service = get_model_service()
+    result = service.delete_model(model_id)
+    return json.dumps(result)
+
+
+def api_search_models(query: str = "", max_params: float = 7.0, limit: int = 20) -> str:
+    """Search HuggingFace for models"""
+    service = get_model_service()
+    results, status = service.search_hf_models(query, max_params, limit)
+    return _json_response(True, {
+        "results": results,
+        "count": len(results),
+        "status": status
+    })
+
+
+def api_get_model_files(repo_id: str) -> str:
+    """Get available files for a HF model"""
+    service = get_model_service()
+    files = service.get_hf_model_files(repo_id)
+    return _json_response(True, {
+        "repo_id": repo_id,
+        "files": files,
+        "count": len(files)
+    })
+
+
+def api_download_model(repo_id: str, filename: str) -> str:
+    """Download a model from HuggingFace"""
+    service = get_model_service()
+    result = service.download_model(repo_id, filename)
+    return json.dumps(result)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# SESSION APIs
+# ══════════════════════════════════════════════════════════════════════════════
+
+def api_list_sessions() -> str:
+    """List all sessions"""
+    service = get_session_service()
+    sessions = service.get_all_sessions()
+    return _json_response(True, {
+        "sessions": sessions,
+        "count": len(sessions),
+        "active_session_id": get_state().get_active_session_id()
+    })
+
+
+def api_get_session(session_id: str) -> str:
+    """Get session with messages"""
+    service = get_session_service()
+    session = service.get_session(session_id)
+    if session:
+        return _json_response(True, {"session": session})
+    return _json_response(False, error="Session not found")
+
+
+def api_create_session(
+    title: str = "",
+    session_type: str = "chat",
+    system_prompt: str = ""
+) -> str:
+    """Create new session"""
+    service = get_session_service()
+    session = service.create_session(title, session_type, system_prompt)
+    return _json_response(True, {
+        "session_id": session["id"],
+        "title": session["title"]
+    })
+
+
+def api_delete_session(session_id: str) -> str:
+    """Delete a session"""
+    service = get_session_service()
+    result = service.delete_session(session_id)
+    return _json_response(result, {"message": "Deleted" if result else "Not found"})
+
+
+def api_rename_session(session_id: str, new_title: str) -> str:
+    """Rename a session"""
+    service = get_session_service()
+    result = service.rename_session(session_id, new_title)
+    return _json_response(result, {"title": new_title})
+
+
+def api_clear_session(session_id: str) -> str:
+    """Clear session messages"""
+    service = get_session_service()
+    result = service.clear_session(session_id)
+    return _json_response(result, {"message": "Cleared"})
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# CHAT / INFERENCE APIs
+# ══════════════════════════════════════════════════════════════════════════════
+
+def api_chat(
+    session_id: str,
+    message: str,
+    max_tokens: int = 512,
+    temperature: float = 0.7
+) -> str:
+    """Send chat message and get response"""
+    model_service = get_model_service()
+    session_service = get_session_service()
+
+    # Check model loaded
+    if not model_service.is_model_loaded():
+        return _json_response(False, error="No model loaded")
+
+    # Get session
+    session = session_service.get_session(session_id)
+    if not session:
+        return _json_response(False, error="Session not found")
+
+    # Add user message
+    session_service.add_message(session_id, "user", message)
+
+    # Build messages for model
+    messages = []
+    if session.get("system_prompt"):
+        messages.append({"role": "system", "content": session["system_prompt"]})
+
+    for msg in session_service.get_messages(session_id):
+        messages.append({"role": msg["role"], "content": msg["content"]})
+
+    # Generate response
+    response = model_service.generate(messages, max_tokens, temperature)
+
+    # Add assistant response
+    session_service.add_message(session_id, "assistant", response)
+
+    return _json_response(True, {
+        "response": response,
+        "session_id": session_id
+    })
+
+
+def api_inference(
+    prompt: str = "",
+    messages: str = "[]",
+    system_prompt: str = "",
+    max_tokens: int = 512,
+    temperature: float = 0.7,
+    top_p: float = 0.9,
+    context: str = "",
+    lora_scale: float = 1.0
+) -> str:
+    """
+    Universal inference endpoint.
+    Can use direct prompt or message list.
+    Supports system prompt, context injection, LoRA scaling (future).
+    """
+    model_service = get_model_service()
+
+    if not model_service.is_model_loaded():
+        return _json_response(False, error="No model loaded")
+
+    try:
+        # Parse messages if provided
+        msg_list = json.loads(messages) if messages and messages != "[]" else []
+
+        # Build full message list
+        full_messages = []
+
+        # System prompt
+        if system_prompt:
+            full_messages.append({"role": "system", "content": system_prompt})
+
+        # Context injection
+        if context:
+            full_messages.append({"role": "system", "content": f"Context:\n{context}"})
+
+        # Conversation messages
+        full_messages.extend(msg_list)
+
+        # Direct prompt
+        if prompt:
+            full_messages.append({"role": "user", "content": prompt})
+
+        if not full_messages:
+            return _json_response(False, error="No prompt or messages provided")
+
+        # Generate
+        response = model_service.generate(full_messages, max_tokens, temperature, top_p)
+
+        loaded_model = model_service.get_loaded_model()
+
+        return _json_response(True, {
+            "response": response,
+            "model_id": loaded_model["id"] if loaded_model else None,
+            "config": {
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": top_p,
+                "lora_scale": lora_scale
+            }
+        })
+
+    except Exception as e:
+        logger.error("API", f"Inference error: {e}")
+        return _json_response(False, error=str(e))
+
+
+def api_chat_with_config(
+    session_id: str,
+    message: str,
+    max_tokens: int = 512,
+    temperature: float = 0.7,
+    top_p: float = 0.9,
+    system_prompt_override: str = "",
+    context: str = "",
+    lora_scale: float = 1.0
+) -> str:
+    """
+    Chat with full configuration options.
+    Supports: custom inference params, system prompt override, context injection.
+    """
+    model_service = get_model_service()
+    session_service = get_session_service()
+
+    if not model_service.is_model_loaded():
+        return _json_response(False, error="No model loaded")
+
+    session = session_service.get_session(session_id)
+    if not session:
+        return _json_response(False, error="Session not found")
+
+    # Add user message
+    session_service.add_message(session_id, "user", message)
+
+    # Build messages
+    messages = []
+
+    # System prompt (override or session default)
+    sys_prompt = system_prompt_override or session.get("system_prompt", "")
+    if sys_prompt:
+        messages.append({"role": "system", "content": sys_prompt})
+
+    # Context injection
+    if context:
+        messages.append({"role": "system", "content": f"Context:\n{context}"})
+
+    # Conversation history
+    for msg in session_service.get_messages(session_id):
+        messages.append({"role": msg["role"], "content": msg["content"]})
+
+    # Generate
+    response = model_service.generate(messages, max_tokens, temperature, top_p)
+
+    # Add response
+    session_service.add_message(session_id, "assistant", response)
+
+    return _json_response(True, {
+        "response": response,
+        "session_id": session_id,
+        "config_used": {
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "lora_scale": lora_scale,
+            "context_provided": bool(context)
+        }
+    })
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# SYSTEM APIs
+# ══════════════════════════════════════════════════════════════════════════════
+
+def api_get_status() -> str:
+    """Get current system status"""
+    model_service = get_model_service()
+    state = get_state()
+
+    loaded = model_service.get_loaded_model()
+
+    return _json_response(True, {
+        "version": VERSION,
+        "model_loaded": model_service.is_model_loaded(),
+        "loaded_model": loaded["name"] if loaded else None,
+        "installed_models_count": len(state.get_installed_models()),
+        "sessions_count": len(state.get_sessions()),
+        "active_session_id": state.get_active_session_id()
+    })
+
+
+def api_get_backends() -> str:
+    """Check which inference backends are available"""
+    from ..core.models import _get_llama_cpp, _get_transformers
+
+    return _json_response(True, {
+        "backends": {
+            "gguf": _get_llama_cpp() is not None,
+            "transformers": _get_transformers() is not None
+        }
+    })
+
+
+def api_health() -> str:
+    """Health check endpoint"""
+    return _json_response(True, {
+        "status": "healthy",
+        "version": VERSION
+    })

app.py

@@ -0,0 +1,201 @@
+"""
+TextAI v2.0
+Clean, Professional AI Chat Interface
+"""
+import gradio as gr
+
+from core.config import VERSION, APP_TITLE
+from core.logger import logger
+from core.state import get_state
+from ui.theme import THEME_CSS, get_theme
+from ui.chat import build_chat_ui
+from ui.models import build_model_manager_ui
+from api import api_health, api_get_status
+
+
+def create_app():
+    """Create the Gradio application"""
+
+    # Initialize state on startup
+    state = get_state()
+    state.sync_with_filesystem()
+    logger.info("App", f"TextAI v{VERSION} starting")
+
+    with gr.Blocks(
+        title=APP_TITLE,
+        theme=get_theme(),
+        css=THEME_CSS
+    ) as app:
+
+        with gr.Tabs() as main_tabs:
+
+            # ══════════════════════════════════════════════════════════
+            # TAB 1: CHAT
+            # ══════════════════════════════════════════════════════════
+            with gr.Tab("Chat", id=0):
+                chat_components = build_chat_ui()
+
+            # ══════════════════════════════════════════════════════════
+            # TAB 2: MODELS
+            # ══════════════════════════════════════════════════════════
+            with gr.Tab("Models", id=1):
+                model_components = build_model_manager_ui()
+
+            # ══════════════════════════════════════════════════════════
+            # TAB 3: TOOLS
+            # ══════════════════════════════════════════════════════════
+            with gr.Tab("Tools", id=2):
+                with gr.Tabs():
+
+                    # System Info
+                    with gr.Tab("System"):
+                        gr.Markdown("### System Status")
+                        btn_status = gr.Button("Get Status", variant="primary")
+                        status_output = gr.JSON(label="Status")
+
+                        btn_status.click(
+                            lambda: __import__('json').loads(api_get_status()),
+                            outputs=[status_output]
+                        )
+
+                    # Logs
+                    with gr.Tab("Logs"):
+                        gr.Markdown("### Application Logs")
+                        with gr.Row():
+                            log_level = gr.Dropdown(
+                                choices=["all", "INFO", "WARN", "ERROR", "EVENT"],
+                                value="all",
+                                label="Level"
+                            )
+                            log_limit = gr.Number(value=50, label="Limit")
+                            btn_refresh_logs = gr.Button("Refresh")
+                            btn_clear_logs = gr.Button("Clear", variant="stop")
+
+                        logs_display = gr.TextArea(
+                            label="",
+                            lines=20,
+                            interactive=False
+                        )
+
+                        def get_logs(level, limit):
+                            from core.logger import logger as log
+                            logs = log.get_logs(
+                                level=level if level != "all" else None,
+                                limit=int(limit)
+                            )
+                            lines = []
+                            for l in reversed(logs):
+                                ts = l["timestamp"].split("T")[1][:8]
+                                lines.append(f"[{ts}] [{l['level']}] [{l['module']}] {l['message']}")
+                            return "\n".join(lines)
+
+                        def clear_logs(level):
+                            from core.logger import logger as log
+                            log.clear(level if level != "all" else None)
+                            return "Logs cleared"
+
+                        btn_refresh_logs.click(
+                            get_logs,
+                            inputs=[log_level, log_limit],
+                            outputs=[logs_display]
+                        )
+
+                        btn_clear_logs.click(
+                            clear_logs,
+                            inputs=[log_level],
+                            outputs=[logs_display]
+                        )
+
+                    # API Info
+                    with gr.Tab("API"):
+                        gr.Markdown("### API Endpoints")
+                        gr.Markdown("""
+                        All endpoints return JSON. Use for integration with local apps.
+
+                        **Models:**
+                        - `api_list_models()` - List installed models
+                        - `api_load_model(model_id)` - Load a model
+                        - `api_unload_model()` - Unload current model
+                        - `api_search_models(query, max_params, limit)` - Search HF
+                        - `api_download_model(repo_id, filename)` - Download model
+
+                        **Sessions:**
+                        - `api_list_sessions()` - List all sessions
+                        - `api_create_session(title, type, system_prompt)` - New session
+                        - `api_delete_session(session_id)` - Delete session
+
+                        **Chat:**
+                        - `api_chat(session_id, message, max_tokens, temperature)` - Chat
+                        - `api_inference(prompt, messages, system_prompt, ...)` - Direct inference
+
+                        **System:**
+                        - `api_health()` - Health check
+                        - `api_get_status()` - Full status
+                        - `api_get_backends()` - Available backends
+                        """)
+
+                        gr.Markdown("### Test")
+                        btn_health = gr.Button("Health Check")
+                        health_output = gr.JSON()
+
+                        btn_health.click(
+                            lambda: __import__('json').loads(api_health()),
+                            outputs=[health_output]
+                        )
+
+            # ══════════════════════════════════════════════════════════
+            # TAB 4: ABOUT
+            # ══════════════════════════════════════════════════════════
+            with gr.Tab("About", id=3):
+                gr.Markdown(f"""
+                # TextAI v{VERSION}
+
+                **Local AI Chat Assistant**
+
+                A clean, professional chat interface for running local LLM models.
+                Inspired by ChatGPT & Grok.
+
+                ---
+
+                ### Features
+
+                - 🤖 **Chat** - Natural conversation with AI
+                - 📁 **Session Management** - Auto-save, rename, delete chats
+                - 🔧 **Model Manager** - Download, load, configure models
+                - 🔍 **HuggingFace Search** - Find and download GGUF models
+                - 🎛️ **Customization** - System prompts, temperature, tokens
+                - 📡 **API** - Full API for integration with other apps
+
+                ---
+
+                ### Supported Models
+
+                - **GGUF** - Via llama-cpp-python (recommended)
+                - **Transformers** - Via HuggingFace transformers
+
+                ---
+
+                ### Keyboard Shortcuts
+
+                - `Enter` - Send message
+                - `Shift+Enter` - New line
+
+                ---
+
+                Built with ❤️ using Gradio
+                """)
+
+    return app
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MAIN
+# ══════════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

core/__init__.py

@@ -0,0 +1,15 @@
+"""
+TextAI v2 Core Module
+Single source of truth for all state management
+"""
+from .state import StateManager, get_state
+from .models import ModelService
+from .sessions import SessionService
+from .logger import logger
+
+__all__ = [
+    'StateManager', 'get_state',
+    'ModelService',
+    'SessionService',
+    'logger'
+]

core/config.py

@@ -0,0 +1,29 @@
+"""
+Configuration - Single place for all paths and constants
+"""
+from pathlib import Path
+import os
+
+# Base directories
+BASE_DIR = Path("/tmp/textai_storage") if os.environ.get("SPACE_ID") else Path(__file__).parent.parent / "storage"
+MODELS_DIR = BASE_DIR / "models"
+SESSIONS_DIR = BASE_DIR / "sessions"
+STATE_FILE = BASE_DIR / "state.json"
+LOGS_DIR = BASE_DIR / "logs"
+
+# Ensure directories exist
+for d in [BASE_DIR, MODELS_DIR, SESSIONS_DIR, LOGS_DIR]:
+    d.mkdir(parents=True, exist_ok=True)
+
+# HuggingFace API
+HF_API_URL = "https://huggingface.co/api"
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+
+# Model constraints (free tier)
+MAX_MODEL_SIZE_GB = 5.0
+MAX_PARAMS_BILLION = 7.0
+RECOMMENDED_QUANTS = ["Q4_K_M", "Q4_K_S", "Q5_K_M"]
+
+# UI Constants
+VERSION = "2.0.0"
+APP_TITLE = "TextAI"

core/logger.py

@@ -0,0 +1,84 @@
+"""
+Centralized Logger
+"""
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+from .config import LOGS_DIR
+
+class Logger:
+    """Thread-safe logger with file persistence"""
+
+    def __init__(self, max_logs: int = 1000):
+        self.log_file = LOGS_DIR / "app.log"
+        self.max_logs = max_logs
+        self._logs: List[Dict] = []
+        self._load_logs()
+
+    def _load_logs(self):
+        """Load existing logs from file"""
+        if self.log_file.exists():
+            try:
+                self._logs = json.loads(self.log_file.read_text())[-self.max_logs:]
+            except:
+                self._logs = []
+
+    def _save_logs(self):
+        """Save logs to file"""
+        try:
+            self.log_file.write_text(json.dumps(self._logs[-self.max_logs:], indent=2))
+        except:
+            pass
+
+    def _log(self, level: str, module: str, message: str, data: Optional[Dict] = None):
+        """Internal log method"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "level": level,
+            "module": module,
+            "message": message,
+            "data": data
+        }
+        self._logs.append(entry)
+
+        # Console output
+        icons = {"INFO": "ℹ️", "WARN": "⚠️", "ERROR": "❌", "EVENT": "📌"}
+        icon = icons.get(level, "•")
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        print(f"[{timestamp}] {icon} [{module}] {message}")
+
+        # Persist periodically
+        if len(self._logs) % 10 == 0:
+            self._save_logs()
+
+    def info(self, module: str, message: str, data: Optional[Dict] = None):
+        self._log("INFO", module, message, data)
+
+    def warn(self, module: str, message: str, data: Optional[Dict] = None):
+        self._log("WARN", module, message, data)
+
+    def error(self, module: str, message: str, data: Optional[Dict] = None):
+        self._log("ERROR", module, message, data)
+
+    def event(self, module: str, message: str, data: Optional[Dict] = None):
+        self._log("EVENT", module, message, data)
+
+    def get_logs(self, level: Optional[str] = None, limit: int = 50) -> List[Dict]:
+        """Get recent logs, optionally filtered by level"""
+        logs = self._logs
+        if level:
+            logs = [l for l in logs if l["level"] == level]
+        return logs[-limit:]
+
+    def clear(self, level: Optional[str] = None):
+        """Clear logs"""
+        if level:
+            self._logs = [l for l in self._logs if l["level"] != level]
+        else:
+            self._logs = []
+        self._save_logs()
+
+
+# Singleton instance
+logger = Logger()

core/models.py

@@ -0,0 +1,494 @@
+"""
+Model Service - All model operations
+Handles: loading, inference, downloading, management
+"""
+import re
+import json
+import requests
+import threading
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple, Any
+
+from .config import MODELS_DIR, HF_API_URL, HF_TOKEN, RECOMMENDED_QUANTS, MAX_PARAMS_BILLION
+from .state import get_state, InstalledModel
+from .logger import logger
+
+# Lazy imports for heavy libraries
+_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("Models", "llama-cpp-python loaded")
+        except ImportError as e:
+            logger.warn("Models", 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 = {"model": AutoModelForCausalLM, "tokenizer": AutoTokenizer}
+            _torch = torch
+            logger.info("Models", "transformers loaded")
+        except ImportError as e:
+            logger.warn("Models", f"transformers not available: {e}")
+            _transformers = False
+    return _transformers if _transformers else None
+
+
+class ModelService:
+    """
+    Service for all model operations.
+    Uses StateManager for persistence.
+    """
+
+    def __init__(self):
+        self._current_model = None
+        self._current_tokenizer = None
+        self._lock = threading.Lock()
+        self._state = get_state()
+
+    # ══════════════════════════════════════════════════════════════════
+    # MODEL LISTING & INFO
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_installed_models(self) -> List[Dict]:
+        """Get all installed models from state"""
+        return self._state.get_installed_models()
+
+    def get_loaded_model(self) -> Optional[Dict]:
+        """Get currently loaded model info"""
+        model_id = self._state.get_loaded_model_id()
+        if model_id:
+            return self._state.get_model_by_id(model_id)
+        return None
+
+    def is_model_loaded(self) -> bool:
+        """Check if any model is loaded"""
+        return self._current_model is not None
+
+    # ══════════════════════════════════════════════════════════════════
+    # MODEL LOADING
+    # ══════════════════════════════════════════════════════════════════
+
+    def load_model(self, model_id: str) -> Dict[str, Any]:
+        """Load a model by ID"""
+        with self._lock:
+            logger.info("Models", f"Loading model: {model_id}")
+
+            # Get model info from state
+            model_info = self._state.get_model_by_id(model_id)
+            if not model_info:
+                return {"success": False, "error": f"Model not found: {model_id}"}
+
+            # Unload current model first
+            if self._current_model is not None:
+                self.unload_model()
+
+            # Load based on type
+            model_path = MODELS_DIR / model_info["filename"]
+            if not model_path.exists():
+                return {"success": False, "error": f"Model file not found: {model_path}"}
+
+            try:
+                if model_info["model_type"] == "gguf":
+                    result = self._load_gguf(model_path)
+                else:
+                    result = self._load_transformers(model_path)
+
+                if result["success"]:
+                    self._state.set_loaded_model(model_id)
+
+                return result
+
+            except Exception as e:
+                logger.error("Models", f"Load failed: {e}")
+                return {"success": False, "error": str(e)}
+
+    def _load_gguf(self, model_path: Path) -> Dict:
+        """Load GGUF model"""
+        Llama = _get_llama_cpp()
+        if Llama is None:
+            return {"success": False, "error": "llama-cpp-python not installed"}
+
+        try:
+            self._current_model = Llama(
+                model_path=str(model_path),
+                n_ctx=4096,
+                n_threads=4,
+                n_gpu_layers=0,
+                verbose=False
+            )
+            logger.info("Models", f"GGUF loaded: {model_path.name}")
+            return {"success": True, "type": "gguf", "name": model_path.stem}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def _load_transformers(self, model_path: Path) -> Dict:
+        """Load transformers model"""
+        tf = _get_transformers()
+        if tf is None:
+            return {"success": False, "error": "transformers not installed"}
+
+        try:
+            self._current_tokenizer = tf["tokenizer"].from_pretrained(str(model_path))
+            self._current_model = tf["model"].from_pretrained(
+                str(model_path),
+                torch_dtype=_torch.float32,
+                device_map="cpu",
+                low_cpu_mem_usage=True
+            )
+            logger.info("Models", f"Transformers loaded: {model_path.name}")
+            return {"success": True, "type": "transformers", "name": model_path.name}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def unload_model(self):
+        """Unload current model"""
+        with self._lock:
+            if self._current_model:
+                del self._current_model
+                self._current_model = None
+            if self._current_tokenizer:
+                del self._current_tokenizer
+                self._current_tokenizer = None
+
+            self._state.set_loaded_model(None)
+
+            import gc
+            gc.collect()
+            logger.info("Models", "Model unloaded")
+
+    # ══════════════════════════════════════════════════════════════════
+    # INFERENCE
+    # ══════════════════════════════════════════════════════════════════
+
+    def generate(
+        self,
+        messages: List[Dict],
+        max_tokens: int = 512,
+        temperature: float = 0.7,
+        top_p: float = 0.9
+    ) -> str:
+        """Generate response from loaded model"""
+        if self._current_model is None:
+            return "[Error: No model loaded]"
+
+        model_info = self.get_loaded_model()
+        if not model_info:
+            return "[Error: Model info not found]"
+
+        try:
+            if model_info["model_type"] == "gguf":
+                return self._generate_gguf(messages, max_tokens, temperature, top_p)
+            else:
+                return self._generate_transformers(messages, max_tokens, temperature, top_p)
+        except Exception as e:
+            logger.error("Models", f"Generation error: {e}")
+            return f"[Error: {e}]"
+
+    def _generate_gguf(self, messages: List[Dict], max_tokens: int, temperature: float, top_p: float) -> 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"""
+        # Build prompt from messages
+        prompt = ""
+        for msg in messages:
+            role = msg["role"].capitalize()
+            prompt += f"{role}: {msg['content']}\n\n"
+        prompt += "Assistant: "
+
+        inputs = self._current_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._current_tokenizer.eos_token_id
+            )
+
+        response = self._current_tokenizer.decode(
+            outputs[0][inputs.input_ids.shape[1]:],
+            skip_special_tokens=True
+        )
+        return response.strip()
+
+    # ══════════════════════════════════════════════════════════════════
+    # HUGGINGFACE SEARCH & DOWNLOAD
+    # ══════════════════════════════════════════════════════════════════
+
+    def search_hf_models(
+        self,
+        query: str = "",
+        max_params: float = MAX_PARAMS_BILLION,
+        limit: int = 20
+    ) -> Tuple[List[Dict], str]:
+        """
+        Search HuggingFace for GGUF models.
+        Returns: (results, status_message)
+        """
+        logger.info("Models", f"HF search: {query}")
+
+        try:
+            params = {
+                "search": query,
+                "library": "gguf",
+                "pipeline_tag": "text-generation",
+                "sort": "downloads",
+                "direction": -1,
+                "limit": limit + 20  # Extra for filtering
+            }
+
+            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()
+
+            results = []
+            for m in resp.json():
+                model_id = m.get("id", "")
+                params_b = self._estimate_params(model_id)
+
+                # Filter by params
+                if max_params and params_b and params_b > max_params:
+                    continue
+
+                # Check compatibility
+                compat = self._check_compatibility(params_b)
+
+                results.append({
+                    "id": model_id,
+                    "downloads": m.get("downloads", 0),
+                    "params_b": params_b,
+                    "est_size_gb": round(params_b * 0.55, 1) if params_b else None,
+                    "compatibility": compat,
+                    "is_installed": self._is_repo_installed(model_id)
+                })
+
+                if len(results) >= limit:
+                    break
+
+            logger.info("Models", f"HF search found {len(results)} models")
+            return results, f"Found {len(results)} models"
+
+        except Exception as e:
+            logger.error("Models", f"HF search error: {e}")
+            return [], f"Search failed: {e}"
+
+    def get_hf_model_files(self, repo_id: str) -> List[Dict]:
+        """Get GGUF files available for a HF model"""
+        logger.info("Models", f"Getting files for: {repo_id}")
+
+        try:
+            headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+            resp = requests.get(f"{HF_API_URL}/models/{repo_id}", headers=headers, timeout=30)
+            resp.raise_for_status()
+
+            files = []
+            for s in resp.json().get("siblings", []):
+                filename = s.get("rfilename", "")
+                if filename.endswith(".gguf"):
+                    quant = self._extract_quant(filename)
+                    files.append({
+                        "filename": filename,
+                        "quant": quant,
+                        "recommended": quant in RECOMMENDED_QUANTS,
+                        "is_installed": self._state.is_model_installed(repo_id, filename)
+                    })
+
+            # Sort: recommended first, then by name
+            files.sort(key=lambda x: (not x["recommended"], x["filename"]))
+            return files
+
+        except Exception as e:
+            logger.error("Models", f"Get files error: {e}")
+            return []
+
+    def download_model(self, repo_id: str, filename: str) -> Dict[str, Any]:
+        """
+        Download a model from HuggingFace.
+        Returns: {success, message, model_id}
+        """
+        logger.info("Models", f"Downloading: {repo_id}/{filename}")
+
+        # Check for duplicate
+        if self._state.is_model_installed(repo_id, filename):
+            return {
+                "success": False,
+                "error": f"Model already installed: {filename}",
+                "duplicate": True
+            }
+
+        try:
+            # Download
+            url = f"https://huggingface.co/{repo_id}/resolve/main/{filename}"
+            headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+
+            dest_path = MODELS_DIR / filename
+            resp = requests.get(url, headers=headers, stream=True, timeout=600)
+            resp.raise_for_status()
+
+            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)
+
+            # Create model entry
+            params_b = self._estimate_params(repo_id)
+            model = InstalledModel(
+                id=Path(filename).stem,
+                name=self._make_display_name(repo_id, filename),
+                hf_repo=repo_id,
+                filename=filename,
+                model_type="gguf" if filename.endswith(".gguf") else "transformers",
+                size_bytes=dest_path.stat().st_size,
+                quant=self._extract_quant(filename),
+                installed_at=datetime.now().isoformat(),
+                params_b=params_b or 0.0
+            )
+
+            # Add to state
+            self._state.add_model(model)
+
+            size_mb = dest_path.stat().st_size / (1024 * 1024)
+            logger.info("Models", f"Downloaded: {filename} ({size_mb:.1f} MB)")
+
+            return {
+                "success": True,
+                "message": f"Downloaded: {filename} ({size_mb:.1f} MB)",
+                "model_id": model.id
+            }
+
+        except Exception as e:
+            logger.error("Models", f"Download failed: {e}")
+            # Clean up partial download
+            if dest_path.exists():
+                dest_path.unlink()
+            return {"success": False, "error": str(e)}
+
+    def delete_model(self, model_id: str) -> Dict[str, Any]:
+        """Delete an installed model"""
+        logger.info("Models", f"Deleting: {model_id}")
+
+        model_info = self._state.get_model_by_id(model_id)
+        if not model_info:
+            return {"success": False, "error": "Model not found"}
+
+        # Unload if currently loaded
+        if self._state.get_loaded_model_id() == model_id:
+            self.unload_model()
+
+        # Delete file
+        try:
+            model_path = MODELS_DIR / model_info["filename"]
+            if model_path.exists():
+                model_path.unlink()
+        except Exception as e:
+            logger.error("Models", f"File delete error: {e}")
+
+        # Remove from state
+        self._state.remove_model(model_id)
+
+        return {"success": True, "message": f"Deleted: {model_info['name']}"}
+
+    # ══════════════════════════════════════════════════════════════════
+    # UTILITY METHODS
+    # ══════════════════════════════════════════════════════════════════
+
+    def _estimate_params(self, model_id: str) -> Optional[float]:
+        """Extract parameter count from model name"""
+        name = model_id.lower()
+        patterns = [
+            r'(\d+\.?\d*)b(?:illion)?',
+            r'(\d+\.?\d*)-?b(?:illion)?',
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, name)
+            if match:
+                try:
+                    return float(match.group(1))
+                except:
+                    pass
+        return None
+
+    def _extract_quant(self, filename: str) -> str:
+        """Extract quantization type from filename"""
+        quants = ["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"]
+        upper = filename.upper()
+        for q in quants:
+            if q in upper:
+                return q
+        return "unknown"
+
+    def _check_compatibility(self, params_b: Optional[float]) -> Dict:
+        """Check if model is compatible with free tier"""
+        if params_b is None:
+            return {"status": "unknown", "label": "❓ Unknown", "ok": True}
+
+        if params_b <= 1.5:
+            return {"status": "best", "label": "✅ Best", "ok": True}
+        elif params_b <= 3:
+            return {"status": "good", "label": "✅ Good", "ok": True}
+        elif params_b <= 7:
+            return {"status": "ok", "label": "⚠️ OK", "ok": True}
+        elif params_b <= 13:
+            return {"status": "slow", "label": "⚠️ Slow", "ok": False}
+        else:
+            return {"status": "too_large", "label": "❌ Too Large", "ok": False}
+
+    def _make_display_name(self, repo_id: str, filename: str) -> str:
+        """Create a nice display name"""
+        # Extract meaningful part from repo or filename
+        name = Path(filename).stem
+        # Clean up common patterns
+        name = re.sub(r'[-_]gguf$', '', name, flags=re.IGNORECASE)
+        name = re.sub(r'[-_]q\d.*$', '', name, flags=re.IGNORECASE)
+        return name.replace('-', ' ').replace('_', ' ').title()
+
+    def _is_repo_installed(self, repo_id: str) -> bool:
+        """Check if any model from this repo is installed"""
+        for m in self._state.get_installed_models():
+            if m["hf_repo"] == repo_id:
+                return True
+        return False
+
+
+# Singleton
+_model_service: Optional[ModelService] = None
+
+
+def get_model_service() -> ModelService:
+    """Get singleton model service"""
+    global _model_service
+    if _model_service is None:
+        _model_service = ModelService()
+    return _model_service

core/sessions.py

@@ -0,0 +1,234 @@
+"""
+Session Service - Chat session management
+"""
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .config import SESSIONS_DIR
+from .state import get_state
+from .logger import logger
+
+
+class SessionService:
+    """
+    Manages chat sessions.
+    Sessions are stored in state + individual files for messages.
+    """
+
+    def __init__(self):
+        self._state = get_state()
+
+    # ══════════════════════════════════════════════════════════════════
+    # SESSION CRUD
+    # ══════════════════════════════════════════════════════════════════
+
+    def create_session(
+        self,
+        title: str = "",
+        session_type: str = "chat",
+        system_prompt: str = ""
+    ) -> Dict:
+        """Create a new chat session"""
+        session_id = str(uuid.uuid4())[:8]
+
+        if not title:
+            now = datetime.now()
+            prefix = "Chat" if session_type == "chat" else "Roleplay"
+            title = f"{prefix} {now.strftime('%m/%d %H:%M')}"
+
+        session = {
+            "id": session_id,
+            "title": title,
+            "type": session_type,
+            "system_prompt": system_prompt,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "message_count": 0,
+            "model_id": self._state.get_loaded_model_id()
+        }
+
+        # Save session metadata to state
+        self._state.add_session(session)
+
+        # Create empty messages file
+        self._save_messages(session_id, [])
+
+        logger.event("Sessions", f"Created: {session_id}", {"title": title})
+        return session
+
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """Get session by ID with messages"""
+        sessions = self._state.get_sessions()
+        for s in sessions:
+            if s["id"] == session_id:
+                session = s.copy()
+                session["messages"] = self._load_messages(session_id)
+                return session
+        return None
+
+    def get_all_sessions(self) -> List[Dict]:
+        """Get all sessions (without messages)"""
+        return self._state.get_sessions()
+
+    def update_session(self, session_id: str, updates: Dict) -> bool:
+        """Update session metadata"""
+        return self._state.update_session(session_id, updates)
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete session and its messages"""
+        # Delete messages file
+        msg_file = SESSIONS_DIR / f"{session_id}.json"
+        if msg_file.exists():
+            msg_file.unlink()
+
+        # Remove from state
+        result = self._state.delete_session(session_id)
+        if result:
+            logger.event("Sessions", f"Deleted: {session_id}")
+        return result
+
+    def rename_session(self, session_id: str, new_title: str) -> bool:
+        """Rename a session"""
+        return self._state.update_session(session_id, {"title": new_title})
+
+    def clear_session(self, session_id: str) -> bool:
+        """Clear all messages from a session"""
+        self._save_messages(session_id, [])
+        self._state.update_session(session_id, {"message_count": 0})
+        return True
+
+    # ══════════════════════════════════════════════════════════════════
+    # MESSAGE HANDLING
+    # ══════════════════════════════════════════════════════════════════
+
+    def add_message(self, session_id: str, role: str, content: str) -> bool:
+        """Add a message to session"""
+        messages = self._load_messages(session_id)
+
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat()
+        }
+        messages.append(message)
+
+        self._save_messages(session_id, messages)
+
+        # Update session metadata
+        self._state.update_session(session_id, {
+            "message_count": len(messages)
+        })
+
+        # Auto-generate title from first user message
+        if role == "user" and len(messages) == 1:
+            title = content[:40] + "..." if len(content) > 40 else content
+            self._state.update_session(session_id, {"title": title})
+
+        return True
+
+    def get_messages(self, session_id: str) -> List[Dict]:
+        """Get all messages for a session"""
+        return self._load_messages(session_id)
+
+    def _load_messages(self, session_id: str) -> List[Dict]:
+        """Load messages from file"""
+        msg_file = SESSIONS_DIR / f"{session_id}.json"
+        if msg_file.exists():
+            try:
+                return json.loads(msg_file.read_text())
+            except:
+                pass
+        return []
+
+    def _save_messages(self, session_id: str, messages: List[Dict]):
+        """Save messages to file"""
+        msg_file = SESSIONS_DIR / f"{session_id}.json"
+        msg_file.write_text(json.dumps(messages, indent=2))
+
+    # ══════════════════════════════════════════════════════════════════
+    # UTILITY
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_active_session(self) -> Optional[Dict]:
+        """Get the currently active session"""
+        session_id = self._state.get_active_session_id()
+        if session_id:
+            return self.get_session(session_id)
+        return None
+
+    def set_active_session(self, session_id: str):
+        """Set active session"""
+        self._state.set_active_session(session_id)
+
+    def get_session_for_display(self, session_id: str) -> Optional[Dict]:
+        """Get session formatted for UI display"""
+        session = self.get_session(session_id)
+        if not session:
+            return None
+
+        # Format messages for Gradio chatbot (tuple format)
+        history = []
+        user_msg = None
+        for msg in session.get("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 {
+            "id": session["id"],
+            "title": session["title"],
+            "type": session["type"],
+            "system_prompt": session["system_prompt"],
+            "history": history,
+            "message_count": session["message_count"]
+        }
+
+    def group_sessions_by_date(self) -> Dict[str, List[Dict]]:
+        """Group sessions by date for sidebar display"""
+        sessions = self.get_all_sessions()
+        today = datetime.now().date()
+
+        groups = {
+            "Today": [],
+            "Yesterday": [],
+            "This Week": [],
+            "Older": []
+        }
+
+        for s in sessions:
+            try:
+                updated = datetime.fromisoformat(s["updated_at"]).date()
+                diff = (today - updated).days
+
+                if diff == 0:
+                    groups["Today"].append(s)
+                elif diff == 1:
+                    groups["Yesterday"].append(s)
+                elif diff < 7:
+                    groups["This Week"].append(s)
+                else:
+                    groups["Older"].append(s)
+            except:
+                groups["Older"].append(s)
+
+        # Remove empty groups
+        return {k: v for k, v in groups.items() if v}
+
+
+# Singleton
+_session_service: Optional[SessionService] = None
+
+
+def get_session_service() -> SessionService:
+    """Get singleton session service"""
+    global _session_service
+    if _session_service is None:
+        _session_service = SessionService()
+    return _session_service

core/state.py

@@ -0,0 +1,305 @@
+"""
+State Management - Single Source of Truth
+All state changes go through here
+"""
+import json
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Callable
+from dataclasses import dataclass, asdict, field
+
+from .config import STATE_FILE, MODELS_DIR
+from .logger import logger
+
+
+@dataclass
+class InstalledModel:
+    """Installed model metadata"""
+    id: str                    # Unique ID (filename stem)
+    name: str                  # Display name
+    hf_repo: str               # HuggingFace repo ID
+    filename: str              # Actual filename
+    model_type: str            # "gguf" or "transformers"
+    size_bytes: int            # File size
+    quant: str                 # Quantization type (Q4_K_M, etc.)
+    installed_at: str          # ISO timestamp
+    system_prompt: str = ""    # Custom system prompt
+    params_b: float = 0.0      # Estimated params in billions
+
+
+@dataclass
+class AppState:
+    """Application state - single source of truth"""
+    installed_models: List[Dict] = field(default_factory=list)
+    loaded_model_id: Optional[str] = None
+    default_model_id: Optional[str] = None
+    sessions: List[Dict] = field(default_factory=list)
+    active_session_id: Optional[str] = None
+    settings: Dict = field(default_factory=dict)
+    version: str = "2.0.0"
+
+
+class StateManager:
+    """
+    Manages all application state with:
+    - File persistence
+    - Thread safety
+    - Change notifications
+    """
+
+    def __init__(self):
+        self._state: AppState = AppState()
+        self._lock = threading.RLock()
+        self._subscribers: List[Callable] = []
+        self._load_state()
+
+    def _load_state(self):
+        """Load state from file"""
+        with self._lock:
+            if STATE_FILE.exists():
+                try:
+                    data = json.loads(STATE_FILE.read_text())
+                    self._state = AppState(**data)
+                    logger.info("State", "State loaded from file")
+                except Exception as e:
+                    logger.error("State", f"Failed to load state: {e}")
+                    self._state = AppState()
+            else:
+                self._state = AppState()
+                self._save_state()
+
+    def _save_state(self):
+        """Save state to file"""
+        try:
+            STATE_FILE.write_text(json.dumps(asdict(self._state), indent=2))
+        except Exception as e:
+            logger.error("State", f"Failed to save state: {e}")
+
+    def _notify_subscribers(self):
+        """Notify all subscribers of state change"""
+        for callback in self._subscribers:
+            try:
+                callback(self._state)
+            except Exception as e:
+                logger.error("State", f"Subscriber error: {e}")
+
+    def subscribe(self, callback: Callable):
+        """Subscribe to state changes"""
+        self._subscribers.append(callback)
+
+    def unsubscribe(self, callback: Callable):
+        """Unsubscribe from state changes"""
+        if callback in self._subscribers:
+            self._subscribers.remove(callback)
+
+    # ══════════════════════════════════════════════════════════════════
+    # MODEL STATE OPERATIONS
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_installed_models(self) -> List[Dict]:
+        """Get all installed models"""
+        with self._lock:
+            return self._state.installed_models.copy()
+
+    def get_model_by_id(self, model_id: str) -> Optional[Dict]:
+        """Get specific model by ID"""
+        with self._lock:
+            for m in self._state.installed_models:
+                if m["id"] == model_id:
+                    return m.copy()
+            return None
+
+    def is_model_installed(self, hf_repo: str, filename: str) -> bool:
+        """Check if model is already installed (duplicate check)"""
+        with self._lock:
+            for m in self._state.installed_models:
+                if m["hf_repo"] == hf_repo and m["filename"] == filename:
+                    return True
+            return False
+
+    def add_model(self, model: InstalledModel) -> bool:
+        """Add a new installed model"""
+        with self._lock:
+            # Duplicate check
+            if self.is_model_installed(model.hf_repo, model.filename):
+                logger.warn("State", f"Model already installed: {model.filename}")
+                return False
+
+            self._state.installed_models.append(asdict(model))
+
+            # Set as default if first model
+            if len(self._state.installed_models) == 1:
+                self._state.default_model_id = model.id
+
+            self._save_state()
+            self._notify_subscribers()
+            logger.event("State", f"Model added: {model.name}")
+            return True
+
+    def remove_model(self, model_id: str) -> bool:
+        """Remove an installed model"""
+        with self._lock:
+            for i, m in enumerate(self._state.installed_models):
+                if m["id"] == model_id:
+                    # Unload if currently loaded
+                    if self._state.loaded_model_id == model_id:
+                        self._state.loaded_model_id = None
+
+                    # Remove from list
+                    removed = self._state.installed_models.pop(i)
+
+                    # Update default if needed
+                    if self._state.default_model_id == model_id:
+                        self._state.default_model_id = (
+                            self._state.installed_models[0]["id"]
+                            if self._state.installed_models else None
+                        )
+
+                    self._save_state()
+                    self._notify_subscribers()
+                    logger.event("State", f"Model removed: {removed['name']}")
+                    return True
+            return False
+
+    def update_model(self, model_id: str, updates: Dict) -> bool:
+        """Update model properties"""
+        with self._lock:
+            for m in self._state.installed_models:
+                if m["id"] == model_id:
+                    m.update(updates)
+                    self._save_state()
+                    self._notify_subscribers()
+                    return True
+            return False
+
+    def set_loaded_model(self, model_id: Optional[str]):
+        """Set the currently loaded model"""
+        with self._lock:
+            self._state.loaded_model_id = model_id
+            self._save_state()
+            self._notify_subscribers()
+            logger.event("State", f"Model loaded: {model_id}")
+
+    def get_loaded_model_id(self) -> Optional[str]:
+        """Get currently loaded model ID"""
+        with self._lock:
+            return self._state.loaded_model_id
+
+    def set_default_model(self, model_id: str):
+        """Set default model"""
+        with self._lock:
+            self._state.default_model_id = model_id
+            self._save_state()
+
+    # ══════════════════════════════════════════════════════════════════
+    # SESSION STATE OPERATIONS
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_sessions(self) -> List[Dict]:
+        """Get all sessions"""
+        with self._lock:
+            return self._state.sessions.copy()
+
+    def add_session(self, session: Dict) -> str:
+        """Add new session, return session ID"""
+        with self._lock:
+            self._state.sessions.insert(0, session)  # Most recent first
+            self._state.active_session_id = session["id"]
+            self._save_state()
+            self._notify_subscribers()
+            return session["id"]
+
+    def update_session(self, session_id: str, updates: Dict):
+        """Update session"""
+        with self._lock:
+            for s in self._state.sessions:
+                if s["id"] == session_id:
+                    s.update(updates)
+                    s["updated_at"] = datetime.now().isoformat()
+                    self._save_state()
+                    return True
+            return False
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete session"""
+        with self._lock:
+            for i, s in enumerate(self._state.sessions):
+                if s["id"] == session_id:
+                    self._state.sessions.pop(i)
+                    if self._state.active_session_id == session_id:
+                        self._state.active_session_id = (
+                            self._state.sessions[0]["id"]
+                            if self._state.sessions else None
+                        )
+                    self._save_state()
+                    self._notify_subscribers()
+                    return True
+            return False
+
+    def set_active_session(self, session_id: str):
+        """Set active session"""
+        with self._lock:
+            self._state.active_session_id = session_id
+            self._save_state()
+
+    def get_active_session_id(self) -> Optional[str]:
+        """Get active session ID"""
+        with self._lock:
+            return self._state.active_session_id
+
+    # ══════════════════════════════════════════════════════════════════
+    # SETTINGS
+    # ════════════════════════════════════════════════════════════���═════
+
+    def get_settings(self) -> Dict:
+        """Get all settings"""
+        with self._lock:
+            return self._state.settings.copy()
+
+    def update_settings(self, updates: Dict):
+        """Update settings"""
+        with self._lock:
+            self._state.settings.update(updates)
+            self._save_state()
+
+    # ══════════════════════════════════════════════════════════════════
+    # UTILITY
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_full_state(self) -> Dict:
+        """Get complete state (for debugging)"""
+        with self._lock:
+            return asdict(self._state)
+
+    def sync_with_filesystem(self):
+        """
+        Sync state with actual files on disk.
+        Call this on startup to handle manual file changes.
+        """
+        with self._lock:
+            # Check each installed model still exists
+            valid_models = []
+            for m in self._state.installed_models:
+                model_path = MODELS_DIR / m["filename"]
+                if model_path.exists():
+                    valid_models.append(m)
+                else:
+                    logger.warn("State", f"Model file missing, removing: {m['filename']}")
+
+            if len(valid_models) != len(self._state.installed_models):
+                self._state.installed_models = valid_models
+                self._save_state()
+                logger.info("State", "State synced with filesystem")
+
+
+# Singleton instance
+_state_manager: Optional[StateManager] = None
+
+
+def get_state() -> StateManager:
+    """Get the singleton state manager"""
+    global _state_manager
+    if _state_manager is None:
+        _state_manager = StateManager()
+    return _state_manager

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.0.0
+requests>=2.28.0
+huggingface_hub>=0.16.0
+llama-cpp-python>=0.2.0

ui/__init__.py

@@ -0,0 +1,9 @@
+"""
+TextAI v2 UI Module
+Gradio-based interface components
+"""
+from .theme import THEME_CSS, get_theme
+from .chat import build_chat_ui
+from .models import build_model_manager_ui
+
+__all__ = ['THEME_CSS', 'get_theme', 'build_chat_ui', 'build_model_manager_ui']

ui/chat.py

@@ -0,0 +1,386 @@
+"""
+Chat UI Component
+Clean ChatGPT/Grok style interface
+"""
+import gradio as gr
+from typing import List, Tuple, Optional, Generator
+
+from ..core.models import get_model_service
+from ..core.sessions import get_session_service
+from ..core.state import get_state
+from ..core.logger import logger
+
+# Default prompts
+DEFAULT_SYSTEM_PROMPT = """You are a helpful AI assistant. Be concise, accurate, and helpful."""
+
+ROLEPLAY_SYSTEM_PROMPT = """You are an expert roleplay AI. Stay in character. Be creative and engaging."""
+
+
+def build_chat_ui():
+    """Build the chat interface - returns components dict"""
+
+    # ══════════════════════════════════════════════════════════════════
+    # HELPER FUNCTIONS
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_sessions_for_sidebar() -> List[List]:
+        """Get sessions formatted for sidebar display"""
+        service = get_session_service()
+        sessions = service.get_all_sessions()
+        return [[s["id"], s["title"][:35] + "..." if len(s["title"]) > 35 else s["title"]]
+                for s in sessions[:30]]
+
+    def get_model_choices() -> List[str]:
+        """Get models for dropdown"""
+        service = get_model_service()
+        models = service.get_installed_models()
+        loaded_id = get_state().get_loaded_model_id()
+
+        choices = []
+        for m in models:
+            prefix = "● " if m["id"] == loaded_id else ""
+            choices.append(f"{prefix}{m['name']}")
+        return choices if choices else ["No models installed"]
+
+    def get_current_model_display() -> str:
+        """Get current model for header display"""
+        service = get_model_service()
+        model = service.get_loaded_model()
+        if model:
+            return f"● {model['name']}"
+        return "No model loaded"
+
+    def format_history(session_id: str) -> List[Tuple[str, str]]:
+        """Format session messages for Gradio chatbot"""
+        service = get_session_service()
+        display = service.get_session_for_display(session_id)
+        return display["history"] if display else []
+
+    # ══════════════════════════════════════════════════════════════════
+    # EVENT HANDLERS
+    # ══════════════════════════════════════════════════════════════════
+
+    def on_new_chat(system_prompt: str = ""):
+        """Create new chat session"""
+        service = get_session_service()
+        session = service.create_session(
+            system_prompt=system_prompt or DEFAULT_SYSTEM_PROMPT
+        )
+        logger.info("Chat", f"New session: {session['id']}")
+        return (
+            session["id"],
+            [],
+            get_sessions_for_sidebar(),
+            "",
+            gr.update(visible=True),  # Show chat
+            gr.update(visible=False)  # Hide welcome
+        )
+
+    def on_session_select(evt: gr.SelectData, sessions_data):
+        """Load selected session"""
+        try:
+            if evt.index is not None:
+                row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+                if sessions_data and row_idx < len(sessions_data):
+                    session_id = sessions_data[row_idx][0]
+                    service = get_session_service()
+                    service.set_active_session(session_id)
+                    history = format_history(session_id)
+                    logger.info("Chat", f"Loaded session: {session_id}")
+                    return (
+                        session_id,
+                        history,
+                        gr.update(visible=True),
+                        gr.update(visible=False)
+                    )
+        except Exception as e:
+            logger.error("Chat", f"Session select error: {e}")
+        return "", [], gr.update(), gr.update()
+
+    def on_send_message(
+        session_id: str,
+        message: str,
+        history: List,
+        max_tokens: int,
+        temperature: float,
+        system_prompt: str
+    ) -> Generator:
+        """Send message and stream response"""
+        if not message.strip():
+            yield history, "", session_id, get_sessions_for_sidebar()
+            return
+
+        model_service = get_model_service()
+        session_service = get_session_service()
+
+        # Check model
+        if not model_service.is_model_loaded():
+            history = history + [(message, "⚠️ Please load a model first. Go to Model Manager.")]
+            yield history, "", session_id, get_sessions_for_sidebar()
+            return
+
+        # Create session if needed
+        if not session_id:
+            session = session_service.create_session(system_prompt=system_prompt)
+            session_id = session["id"]
+
+        # Add user message to UI
+        history = history + [(message, None)]
+        yield history, "", session_id, get_sessions_for_sidebar()
+
+        # Add to session
+        session_service.add_message(session_id, "user", message)
+
+        # Build messages for model
+        session = session_service.get_session(session_id)
+        messages = []
+        if session.get("system_prompt"):
+            messages.append({"role": "system", "content": session["system_prompt"]})
+        for msg in session.get("messages", []):
+            messages.append({"role": msg["role"], "content": msg["content"]})
+
+        # Generate response
+        try:
+            response = model_service.generate(messages, max_tokens, temperature)
+            session_service.add_message(session_id, "assistant", response)
+            history[-1] = (message, response)
+        except Exception as e:
+            logger.error("Chat", f"Generation error: {e}")
+            history[-1] = (message, f"⚠️ Error: {e}")
+
+        yield history, "", session_id, get_sessions_for_sidebar()
+
+    def on_load_model(choice: str):
+        """Load selected model"""
+        if not choice or choice == "No models installed":
+            return get_current_model_display(), "Select a model"
+
+        # Extract model name (remove ● prefix if present)
+        name = choice.replace("● ", "")
+
+        model_service = get_model_service()
+        models = model_service.get_installed_models()
+
+        for m in models:
+            if m["name"] == name:
+                result = model_service.load_model(m["id"])
+                if result["success"]:
+                    logger.info("Chat", f"Loaded model: {m['name']}")
+                    return get_current_model_display(), f"✓ Loaded: {m['name']}"
+                else:
+                    return get_current_model_display(), f"✗ Error: {result.get('error')}"
+
+        return get_current_model_display(), "Model not found"
+
+    def on_delete_session(session_id: str):
+        """Delete current session"""
+        if session_id:
+            get_session_service().delete_session(session_id)
+        return "", [], get_sessions_for_sidebar()
+
+    def on_clear_session(session_id: str):
+        """Clear current session messages"""
+        if session_id:
+            get_session_service().clear_session(session_id)
+        return []
+
+    # ══════════════════════════════════════════════════════════════════
+    # BUILD UI
+    # ══════════════════════════════════════════════════════════════════
+
+    with gr.Row(elem_classes="chat-layout"):
+        # ─────────────────────────────────────────────────────────────
+        # SIDEBAR
+        # ─────────────────────────────────────────────────────────────
+        with gr.Column(scale=1, min_width=260, elem_classes="sidebar"):
+            # New Chat Button
+            btn_new_chat = gr.Button(
+                "＋ New Chat",
+                elem_classes="new-chat-btn",
+                size="lg"
+            )
+
+            # Sessions List
+            gr.Markdown("### Chats", elem_classes="session-group-title")
+            sessions_list = gr.Dataframe(
+                headers=["id", "Title"],
+                value=get_sessions_for_sidebar(),
+                interactive=False,
+                show_label=False,
+                row_count=20,
+                col_count=(2, "fixed"),
+                elem_classes="session-list"
+            )
+
+            # Sidebar Footer - Model & Settings
+            with gr.Column(elem_classes="sidebar-footer"):
+                gr.Markdown("**Model**", elem_classes="text-sm text-muted")
+                model_dropdown = gr.Dropdown(
+                    choices=get_model_choices(),
+                    value=None,
+                    label="",
+                    show_label=False,
+                    elem_classes="model-selector"
+                )
+                btn_load_model = gr.Button("Load", size="sm", elem_classes="btn-sm")
+                model_status = gr.Textbox(
+                    value="",
+                    show_label=False,
+                    interactive=False,
+                    elem_classes="text-sm"
+                )
+
+        # ─────────────────────────────────────────��───────────────────
+        # MAIN CHAT AREA
+        # ─────────────────────────────────────────────────────────────
+        with gr.Column(scale=4, elem_classes="chat-container"):
+            # Header
+            with gr.Row(elem_classes="chat-header"):
+                current_model = gr.Textbox(
+                    value=get_current_model_display(),
+                    show_label=False,
+                    interactive=False,
+                    elem_classes="model-badge"
+                )
+
+                with gr.Row():
+                    btn_settings = gr.Button("⚙️", size="sm", elem_classes="input-btn")
+                    btn_delete = gr.Button("🗑️", size="sm", elem_classes="input-btn")
+
+            # Hidden state
+            current_session_id = gr.State("")
+
+            # Welcome Screen (shown when no chat)
+            with gr.Column(visible=True, elem_classes="welcome-container") as welcome_screen:
+                gr.Markdown("# TextAI", elem_classes="welcome-title")
+                gr.Markdown("Your local AI assistant", elem_classes="welcome-subtitle")
+
+                with gr.Row(elem_classes="suggestion-cards"):
+                    btn_suggest1 = gr.Button("💡 Explain a concept", elem_classes="suggestion-card")
+                    btn_suggest2 = gr.Button("✍️ Help me write", elem_classes="suggestion-card")
+                    btn_suggest3 = gr.Button("💻 Code assistance", elem_classes="suggestion-card")
+                    btn_suggest4 = gr.Button("🎭 Roleplay", elem_classes="suggestion-card")
+
+            # Chat Messages
+            with gr.Column(visible=False, elem_classes="chat-messages-container") as chat_screen:
+                chatbot = gr.Chatbot(
+                    value=[],
+                    show_label=False,
+                    height=500,
+                    elem_classes="chat-messages",
+                    layout="bubble"
+                )
+
+            # Input Area
+            with gr.Row(elem_classes="input-container"):
+                with gr.Row(elem_classes="input-wrapper"):
+                    btn_attach = gr.Button("📎", size="sm", elem_classes="input-btn")
+                    btn_voice = gr.Button("🎤", size="sm", elem_classes="input-btn")
+
+                    chat_input = gr.Textbox(
+                        placeholder="Message TextAI...",
+                        show_label=False,
+                        lines=1,
+                        max_lines=5,
+                        elem_classes="chat-input",
+                        scale=10
+                    )
+
+                    btn_send = gr.Button("➤", variant="primary", elem_classes="send-btn")
+
+            # Settings Panel (hidden by default)
+            with gr.Column(visible=False, elem_classes="settings-panel") as settings_panel:
+                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"
+                )
+                system_prompt = gr.TextArea(
+                    value=DEFAULT_SYSTEM_PROMPT,
+                    label="System Prompt",
+                    lines=3
+                )
+                btn_close_settings = gr.Button("Close", size="sm")
+
+    # ══════════════════════════════════════════════════════════════════
+    # WIRE UP EVENTS
+    # ══════════════════════════════════════════════════════════════════
+
+    # New Chat
+    btn_new_chat.click(
+        on_new_chat,
+        inputs=[system_prompt],
+        outputs=[current_session_id, chatbot, sessions_list, chat_input, chat_screen, welcome_screen]
+    )
+
+    # Session select
+    sessions_list.select(
+        on_session_select,
+        inputs=[sessions_list],
+        outputs=[current_session_id, chatbot, chat_screen, welcome_screen]
+    )
+
+    # Send message
+    btn_send.click(
+        on_send_message,
+        inputs=[current_session_id, chat_input, chatbot, max_tokens, temperature, system_prompt],
+        outputs=[chatbot, chat_input, current_session_id, sessions_list]
+    )
+    chat_input.submit(
+        on_send_message,
+        inputs=[current_session_id, chat_input, chatbot, max_tokens, temperature, system_prompt],
+        outputs=[chatbot, chat_input, current_session_id, sessions_list]
+    )
+
+    # Load model
+    btn_load_model.click(
+        on_load_model,
+        inputs=[model_dropdown],
+        outputs=[current_model, model_status]
+    )
+
+    # Settings toggle
+    btn_settings.click(
+        lambda: gr.update(visible=True),
+        outputs=[settings_panel]
+    )
+    btn_close_settings.click(
+        lambda: gr.update(visible=False),
+        outputs=[settings_panel]
+    )
+
+    # Delete session
+    btn_delete.click(
+        on_delete_session,
+        inputs=[current_session_id],
+        outputs=[current_session_id, chatbot, sessions_list]
+    )
+
+    # Suggestion buttons (start new chat with specific prompt)
+    for btn, prompt in [
+        (btn_suggest1, "Explain the concept of machine learning in simple terms."),
+        (btn_suggest2, "Help me write a professional email."),
+        (btn_suggest3, "Help me debug this code."),
+        (btn_suggest4, "Let's do a creative roleplay.")
+    ]:
+        btn.click(
+            lambda p=prompt: on_new_chat() + (p,),
+            outputs=[current_session_id, chatbot, sessions_list, chat_input, chat_screen, welcome_screen]
+        )
+
+    # Return components for external access
+    return {
+        "chatbot": chatbot,
+        "input": chat_input,
+        "sessions": sessions_list,
+        "model_dropdown": model_dropdown,
+        "current_model": current_model,
+        "session_id": current_session_id,
+        "refresh_sessions": lambda: get_sessions_for_sidebar(),
+        "refresh_models": lambda: get_model_choices()
+    }

ui/models.py

@@ -0,0 +1,430 @@
+"""
+Model Manager UI Component
+Unified model management with HF search modal
+"""
+import gradio as gr
+from typing import List, Dict, Optional
+
+from ..core.models import get_model_service
+from ..core.state import get_state
+from ..core.logger import logger
+from ..core.config import RECOMMENDED_QUANTS
+
+
+def build_model_manager_ui():
+    """Build the model manager interface with HF search modal"""
+
+    # ══════════════════════════════════════════════════════════════════
+    # HELPER FUNCTIONS
+    # ══════════════════════════════════════════════════════════════════
+
+    def get_installed_models_table() -> List[List]:
+        """Get installed models for table display"""
+        service = get_model_service()
+        models = service.get_installed_models()
+        loaded_id = get_state().get_loaded_model_id()
+
+        rows = []
+        for m in models:
+            status = "● Loaded" if m["id"] == loaded_id else "Ready"
+            size_mb = m.get("size_bytes", 0) / (1024 * 1024)
+            rows.append([
+                m["id"],
+                m["name"],
+                m.get("model_type", "gguf").upper(),
+                f"{size_mb:.1f} MB",
+                m.get("quant", "-"),
+                status
+            ])
+        return rows
+
+    def get_loaded_model_display() -> str:
+        """Get currently loaded model name"""
+        service = get_model_service()
+        model = service.get_loaded_model()
+        return f"● {model['name']}" if model else "No model loaded"
+
+    # ══════════════════════════════════════════════════════════════════
+    # EVENT HANDLERS - INSTALLED MODELS
+    # ══════════════════════════════════════════════════════════════════
+
+    def on_select_model(evt: gr.SelectData, table_data) -> str:
+        """Select model from table"""
+        try:
+            row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+            if table_data and row_idx < len(table_data):
+                model_id = table_data[row_idx][0]
+                logger.info("ModelMgr", f"Selected: {model_id}")
+                return model_id
+        except Exception as e:
+            logger.error("ModelMgr", f"Select error: {e}")
+        return ""
+
+    def on_load_model(model_id: str):
+        """Load selected model"""
+        if not model_id:
+            return get_installed_models_table(), get_loaded_model_display(), "Select a model first"
+
+        service = get_model_service()
+        result = service.load_model(model_id)
+
+        if result["success"]:
+            return get_installed_models_table(), get_loaded_model_display(), f"✓ Loaded: {result.get('name', model_id)}"
+        else:
+            return get_installed_models_table(), get_loaded_model_display(), f"✗ Error: {result.get('error')}"
+
+    def on_unload_model():
+        """Unload current model"""
+        service = get_model_service()
+        service.unload_model()
+        return get_installed_models_table(), get_loaded_model_display(), "Model unloaded"
+
+    def on_delete_model(model_id: str):
+        """Delete selected model"""
+        if not model_id:
+            return get_installed_models_table(), "", "Select a model first"
+
+        service = get_model_service()
+        result = service.delete_model(model_id)
+
+        if result["success"]:
+            return get_installed_models_table(), "", f"✓ {result.get('message')}"
+        else:
+            return get_installed_models_table(), model_id, f"✗ Error: {result.get('error')}"
+
+    def on_refresh():
+        """Refresh models table"""
+        return get_installed_models_table(), get_loaded_model_display()
+
+    # ══════════════════════════════════════════════════════════════════
+    # EVENT HANDLERS - HF SEARCH MODAL
+    # ══════════════════════════════════════════════════════════════════
+
+    def on_search_hf(query: str, max_params: str):
+        """Search HuggingFace for models"""
+        logger.info("ModelMgr", f"HF Search: {query}, max_params={max_params}")
+
+        service = get_model_service()
+        max_p = float(max_params) if max_params != "any" else 100.0
+        results, status = service.search_hf_models(query, max_p, limit=15)
+
+        # Format for table
+        rows = []
+        for r in results:
+            params = f"{r['params_b']}B" if r.get('params_b') else "?"
+            size = f"~{r['est_size_gb']}GB" if r.get('est_size_gb') else "?"
+            compat = r.get('compatibility', {}).get('label', '?')
+            downloads = f"{r.get('downloads', 0):,}"
+            installed = "✓" if r.get('is_installed') else ""
+
+            rows.append([r['id'], params, size, compat, downloads, installed])
+
+        return rows, status
+
+    def on_select_hf_model(evt: gr.SelectData, table_data) -> tuple:
+        """Select model from HF search results"""
+        try:
+            row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+            if table_data and row_idx < len(table_data):
+                repo_id = table_data[row_idx][0]
+                logger.info("ModelMgr", f"Selected HF model: {repo_id}")
+                return repo_id, gr.update(visible=True)
+        except Exception as e:
+            logger.error("ModelMgr", f"HF select error: {e}")
+        return "", gr.update(visible=False)
+
+    def on_get_files(repo_id: str):
+        """Get GGUF files for selected model"""
+        if not repo_id:
+            return [], "Select a model first"
+
+        logger.info("ModelMgr", f"Getting files for: {repo_id}")
+        service = get_model_service()
+        files = service.get_hf_model_files(repo_id)
+
+        if not files:
+            return [], "No GGUF files found"
+
+        # Format for display with radio selection
+        rows = []
+        for f in files:
+            rec = "★ Recommended" if f["recommended"] else ""
+            installed = "✓ Installed" if f["is_installed"] else ""
+            rows.append([f["filename"], f["quant"], rec, installed])
+
+        return rows, f"Found {len(files)} files"
+
+    def on_select_file(evt: gr.SelectData, table_data) -> str:
+        """Select file from files list"""
+        try:
+            row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+            if table_data and row_idx < len(table_data):
+                filename = table_data[row_idx][0]
+                return filename
+        except:
+            pass
+        return ""
+
+    def on_download_model(repo_id: str, filename: str):
+        """Download selected model"""
+        if not repo_id or not filename:
+            return "Select a model and file first", get_installed_models_table()
+
+        logger.info("ModelMgr", f"Downloading: {repo_id}/{filename}")
+        service = get_model_service()
+        result = service.download_model(repo_id, filename)
+
+        if result["success"]:
+            return f"✓ {result.get('message')}", get_installed_models_table()
+        elif result.get("duplicate"):
+            return f"⚠️ {result.get('error')} - Choose a different quantization.", get_installed_models_table()
+        else:
+            return f"✗ Error: {result.get('error')}", get_installed_models_table()
+
+    def on_auto_download(repo_id: str):
+        """Auto-download best quantization"""
+        if not repo_id:
+            return "Select a model first", get_installed_models_table()
+
+        service = get_model_service()
+        files = service.get_hf_model_files(repo_id)
+
+        if not files:
+            return "No GGUF files found", get_installed_models_table()
+
+        # Find best file (Q4_K_M preferred)
+        best_file = None
+        for quant in RECOMMENDED_QUANTS + ["Q4_0", "Q5_0"]:
+            for f in files:
+                if f["quant"] == quant and not f["is_installed"]:
+                    best_file = f["filename"]
+                    break
+            if best_file:
+                break
+
+        if not best_file:
+            # Try first non-installed file
+            for f in files:
+                if not f["is_installed"]:
+                    best_file = f["filename"]
+                    break
+
+        if not best_file:
+            return "⚠️ All quantizations already installed", get_installed_models_table()
+
+        return on_download_model(repo_id, best_file)
+
+    # ══════════════════════════════════════════════════════════════════
+    # BUILD UI
+    # ══════════════════════════════════════════════════════════════════
+
+    with gr.Column(elem_classes="model-manager"):
+        gr.Markdown("# Model Manager")
+
+        # Current Model Status
+        with gr.Row():
+            loaded_model_display = gr.Textbox(
+                value=get_loaded_model_display(),
+                label="Currently Loaded",
+                interactive=False,
+                scale=3
+            )
+            btn_unload = gr.Button("Unload", size="sm", variant="stop")
+            btn_refresh = gr.Button("🔄 Refresh", size="sm")
+
+        gr.Markdown("---")
+
+        # ────��────────────────────────────────────────────────────────
+        # INSTALLED MODELS TABLE
+        # ─────────────────────────────────────────────────────────────
+        gr.Markdown("### Installed Models")
+        gr.Markdown("*Click a row to select, then use actions below*")
+
+        installed_table = gr.Dataframe(
+            headers=["ID", "Name", "Type", "Size", "Quant", "Status"],
+            value=get_installed_models_table(),
+            interactive=False,
+            row_count=6,
+            elem_classes="model-table"
+        )
+
+        selected_model_id = gr.Textbox(
+            label="Selected",
+            interactive=False,
+            visible=True
+        )
+
+        with gr.Row():
+            btn_load = gr.Button("▶ Load Selected", variant="primary")
+            btn_delete = gr.Button("🗑️ Delete Selected", variant="stop")
+            btn_configure = gr.Button("⚙️ Configure")
+
+        action_status = gr.Textbox(
+            label="",
+            show_label=False,
+            interactive=False
+        )
+
+        gr.Markdown("---")
+
+        # ─────────────────────────────────────────────────────────────
+        # ADD FROM HUGGINGFACE
+        # ─────────────────────────────────────────────────────────────
+        gr.Markdown("### Add from HuggingFace")
+
+        with gr.Row():
+            hf_search_input = gr.Textbox(
+                placeholder="Search models (tinyllama, phi, mistral...)",
+                show_label=False,
+                scale=4
+            )
+            hf_max_params = gr.Dropdown(
+                choices=[("< 3B (Fast)", "3"), ("< 7B (OK)", "7"), ("Any", "any")],
+                value="7",
+                label="Size",
+                scale=1
+            )
+            btn_search = gr.Button("🔍 Search", variant="primary")
+
+        hf_status = gr.Textbox(
+            label="",
+            show_label=False,
+            interactive=False
+        )
+
+        # Search Results
+        hf_results_table = gr.Dataframe(
+            headers=["Model ID", "Params", "Est. Size", "Compat", "Downloads", "Installed"],
+            value=[],
+            interactive=False,
+            row_count=8,
+            elem_classes="model-table"
+        )
+
+        selected_hf_repo = gr.Textbox(
+            label="Selected Model",
+            interactive=False
+        )
+
+        # File Selection Panel (shown after selecting a model)
+        with gr.Column(visible=False) as file_panel:
+            gr.Markdown("#### Select Quantization")
+
+            files_table = gr.Dataframe(
+                headers=["Filename", "Quant", "Recommended", "Status"],
+                value=[],
+                interactive=False,
+                row_count=6
+            )
+
+            selected_file = gr.Textbox(
+                label="Selected File",
+                interactive=False
+            )
+
+            with gr.Row():
+                btn_download = gr.Button("⬇️ Download Selected", variant="primary")
+                btn_auto_download = gr.Button("⚡ Auto Download (Best Q4)")
+                btn_close_files = gr.Button("Close")
+
+            download_status = gr.Textbox(
+                label="",
+                show_label=False,
+                interactive=False
+            )
+
+        gr.Markdown("---")
+        gr.Markdown("**Legend:** ✅ Best (<1.5B) | ✅ Good (<3B) | ⚠️ OK (<7B) | ❌ Too Large (>7B)")
+
+    # ══════════════════════════════════════════════════════════════════
+    # WIRE UP EVENTS
+    # ══════════════════════════════════════════════════════════════════
+
+    # Installed models table
+    installed_table.select(
+        on_select_model,
+        inputs=[installed_table],
+        outputs=[selected_model_id]
+    )
+
+    btn_load.click(
+        on_load_model,
+        inputs=[selected_model_id],
+        outputs=[installed_table, loaded_model_display, action_status]
+    )
+
+    btn_unload.click(
+        on_unload_model,
+        outputs=[installed_table, loaded_model_display, action_status]
+    )
+
+    btn_delete.click(
+        on_delete_model,
+        inputs=[selected_model_id],
+        outputs=[installed_table, selected_model_id, action_status]
+    )
+
+    btn_refresh.click(
+        on_refresh,
+        outputs=[installed_table, loaded_model_display]
+    )
+
+    # HF Search
+    btn_search.click(
+        on_search_hf,
+        inputs=[hf_search_input, hf_max_params],
+        outputs=[hf_results_table, hf_status]
+    )
+
+    hf_search_input.submit(
+        on_search_hf,
+        inputs=[hf_search_input, hf_max_params],
+        outputs=[hf_results_table, hf_status]
+    )
+
+    # HF model selection
+    hf_results_table.select(
+        on_select_hf_model,
+        inputs=[hf_results_table],
+        outputs=[selected_hf_repo, file_panel]
+    )
+
+    # When HF model selected, load its files
+    selected_hf_repo.change(
+        on_get_files,
+        inputs=[selected_hf_repo],
+        outputs=[files_table, download_status]
+    )
+
+    # File selection
+    files_table.select(
+        on_select_file,
+        inputs=[files_table],
+        outputs=[selected_file]
+    )
+
+    # Download
+    btn_download.click(
+        on_download_model,
+        inputs=[selected_hf_repo, selected_file],
+        outputs=[download_status, installed_table]
+    )
+
+    btn_auto_download.click(
+        on_auto_download,
+        inputs=[selected_hf_repo],
+        outputs=[download_status, installed_table]
+    )
+
+    btn_close_files.click(
+        lambda: gr.update(visible=False),
+        outputs=[file_panel]
+    )
+
+    # Return components for external access
+    return {
+        "installed_table": installed_table,
+        "loaded_display": loaded_model_display,
+        "selected_id": selected_model_id,
+        "refresh": on_refresh
+    }

ui/theme.py

@@ -0,0 +1,607 @@
+"""
+Theme and CSS - ChatGPT/Grok inspired dark theme
+"""
+import gradio as gr
+
+THEME_CSS = """
+/* ═══════════════════════════════════════════════════════════════════════════
+   ROOT VARIABLES
+   ═══════════════════════════════════════════════════════════════════════════ */
+:root {
+    --bg-primary: #0d0d0d;
+    --bg-secondary: #171717;
+    --bg-tertiary: #212121;
+    --bg-hover: #2a2a2a;
+    --bg-active: #333333;
+
+    --text-primary: #ececec;
+    --text-secondary: #9a9a9a;
+    --text-muted: #666666;
+
+    --border-color: #333333;
+    --border-light: #444444;
+
+    --accent-primary: #10a37f;
+    --accent-hover: #0d8c6d;
+    --accent-light: rgba(16, 163, 127, 0.1);
+
+    --error: #ef4444;
+    --warning: #f59e0b;
+    --success: #10b981;
+
+    --sidebar-width: 260px;
+    --header-height: 56px;
+    --input-height: 52px;
+
+    --radius-sm: 6px;
+    --radius-md: 12px;
+    --radius-lg: 16px;
+    --radius-full: 9999px;
+
+    --shadow-sm: 0 1px 2px rgba(0,0,0,0.3);
+    --shadow-md: 0 4px 6px rgba(0,0,0,0.4);
+    --shadow-lg: 0 10px 15px rgba(0,0,0,0.5);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   GLOBAL STYLES
+   ═══════════════════════════════════════════════════════════════════════════ */
+body, .gradio-container {
+    background: var(--bg-primary) !important;
+    color: var(--text-primary) !important;
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
+}
+
+.gradio-container {
+    max-width: 100% !important;
+    padding: 0 !important;
+    margin: 0 !important;
+}
+
+/* Hide Gradio footer */
+footer { display: none !important; }
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   SIDEBAR
+   ═══════════════════════════════════════════════════════════════════════════ */
+.sidebar {
+    background: var(--bg-secondary) !important;
+    border-right: 1px solid var(--border-color) !important;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+.sidebar-header {
+    padding: 12px 16px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.new-chat-btn {
+    width: 100%;
+    background: var(--bg-tertiary) !important;
+    border: 1px solid var(--border-color) !important;
+    color: var(--text-primary) !important;
+    padding: 12px 16px !important;
+    border-radius: var(--radius-md) !important;
+    font-weight: 500 !important;
+    transition: all 0.2s ease !important;
+}
+
+.new-chat-btn:hover {
+    background: var(--bg-hover) !important;
+}
+
+.session-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 8px;
+}
+
+.session-item {
+    padding: 10px 14px;
+    margin: 2px 0;
+    border-radius: var(--radius-md);
+    cursor: pointer;
+    color: var(--text-secondary);
+    font-size: 14px;
+    transition: all 0.15s ease;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.session-item:hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+}
+
+.session-item.active {
+    background: var(--bg-active);
+    color: var(--text-primary);
+}
+
+.session-group-title {
+    font-size: 11px;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    padding: 16px 14px 6px;
+    font-weight: 600;
+    letter-spacing: 0.5px;
+}
+
+.sidebar-footer {
+    padding: 12px;
+    border-top: 1px solid var(--border-color);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   CHAT AREA
+   ═══════════════════════════════════════════════════════════════════════════ */
+.chat-container {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    background: var(--bg-primary);
+}
+
+.chat-header {
+    height: var(--header-height);
+    padding: 0 20px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.model-selector {
+    background: var(--bg-tertiary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius-full) !important;
+    padding: 8px 16px !important;
+    font-size: 13px !important;
+    color: var(--text-primary) !important;
+}
+
+.chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 20px;
+    max-width: 800px;
+    margin: 0 auto;
+    width: 100%;
+}
+
+.message {
+    margin-bottom: 24px;
+    line-height: 1.6;
+}
+
+.message.user {
+    color: var(--text-primary);
+}
+
+.message.assistant {
+    color: var(--text-secondary);
+}
+
+.message-content {
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+/* Welcome screen */
+.welcome-container {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 40px;
+    text-align: center;
+}
+
+.welcome-title {
+    font-size: 28px;
+    font-weight: 600;
+    margin-bottom: 8px;
+    color: var(--text-primary);
+}
+
+.welcome-subtitle {
+    font-size: 16px;
+    color: var(--text-muted);
+    margin-bottom: 32px;
+}
+
+.suggestion-cards {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 12px;
+    max-width: 600px;
+}
+
+.suggestion-card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-md);
+    padding: 16px;
+    cursor: pointer;
+    text-align: left;
+    transition: all 0.2s ease;
+}
+
+.suggestion-card:hover {
+    background: var(--bg-tertiary);
+    border-color: var(--border-light);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   INPUT AREA
+   ═══════════════════════════════════════════════════════════════════════════ */
+.input-container {
+    padding: 16px 20px 24px;
+    max-width: 800px;
+    margin: 0 auto;
+    width: 100%;
+}
+
+.input-wrapper {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius-lg) !important;
+    padding: 4px !important;
+    display: flex;
+    align-items: flex-end;
+    gap: 8px;
+}
+
+.input-wrapper:focus-within {
+    border-color: var(--accent-primary) !important;
+    box-shadow: 0 0 0 2px var(--accent-light) !important;
+}
+
+.chat-input textarea {
+    background: transparent !important;
+    border: none !important;
+    color: var(--text-primary) !important;
+    font-size: 15px !important;
+    padding: 12px 16px !important;
+    resize: none !important;
+    min-height: 24px !important;
+    max-height: 200px !important;
+}
+
+.chat-input textarea::placeholder {
+    color: var(--text-muted) !important;
+}
+
+.input-actions {
+    display: flex;
+    gap: 4px;
+    padding: 8px;
+}
+
+.input-btn {
+    width: 36px !important;
+    height: 36px !important;
+    min-width: 36px !important;
+    padding: 0 !important;
+    border-radius: var(--radius-md) !important;
+    background: transparent !important;
+    border: none !important;
+    color: var(--text-muted) !important;
+    cursor: pointer;
+    transition: all 0.15s ease;
+}
+
+.input-btn:hover {
+    background: var(--bg-hover) !important;
+    color: var(--text-primary) !important;
+}
+
+.send-btn {
+    background: var(--accent-primary) !important;
+    color: white !important;
+}
+
+.send-btn:hover {
+    background: var(--accent-hover) !important;
+}
+
+.send-btn:disabled {
+    background: var(--bg-tertiary) !important;
+    color: var(--text-muted) !important;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   SETTINGS PANEL (Dropdown)
+   ═══════════════════════════════════════════════════════════════════════════ */
+.settings-panel {
+    position: absolute;
+    top: var(--header-height);
+    right: 20px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-md);
+    padding: 16px;
+    min-width: 280px;
+    box-shadow: var(--shadow-lg);
+    z-index: 100;
+}
+
+.settings-section {
+    margin-bottom: 16px;
+}
+
+.settings-label {
+    font-size: 12px;
+    color: var(--text-muted);
+    margin-bottom: 6px;
+    text-transform: uppercase;
+    font-weight: 600;
+}
+
+/* ═══════════════════════════════════════════════════════════════════��═══════
+   MODEL MANAGER
+   ═══════════════════════════════════════════════════════════════════════════ */
+.model-manager {
+    padding: 24px;
+    max-width: 1000px;
+    margin: 0 auto;
+}
+
+.model-table {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius-md) !important;
+}
+
+.model-table th {
+    background: var(--bg-tertiary) !important;
+    color: var(--text-secondary) !important;
+    font-weight: 600 !important;
+    text-transform: uppercase !important;
+    font-size: 11px !important;
+    letter-spacing: 0.5px !important;
+}
+
+.model-table td {
+    border-bottom: 1px solid var(--border-color) !important;
+}
+
+.model-table tr:hover td {
+    background: var(--bg-hover) !important;
+}
+
+/* Radio selection in table */
+.model-radio {
+    accent-color: var(--accent-primary);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   MODAL
+   ═══════════════════════════════════════════════════════════════════════════ */
+.modal-overlay {
+    position: fixed;
+    inset: 0;
+    background: rgba(0, 0, 0, 0.7);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+
+.modal {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    max-width: 600px;
+    width: 90%;
+    max-height: 80vh;
+    overflow: hidden;
+    box-shadow: var(--shadow-lg);
+}
+
+.modal-header {
+    padding: 16px 20px;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.modal-title {
+    font-size: 18px;
+    font-weight: 600;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    font-size: 20px;
+}
+
+.modal-body {
+    padding: 20px;
+    overflow-y: auto;
+    max-height: 60vh;
+}
+
+.modal-footer {
+    padding: 16px 20px;
+    border-top: 1px solid var(--border-color);
+    display: flex;
+    justify-content: flex-end;
+    gap: 12px;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   BUTTONS
+   ═══════════════════════════════════════════════════════════════════════════ */
+.btn {
+    padding: 10px 20px;
+    border-radius: var(--radius-md);
+    font-weight: 500;
+    font-size: 14px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    border: none;
+}
+
+.btn-primary {
+    background: var(--accent-primary) !important;
+    color: white !important;
+}
+
+.btn-primary:hover {
+    background: var(--accent-hover) !important;
+}
+
+.btn-secondary {
+    background: var(--bg-tertiary) !important;
+    color: var(--text-primary) !important;
+    border: 1px solid var(--border-color) !important;
+}
+
+.btn-secondary:hover {
+    background: var(--bg-hover) !important;
+}
+
+.btn-danger {
+    background: var(--error) !important;
+    color: white !important;
+}
+
+.btn-sm {
+    padding: 6px 12px !important;
+    font-size: 13px !important;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   FORM ELEMENTS
+   ═══════════════════════════════════════════════════════════════════════════ */
+input[type="text"],
+input[type="search"],
+textarea,
+select {
+    background: var(--bg-tertiary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius-md) !important;
+    color: var(--text-primary) !important;
+    padding: 10px 14px !important;
+    font-size: 14px !important;
+}
+
+input:focus,
+textarea:focus,
+select:focus {
+    border-color: var(--accent-primary) !important;
+    outline: none !important;
+    box-shadow: 0 0 0 2px var(--accent-light) !important;
+}
+
+/* Slider */
+input[type="range"] {
+    accent-color: var(--accent-primary);
+}
+
+/* Checkbox */
+input[type="checkbox"] {
+    accent-color: var(--accent-primary);
+}
+
+/* ═══════════════��═══════════════════════════════════════════════════════════
+   STATUS BADGES
+   ═══════════════════════════════════════════════════════════════════════════ */
+.badge {
+    display: inline-block;
+    padding: 4px 10px;
+    border-radius: var(--radius-full);
+    font-size: 12px;
+    font-weight: 500;
+}
+
+.badge-success {
+    background: rgba(16, 185, 129, 0.15);
+    color: var(--success);
+}
+
+.badge-warning {
+    background: rgba(245, 158, 11, 0.15);
+    color: var(--warning);
+}
+
+.badge-error {
+    background: rgba(239, 68, 68, 0.15);
+    color: var(--error);
+}
+
+.badge-info {
+    background: var(--accent-light);
+    color: var(--accent-primary);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   UTILITIES
+   ═══════════════════════════════════════════════════════════════════════════ */
+.hidden { display: none !important; }
+.flex { display: flex !important; }
+.flex-1 { flex: 1 !important; }
+.gap-2 { gap: 8px !important; }
+.gap-4 { gap: 16px !important; }
+.items-center { align-items: center !important; }
+.justify-between { justify-content: space-between !important; }
+.text-center { text-align: center !important; }
+.text-sm { font-size: 13px !important; }
+.text-muted { color: var(--text-muted) !important; }
+.mb-4 { margin-bottom: 16px !important; }
+.mt-4 { margin-top: 16px !important; }
+.p-4 { padding: 16px !important; }
+.w-full { width: 100% !important; }
+
+/* Scrollbar */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--border-color);
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--border-light);
+}
+"""
+
+
+def get_theme():
+    """Get Gradio theme (Soft dark)"""
+    return gr.themes.Soft(
+        primary_hue="emerald",
+        secondary_hue="gray",
+        neutral_hue="gray",
+        font=gr.themes.GoogleFont("Inter"),
+    ).set(
+        body_background_fill="#0d0d0d",
+        body_background_fill_dark="#0d0d0d",
+        block_background_fill="#171717",
+        block_background_fill_dark="#171717",
+        block_border_width="0px",
+        block_label_background_fill="#171717",
+        block_label_background_fill_dark="#171717",
+        input_background_fill="#212121",
+        input_background_fill_dark="#212121",
+        button_primary_background_fill="#10a37f",
+        button_primary_background_fill_dark="#10a37f",
+        button_primary_background_fill_hover="#0d8c6d",
+        button_primary_background_fill_hover_dark="#0d8c6d",
+    )