Update main_web.py

main_web.py

@@ -1,7 +1,285 @@
 import gradio as gr
+import asyncio
+import logging
+import os
+import sys
+import time
+import html
+import json
+import tempfile
+from typing import Optional, Dict, List, Tuple
 
-def greet(name):
-    return "Hello " + name + "!!"
+# --- Constants & Logger (Your original, stable code) ---
+APP_TITLE = "ZOTHEOS - Ethical Fusion AI"
+FAVICON_FILENAME = "favicon_blackBW.ico"
+LOGO_FILENAME = "zotheos_logo.png"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# Using your robust logger setup
+def init_logger():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    logger_instance = logging.getLogger("ZOTHEOS_Interface")
+    if not logger_instance.handlers:
+        handler = logging.StreamHandler(sys.stdout); handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")); logger_instance.addHandler(handler)
+    return logger_instance
+logger = init_logger()
+
+# --- Asset Path Helper (Your original, stable code) ---
+def get_asset_path(filename: str) -> Optional[str]:
+    base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
+    for path in [os.path.join(base_dir, 'assets', filename), os.path.join(base_dir, filename)]:
+        if os.path.exists(path):
+            logger.info(f"Asset found: '{filename}' -> '{path}'")
+            return path
+    logger.warning(f"Asset NOT FOUND: '{filename}'.")
+    return None
+
+logo_path_verified = get_asset_path(LOGO_FILENAME)
+favicon_path_verified = get_asset_path(FAVICON_FILENAME)
+
+# --- Core Logic & AI System Initialization (Your original, stable code) ---
+MainFusionPublic = None; initialization_error: Optional[Exception] = None; DEFAULT_INFERENCE_PRESET_INTERFACE = "balanced"; get_user_tier = lambda token: "error (auth module failed)"
+try:
+    script_dir = os.path.dirname(os.path.abspath(__file__)); project_root = script_dir
+    if project_root not in sys.path: sys.path.insert(0, project_root);
+    from modules.main_fusion_public import MainFusionPublic
+    try: from modules.config_settings_public import DEFAULT_INFERENCE_PRESET as CONFIG_DEFAULT_PRESET; DEFAULT_INFERENCE_PRESET_INTERFACE = CONFIG_DEFAULT_PRESET
+    except ImportError: logger.warning("Could not import DEFAULT_INFERENCE_PRESET.")
+    from modules.user_auth import get_user_tier as imported_get_user_tier; get_user_tier = imported_get_user_tier; logger.info("✅ Successfully imported MainFusionPublic and user_auth.")
+except Exception as e:
+    logger.error(f"❌ Error importing modules: {e}", exc_info=True); initialization_error = e
+
+ai_system: Optional[MainFusionPublic] = None
+if 'MainFusionPublic' in globals() and MainFusionPublic is not None and initialization_error is None:
+    try: logger.info("Initializing ZOTHEOS AI System..."); ai_system = MainFusionPublic(); logger.info("✅ ZOTHEOS AI System Initialized.")
+    except Exception as e_init: initialization_error = e_init; logger.error(f"❌ AI System Init Failed: {e_init}", exc_info=True); ai_system = None
+elif initialization_error is None: initialization_error = ModuleNotFoundError("MainFusionPublic could not be imported."); logger.error(f"❌ {initialization_error}")
+
+
+# --- TIER_FEATURES Dictionary (Your original, stable code) ---
+TIER_FEATURES = {"free": {"display_name": "Free Tier", "memory_enabled": False, "export_enabled": False}, "starter": {"display_name": "Starter Tier", "memory_enabled": True, "export_enabled": False}, "pro": {"display_name": "Pro Tier", "memory_enabled": True, "export_enabled": True}, "error (auth module failed)": {"display_name": "Error", "memory_enabled": False, "export_enabled": False}}
+
+#
+# --- NEW DESIGN: "ANCESTRAL TECH" (BLACK, WHITE, AZTEC TURQUOISE) ---
+#
+zotheos_base_css = """
+@import url('https://fonts.googleapis.com/css2?family=Teko:wght@400;600&family=Inter:wght@400;500&display=swap');
+
+:root {
+    --bg-main: #0A0A0A;
+    --bg-surface: #141414;
+    --text-primary: #E0E0E0;
+    --text-secondary: #707070;
+    --border-color: #282828;
+    --accent-turquoise: #40E0D0;
+    --accent-turquoise-dark: #32B3A6;
+
+    --font-display: 'Teko', 'Staatliches', sans-serif;
+    --font-body: 'Inter', sans-serif;
+    
+    --radius: 4px; /* Sharp, geometric corners */
+    --glow-shadow: 0 0 12px 0px rgba(64, 224, 208, 0.4);
+}
+
+/* --- Base Resets --- */
+footer, canvas { display: none !important; }
+html, body {
+    background-color: var(--bg-main) !important;
+    font-family: var(--font-body);
+    color: var(--text-primary);
+}
+.gradio-container {
+    max-width: 840px !important;
+    margin: 0 auto !important;
+    padding: 2rem 1.5rem !important;
+    background-color: transparent !important;
+}
+
+/* --- Header & Typography --- */
+#header_column { text-align: center; margin-bottom: 2rem; }
+#header_logo img {
+    max-height: 80px;
+    filter: brightness(0) invert(1); /* Ensure logo is pure white */
+    text-shadow: 0 0 10px rgba(255,255,255,0.3);
+}
+#header_subtitle {
+    font-family: var(--font-display) !important;
+    font-size: 1.4rem !important;
+    letter-spacing: 2px;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+}
+#welcome_message {
+    font-family: var(--font-display) !important;
+    font-size: 1.8rem !important;
+    letter-spacing: 1px;
+    text-transform: uppercase;
+    color: var(--text-primary);
+    border-top: 1px solid var(--border-color);
+    border-bottom: 1px solid var(--border-color);
+    padding: 0.5rem 0;
+    margin-bottom: 2rem;
+}
+
+/* --- Input & Interactive Elements --- */
+.gradio-textbox textarea, .gradio-textbox input {
+    background-color: var(--bg-surface) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius) !important;
+    color: var(--text-primary) !important;
+    transition: all 0.2s ease-in-out;
+}
+.gradio-textbox textarea:focus, .gradio-textbox input:focus {
+    border-color: var(--accent-turquoise) !important;
+    box-shadow: var(--glow-shadow);
+    background-color: #181818 !important;
+}
+#query_input textarea { min-height: 150px !important; font-size: 1rem; }
+
+/* --- Buttons --- */
+.gradio-button { border-radius: var(--radius) !important; transition: all 0.2s ease; border: 1px solid transparent; }
+#submit_button {
+    background: var(--accent-turquoise) !important;
+    color: #000 !important;
+    font-weight: 600 !important;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    border-color: var(--accent-turquoise) !important;
+}
+#submit_button:hover { background: var(--text-primary) !important; border-color: var(--text-primary) !important; transform: scale(1.02); }
+#clear_button { background: var(--bg-surface) !important; color: var(--text-secondary) !important; border-color: var(--border-color) !important; }
+#clear_button:hover { color: var(--text-primary) !important; border-color: var(--text-secondary) !important; }
+#export_memory_button { background: transparent !important; color: var(--text-secondary) !important; border: 1px dashed var(--border-color); }
+#export_memory_button.interactive_button_enabled { color: var(--accent-turquoise) !important; border-color: var(--accent-turquoise) !important; }
+#export_memory_button.interactive_button_enabled:hover { background: rgba(64, 224, 208, 0.1) !important; }
+
+/* --- Output & Accordions --- */
+#synthesized_summary_output, #fusion_output {
+    background-color: transparent !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius) !important;
+    padding: 1rem 1.5rem !important;
+}
+.gradio-accordion > .label-wrap {
+    background-color: var(--bg-surface) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: var(--radius) !important;
+}
+
+/* --- Tier Status & Footer --- */
+#tier_status_display small { color: var(--text-secondary) !important; font-size: 0.8rem; }
+#footer_attribution { font-size: 0.75rem; color: #444; text-align: center; margin-top: 3rem; }
+"""
+
+# --- All Helper Functions (Your original, stable code) ---
+def render_memory_entries_as_html(memory_entries: List[dict]) -> str:
+    # This function is fine as-is. The new CSS will style the output.
+    if not memory_entries: return "<div class='memory-entry'>No stored memory entries or memory disabled.</div>"
+    html_blocks = [];
+    for entry in reversed(memory_entries[-5:]):
+        query = html.escape(entry.get("query", "N/A")); ts_iso = entry.get("metadata", {}).get("timestamp_iso", "Unknown");
+        try: dt_obj = time.strptime(ts_iso, '%Y-%m-%dT%H:%M:%SZ'); formatted_ts = time.strftime('%Y-%m-%d %H:%M UTC', dt_obj)
+        except: formatted_ts = html.escape(ts_iso)
+        models_list = entry.get("metadata", {}).get("active_models_queried", []); models_str = html.escape(", ".join(models_list)) if models_list else "N/A"
+        summary_raw = entry.get("metadata", {}).get("synthesized_summary_text", "No summary."); summary = html.escape(summary_raw[:300]) + ("..." if len(summary_raw) > 300 else "")
+        html_blocks.append(f"<div class='memory-entry'><p><strong>🕒 TS:</strong> {formatted_ts}</p><p><strong>🧠 Models:</strong> {models_str}</p><div><strong>❓ Q:</strong><div class='query-text'>{query}</div></div><div><strong>📌 Sum:</strong><div class='summary-text'>{summary}</div></div></div>")
+    return "\n".join(html_blocks)
+
+def format_tier_status_for_ui(tier_name: str) -> str:
+    features = TIER_FEATURES.get(tier_name, TIER_FEATURES["error (auth module failed)"])
+    return f"<small>Tier: **{features['display_name']}** | Memory: {'✅' if features['memory_enabled'] else '❌'} | Export: {'✅' if features['export_enabled'] else '❌'}</small>"
+
+def update_tier_display_and_features_ui(user_token_str: Optional[str]) -> Tuple:
+    tier_name = get_user_tier(user_token_str or "")
+    tier_features = TIER_FEATURES.get(tier_name, TIER_FEATURES["free"])
+    return (gr.update(value=format_tier_status_for_ui(tier_name)), gr.update(interactive=tier_features["export_enabled"], elem_classes="interactive_button_enabled" if tier_features["export_enabled"] else ""))
+
+def clear_all_fields():
+    default_tier_name = get_user_tier(""); default_features = TIER_FEATURES.get(default_tier_name, TIER_FEATURES["free"])
+    return ("", "", gr.update(value=format_tier_status_for_ui(default_tier_name)), "Detailed perspectives...", "Synthesized insight...", "**Status:** Awaiting Input", "No memory entries loaded.", gr.update(interactive=default_features["export_enabled"], elem_classes="interactive_button_enabled" if default_features["export_enabled"] else ""), None)
+
+async def export_user_memory_data_for_download(user_token_str: Optional[str]) -> Optional[str]:
+    # This function is fine as-is.
+    try:
+        if not (tier_features := TIER_FEATURES.get(get_user_tier(user_token_str or ""), TIER_FEATURES["free"]))['export_enabled']: gr.Warning("🚫 Export is a Pro Tier feature."); return None
+        if not ai_system or not hasattr(ai_system, 'memory_bank'): gr.Error("⚠️ Memory system unavailable."); return None
+        memory_data = await ai_system.memory_bank.get_all_memories_for_export_async() if hasattr(ai_system.memory_bank, 'get_all_memories_for_export_async') else ai_system.memory_bank.get_all_memories_for_export()
+        if not memory_data: gr.Info("ℹ️ No memory to export."); return None
+        with tempfile.NamedTemporaryFile(delete=False, mode="w", suffix=".json", encoding="utf-8") as f: f.write(json.dumps(memory_data, indent=2)); return f.name
+    except Exception as e: logger.error(f"❌ Export error: {e}", exc_info=True); gr.Error(f"⚠️ Export error: {e}"); return None
+
+
+# --- Build Gradio Interface (Using your stable layout with the new CSS) ---
+def build_interface(logo_path_param: Optional[str], favicon_path_param: Optional[str]) -> gr.Blocks:
+    theme = gr.themes.Base(font=[gr.themes.GoogleFont("Inter"), "sans-serif"])
+    initial_tier_name = get_user_tier("")
+    initial_tier_features = TIER_FEATURES.get(initial_tier_name, TIER_FEATURES["free"])
+
+    # The favicon_path is correctly passed here, which will make the logo appear in the browser tab.
+    with gr.Blocks(theme=theme, css=zotheos_base_css, title=APP_TITLE, favicon_path=favicon_path_param) as demo:
+        with gr.Column(elem_classes="centered-container"):
+            # Using your proven layout structure
+            with gr.Column(elem_id="header_column"):
+                if logo_path_param: gr.Image(value=logo_path_param, elem_id="header_logo", show_label=False, container=False, interactive=False)
+                gr.Markdown("Ethical Fusion AI for Synthesized Intelligence", elem_id="header_subtitle")
+            gr.Markdown("💡 Fusing perspectives for deeper truth.", elem_id="welcome_message")
+            
+            # Auth Row
+            with gr.Row(elem_id="auth_row", equal_height=False):
+                user_token_input = gr.Textbox(label="🔑 Access Token", placeholder="Enter token...", type="password", elem_id="user_token_input", scale=3, container=False)
+                tier_status_display = gr.Markdown(value=format_tier_status_for_ui(initial_tier_name), elem_id="tier_status_display")
+            
+            # Input Group
+            with gr.Group(elem_classes="interface-section"):
+                query_input_component = gr.Textbox(label="Your Inquiry:", placeholder="e.g., Analyze the ethical implications of AI in art...", lines=6, elem_id="query_input")
+                status_indicator_component = gr.HTML(elem_id="status_indicator", visible=False)
+                with gr.Row():
+                    submit_button_component = gr.Button("Process Inquiry", elem_id="submit_button", variant="primary", scale=2)
+                    clear_button_component = gr.Button("Clear All", elem_id="clear_button", variant="secondary", scale=1)
+            
+            # Output Group
+            with gr.Group(elem_classes="interface-section"):
+                synthesized_summary_component = gr.Markdown(elem_id="synthesized_summary_output", value="Synthesized insight will appear here...")
+                fused_response_output_component = gr.Markdown(elem_id="fusion_output", value="Detailed perspectives will appear here...")
+            
+            # Tools & Footer (Your proven layout)
+            export_memory_button = gr.Button("⬇️ Export Memory Log", interactive=initial_tier_features["export_enabled"], elem_classes="interactive_button_enabled" if initial_tier_features["export_enabled"] else "")
+            with gr.Accordion("💡 System Status & Active Models", open=False): active_models_display_component = gr.Markdown("**Status:** Initializing...")
+            with gr.Accordion("🧠 Recent Interaction Chronicle (Last 5)", open=False): memory_display_panel_html = gr.HTML("No memory entries yet.")
+            gr.Markdown("--- \n ZOTHEOS © 2025 ZOTHEOS LLC. System Architect: David A. Garcia.", elem_id="footer_attribution")
+
+        # --- Event Handlers (Using your stable, robust logic) ---
+        # This is your original, stable processing wrapper.
+        async def process_query_wrapper_internal(query, token):
+            loading_html = f"<div class='cosmic-loading'><div class='orbital-spinner'></div><div class='thinking-text'>ZOTHEOS is synthesizing...</div></div>"
+            yield (gr.update(value=loading_html, visible=True), gr.update(interactive=False), gr.update(interactive=False), "", "", "", "Loading...")
+            if not ai_system or initialization_error:
+                error_html = f"🚫 Core System Error: {html.escape(str(initialization_error))}"
+                yield (gr.update(value=error_html, visible=True), gr.update(interactive=True), gr.update(interactive=True), "System error.", "System error.", "Offline", "Memory unavailable.")
+                return
+            response = await ai_system.process_query_with_fusion(query, user_token=token, fusion_mode_override=DEFAULT_INFERENCE_PRESET_INTERFACE)
+            # Your original parsing logic here
+            summary = "## ✨ ZOTHEOS Final Synthesized Insight ✨\n" + (res.split("## ✨ ZOTHEOS Final Synthesized Insight ✨")[-1] if "## ✨ ZOTHEOS Final Synthesized Insight ✨" in (res:=response) else res)
+            perspectives = "## 🧠 ZOTHEOS Fused Perspectives 🧠\n" + (res.split("## ✨ ZOTHEOS Final Synthesized Insight ✨")[0] if "## ✨ ZOTHEOS Final Synthesized Insight ✨" in res else "Details in summary.")
+            tier_name = get_user_tier(token or "")
+            mem_html = render_memory_entries_as_html(await ai_system.memory_bank.retrieve_recent_memories_async(limit=5)) if TIER_FEATURES[tier_name]['memory_enabled'] and hasattr(ai_system, 'memory_bank') else "Memory disabled."
+            status_report = await ai_system.get_status_report()
+            status_md = f"**Active Cores:** `{', '.join(status_report.get('models_last_queried_for_perspectives', ['N/A']))}`"
+            yield (gr.update(visible=False), gr.update(interactive=True), gr.update(interactive=True), summary, perspectives, status_md, mem_html)
+
+        submit_button_component.click(fn=process_query_wrapper_internal, inputs=[query_input_component, user_token_input], outputs=[status_indicator_component, submit_button_component, clear_button_component, synthesized_summary_component, fused_response_output_component, active_models_display_component, memory_display_panel_html], show_progress="hidden")
+        clear_button_component.click(fn=clear_all_fields, outputs=[query_input_component, user_token_input, tier_status_display, fused_response_output_component, synthesized_summary_component, active_models_display_component, memory_display_panel_html, export_memory_button, None], show_progress="hidden")
+        user_token_input.change(fn=update_tier_display_and_features_ui, inputs=[user_token_input], outputs=[tier_status_display, export_memory_button], show_progress="hidden")
+        export_memory_button.click(fn=export_user_memory_data_for_download, inputs=[user_token_input], outputs=[])
+
+    return demo
+
+# --- Main Execution Block (Your original, stable code) ---
+if __name__ == "__main__":
+    logger.info("--- Initializing ZOTHEOS Gradio Interface (V13 - Ancestral Tech) ---")
+    zotheos_interface = build_interface(logo_path_verified, favicon_path_verified)
+    logger.info("✅ ZOTHEOS Gradio UI built.")
+    if initialization_error: print(f"‼️ WARNING: ZOTHEOS AI System failed to initialize fully: {initialization_error}")
+    elif not ai_system: print(f"‼️ WARNING: ZOTHEOS AI System object is None. Backend will not function.")
+    else: print("✅ ZOTHEOS AI System appears initialized.")
+    launch_kwargs = {"server_name": "0.0.0.0", "server_port": int(os.getenv("PORT", 7860)), "share": os.getenv("GRADIO_SHARE", "False").lower() == "true"}
+    zotheos_interface.queue().launch(**launch_kwargs)