Changes to be committed:

app.py

@@ -1,91 +1,374 @@
 import gradio as gr
-import torch
-from PIL import Image
-import numpy as np
-from transformers import pipeline
-from diffusers import AutoPipelineForInpainting
-import requests
-from io import BytesIO
-
-# ----------------------------
-# 1. Load models (lazy init for HF Spaces)
-# ----------------------------
-detector = None
-inpainter = None
-
-def load_models():
-    global detector, inpainter
-    if detector is None:
-        print("Loading Grounding DINO...")
-        detector = pipeline(
-            "object-detection",
-            model="facebook/grounding-dino-base",
-            device="cpu"
-        )
-    if inpainter is None:
-        print("Loading Stable Diffusion 3 Inpainting...")
-        inpainter = AutoPipelineForInpainting.from_pretrained(
-            "stabilityai/stable-diffusion-3-medium",
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            safety_checker=None,
-        )
-        if torch.cuda.is_available():
-            inpainter = inpainter.to("cuda")
-
-# ----------------------------
-# 2. Core logic
-# ----------------------------
-def remove_horse(image: Image.Image) -> Image.Image:
-    load_models()
-    
-    # Detect horses
-    results = detector(image, candidate_labels="horse")
-    horse_detections = [r for r in results if r['label'] == 'horse' and r['score'] > 0.3]
-    
-    if not horse_detections:
-        return image  # No horse? Return original.
-    
-    # Create mask (white on black)
-    mask = np.zeros(image.size[::-1], dtype=np.uint8)
-    for det in horse_detections:
-        box = det['box']
-        x0, y0 = int(box['xmin']), int(box['ymin'])
-        x1, y1 = int(box['xmax']), int(box['ymax'])
-        mask[y0:y1, x0:x1] = 255
-    
-    mask_img = Image.fromarray(mask).convert("L")
-    
-    # Inpaint
-    prompt = "a natural scene with no horse, seamless background, photorealistic"
-    edited = inpainter(
-        prompt=prompt,
-        image=image,
-        mask_image=mask_img,
-        num_inference_steps=28,
-        strength=0.99,
-        guidance_scale=7.0
-    ).images[0]
+import logging
+from contextlib import contextmanager
+from typing import Optional
+import re
+import json
+
+# === Internal Imports (your fixed backend) ===
+from smolagents import Tool
+from sqlalchemy import create_engine, Column, Integer, String, Text, DateTime, ForeignKey
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+import discum
+from datetime import datetime
+
+# === Configuration ===
+DB_PATH = "sqlite:///discord_bots.db"
+Base = declarative_base()
+engine = create_engine(DB_PATH, echo=False)
+SessionLocal = sessionmaker(bind=engine)
+
+# === Logging ===
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# === Models (same as before) ===
+class Personality(Base):
+    __tablename__ = 'personalities'
+    id = Column(Integer, primary_key=True)
+    name = Column(String, nullable=False)
+    base_prompt = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+class ChannelConfig(Base):
+    __tablename__ = 'channel_configs'
+    id = Column(Integer, primary_key=True)
+    channel_id = Column(String, nullable=False)
+    personality_id = Column(Integer, ForeignKey('personalities.id'))
+    context_analysis = Column(Text)
+    adapted_prompt = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    personality = relationship("Personality")
+
+Base.metadata.create_all(engine)
+
+# === Global State ===
+_discum_clients = {}  # token_id (int) -> discum.Client
+
+# === Utilities ===
+@contextmanager
+def get_db_session():
+    session = SessionLocal()
+    try:
+        yield session
+        session.commit()
+    except Exception as e:
+        session.rollback()
+        logger.exception("Database error")
+        raise
+    finally:
+        session.close()
+
+def validate_discord_id(discord_id: str) -> bool:
+    return bool(re.fullmatch(r'\d+', discord_id))
+
+# === Core Tool Functions (refactored for Gradio) ===
+def create_personality(name: str, base_prompt: str):
+    if not name.strip() or not base_prompt.strip():
+        return gr.update(value="❌ Error: Name and base prompt cannot be empty.", visible=True), None
+    try:
+        with get_db_session() as session:
+            personality = Personality(name=name.strip(), base_prompt=base_prompt.strip())
+            session.add(personality)
+            session.flush()
+            pid = personality.id
+        return gr.update(value=f"✅ Personality '{name}' created with ID: {pid}", visible=True), pid
+    except Exception as e:
+        logger.error(f"Create personality error: {e}")
+        return gr.update(value="❌ Failed to create personality.", visible=True), None
+
+def configure_channel(channel_id: str, personality_id: str, context_analysis: str):
+    if not channel_id or not personality_id or not context_analysis.strip():
+        return gr.update(value="❌ All fields are required.", visible=True)
+    if not validate_discord_id(channel_id):
+        return gr.update(value="❌ Invalid Channel ID (must be numeric).", visible=True)
+    try:
+        pid = int(personality_id)
+        if pid <= 0:
+            raise ValueError("Invalid ID")
+        with get_db_session() as session:
+            personality = session.query(Personality).filter(Personality.id == pid).first()
+            if not personality:
+                return gr.update(value=f"❌ Personality ID {pid} not found.", visible=True)
+            config = ChannelConfig(
+                channel_id=channel_id,
+                personality_id=pid,
+                context_analysis=context_analysis.strip()
+            )
+            session.add(config)
+        return gr.update(value=f"✅ Channel {channel_id} configured with personality {pid}", visible=True)
+    except ValueError:
+        return gr.update(value="❌ Personality ID must be a positive integer.", visible=True)
+    except Exception as e:
+        logger.error(f"Configure channel error: {e}")
+        return gr.update(value="❌ Failed to configure channel.", visible=True)
+
+def generate_channel_prompt(channel_id: str, personality_id: str, llm_analysis: str):
+    if not channel_id or not personality_id or not llm_analysis.strip():
+        return gr.update(value="❌ All fields are required.", visible=True), ""
+    if not validate_discord_id(channel_id):
+        return gr.update(value="❌ Invalid Channel ID.", visible=True), ""
+    try:
+        pid = int(personality_id)
+        if pid <= 0:
+            raise ValueError
+        with get_db_session() as session:
+            personality = session.query(Personality).filter(Personality.id == pid).first()
+            if not personality:
+                return gr.update(value="❌ Personality not found.", visible=True), ""
+            prompt = f"{personality.base_prompt}\n\nChannel Context:\n{llm_analysis.strip()}"
+            config = session.query(ChannelConfig).filter(
+                ChannelConfig.channel_id == channel_id,
+                ChannelConfig.personality_id == pid
+            ).first()
+            if config:
+                config.adapted_prompt = prompt
+            else:
+                config = ChannelConfig(
+                    channel_id=channel_id,
+                    personality_id=pid,
+                    adapted_prompt=prompt
+                )
+                session.add(config)
+        return gr.update(value="✅ Prompt generated and saved.", visible=True), prompt
+    except ValueError:
+        return gr.update(value="❌ Personality ID must be a positive integer.", visible=True), ""
+    except Exception as e:
+        logger.error(f"Generate prompt error: {e}")
+        return gr.update(value="❌ Failed to generate prompt.", visible=True), ""
+
+def get_channel_prompt(channel_id: str, personality_id: str):
+    if not channel_id or not personality_id:
+        return gr.update(value="❌ Both fields required.", visible=True), ""
+    if not validate_discord_id(channel_id):
+        return gr.update(value="❌ Invalid Channel ID.", visible=True), ""
+    try:
+        pid = int(personality_id)
+        if pid <= 0:
+            raise ValueError
+        with get_db_session() as session:
+            config = session.query(ChannelConfig).filter(
+                ChannelConfig.channel_id == channel_id,
+                ChannelConfig.personality_id == pid
+            ).first()
+            if config and config.adapted_prompt:
+                return gr.update(value="✅ Prompt retrieved.", visible=True), config.adapted_prompt
+            return gr.update(value="ℹ️ No adapted prompt found.", visible=True), ""
+    except ValueError:
+        return gr.update(value="❌ Personality ID must be a positive integer.", visible=True), ""
+    except Exception as e:
+        logger.error(f"Get prompt error: {e}")
+        return gr.update(value="❌ Failed to retrieve prompt.", visible=True), ""
+
+def initialize_bot(token_id: str, token: str):
+    if not token_id or not token.strip():
+        return gr.update(value="❌ Token ID and token are required.", visible=True)
+    try:
+        tid = int(token_id)
+        if tid <= 0:
+            raise ValueError("Invalid token ID")
+        if len(token) < 50:
+            return gr.update(value="❌ Token appears invalid (too short).", visible=True)
+        if tid in _discum_clients:
+            _discum_clients[tid].close()
+        client = discum.Client(token=token, log=False)
+        _discum_clients[tid] = client
+        return gr.update(value=f"✅ Bot initialized with Token ID: {tid}", visible=True)
+    except ValueError:
+        return gr.update(value="❌ Token ID must be a positive integer.", visible=True)
+    except Exception as e:
+        logger.error(f"Bot init error: {e}")
+        return gr.update(value="❌ Failed to initialize bot. Check token.", visible=True)
+
+def send_message(token_id: str, channel_id: str, message: str):
+    if not token_id or not channel_id or not message.strip():
+        return gr.update(value="❌ All fields required.", visible=True)
+    if not validate_discord_id(channel_id):
+        return gr.update(value="❌ Invalid Channel ID.", visible=True)
+    try:
+        tid = int(token_id)
+        if tid not in _discum_clients:
+            return gr.update(value="❌ Bot not initialized. Use 'Initialize Bot' first.", visible=True)
+        client = _discum_clients[tid]
+        client.sendMessage(channel_id, message.strip())
+        return gr.update(value="✅ Message sent successfully!", visible=True)
+    except ValueError:
+        return gr.update(value="❌ Token ID must be an integer.", visible=True)
+    except Exception as e:
+        logger.error(f"Send message error: {e}")
+        return gr.update(value="❌ Failed to send message. Check bot permissions.", visible=True)
+
+def get_channel_messages(token_id: str, channel_id: str, limit: int):
+    if not token_id or not channel_id:
+        return gr.update(value="❌ Token ID and Channel ID required.", visible=True), ""
+    if not validate_discord_id(channel_id):
+        return gr.update(value="❌ Invalid Channel ID.", visible=True), ""
+    try:
+        tid = int(token_id)
+        if tid not in _discum_clients:
+            return gr.update(value="❌ Bot not initialized.", visible=True), ""
+        limit = max(1, min(limit, 100))
+        client = _discum_clients[tid]
+        resp = client.getMessages(channel_id, num=limit)
+        if resp.status_code != 200:
+            return gr.update(value=f"❌ Discord API error: {resp.status_code}", visible=True), ""
+        messages = resp.json()
+        formatted = json.dumps(messages, indent=2)
+        return gr.update(value="✅ Messages retrieved.", visible=True), formatted
+    except ValueError:
+        return gr.update(value="❌ Token ID must be an integer.", visible=True), ""
+    except Exception as e:
+        logger.error(f"Get messages error: {e}")
+        return gr.update(value="❌ Failed to fetch messages.", visible=True), ""
+
+# === Gradio Interface ===
+with gr.Blocks(title="Discord Personality Bot Manager") as demo:
+    gr.Markdown("# 🤖 Discord Personality Bot Manager")
+    gr.Markdown("Manage AI personalities, configure channels, and interact with Discord via a secure web interface.")
     
-    return edited
-
-# ----------------------------
-# 3. Gradio UI
-# ----------------------------
-with gr.Blocks(title="NO HORSE") as demo:
-    gr.Markdown("# 🐴 NO HORSE")
-    gr.Markdown("Upload an image. Horses will be **erased from reality**.")
-    with gr.Row():
-        input_img = gr.Image(type="pil", label="Input (with horse)")
-        output_img = gr.Image(type="pil", label="Output (no horse)")
-    btn = gr.Button("PURGE HORSE")
-    btn.click(fn=remove_horse, inputs=input_img, outputs=output_img)
-    gr.Examples(
-        examples=["examples/horse1.jpg", "examples/horse2.jpg"],
-        inputs=input_img
-    )
-
-# ----------------------------
-# Launch
-# ----------------------------
+    with gr.Tabs():
+        # === Documentation Tab ===
+        with gr.Tab("📘 Documentation"):
+            gr.Markdown("""
+            ## How to Use This Tool
+
+            ### Step 1: Initialize Your Bot
+            - Go to **Bot Management** → **Initialize Bot**
+            - Provide a **Token ID** (any positive integer, e.g., `1`) and your **Discord token**
+            - ⚠️ **Never share your token!** It grants full account access.
+
+            ### Step 2: Create a Personality
+            - Go to **Personality Management** → **Create Personality**
+            - Give it a name (e.g., "Sarcastic Helper") and a base prompt (e.g., "You are a witty assistant...")
+
+            ### Step 3: Configure a Channel
+            - Get your Discord **Channel ID** (enable Developer Mode in Discord → right-click channel → Copy ID)
+            - Use **Configure Channel** to link a personality to a channel with context analysis
+            - Or use **Generate Channel Prompt** to auto-create an adapted prompt
+
+            ### Step 4: Interact
+            - Use **Get Channel Prompt** to see the final prompt
+            - Use **Send Message** to post as your bot
+            - Use **Get Messages** to fetch recent channel history
+
+            ---
+            **Security Notes**:
+            - Tokens are stored in memory only (not saved to disk)
+            - Always close the browser tab when done
+            - Re-initialize if the bot disconnects
+            """)
+
+        # === Personality Management ===
+        with gr.Tab("🧠 Personality Management"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Create New Personality")
+                    name_input = gr.Textbox(label="Personality Name", placeholder="e.g., Helpful Assistant")
+                    prompt_input = gr.Textbox(label="Base Prompt", lines=3, placeholder="Describe the personality...")
+                    create_btn = gr.Button("Create Personality")
+                    create_status = gr.Textbox(label="Status", interactive=False, visible=False)
+                    created_id = gr.Number(label="Created Personality ID", visible=False)
+
+                with gr.Column():
+                    gr.Markdown("### Generate Channel-Specific Prompt")
+                    gen_ch_id = gr.Textbox(label="Channel ID")
+                    gen_pid = gr.Textbox(label="Personality ID")
+                    llm_analysis = gr.Textbox(label="LLM Context Analysis", lines=3, placeholder="e.g., This channel discusses Python programming...")
+                    gen_btn = gr.Button("Generate & Save Prompt")
+                    gen_status = gr.Textbox(label="Status", interactive=False, visible=False)
+                    gen_output = gr.Textbox(label="Generated Prompt", lines=5, interactive=False)
+
+            create_btn.click(
+                create_personality,
+                inputs=[name_input, prompt_input],
+                outputs=[create_status, created_id]
+            )
+            gen_btn.click(
+                generate_channel_prompt,
+                inputs=[gen_ch_id, gen_pid, llm_analysis],
+                outputs=[gen_status, gen_output]
+            )
+
+        # === Channel Configuration ===
+        with gr.Tab("⚙️ Channel Configuration"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Configure Channel with Personality")
+                    conf_ch_id = gr.Textbox(label="Channel ID")
+                    conf_pid = gr.Textbox(label="Personality ID")
+                    context_analysis = gr.Textbox(label="Context Analysis", lines=3, placeholder="Describe the channel's purpose...")
+                    conf_btn = gr.Button("Configure Channel")
+                    conf_status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+                with gr.Column():
+                    gr.Markdown("### Retrieve Channel Prompt")
+                    get_ch_id = gr.Textbox(label="Channel ID")
+                    get_pid = gr.Textbox(label="Personality ID")
+                    get_btn = gr.Button("Get Prompt")
+                    get_status = gr.Textbox(label="Status", interactive=False, visible=False)
+                    get_output = gr.Textbox(label="Adapted Prompt", lines=5, interactive=False)
+
+            conf_btn.click(
+                configure_channel,
+                inputs=[conf_ch_id, conf_pid, context_analysis],
+                outputs=conf_status
+            )
+            get_btn.click(
+                get_channel_prompt,
+                inputs=[get_ch_id, get_pid],
+                outputs=[get_status, get_output]
+            )
+
+        # === Bot Management ===
+        with gr.Tab("🤖 Bot Management"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Initialize Discord Bot")
+                    token_id_input = gr.Textbox(label="Token ID (e.g., 1)", placeholder="Positive integer")
+                    token_input = gr.Textbox(label="Discord Token", type="password", placeholder="Paste your token here")
+                    init_btn = gr.Button("Initialize Bot")
+                    init_status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+                with gr.Column():
+                    gr.Markdown("### Send Message to Channel")
+                    send_token_id = gr.Textbox(label="Token ID")
+                    send_ch_id = gr.Textbox(label="Channel ID")
+                    message_input = gr.Textbox(label="Message", lines=3)
+                    send_btn = gr.Button("Send Message")
+                    send_status = gr.Textbox(label="Status", interactive=False, visible=False)
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Get Channel Messages")
+                    msg_token_id = gr.Textbox(label="Token ID")
+                    msg_ch_id = gr.Textbox(label="Channel ID")
+                    limit_slider = gr.Slider(1, 100, value=10, label="Number of Messages")
+                    get_msgs_btn = gr.Button("Fetch Messages")
+                    msgs_status = gr.Textbox(label="Status", interactive=False, visible=False)
+                    messages_output = gr.Textbox(label="Messages (JSON)", lines=10, interactive=False)
+
+            init_btn.click(
+                initialize_bot,
+                inputs=[token_id_input, token_input],
+                outputs=init_status
+            )
+            send_btn.click(
+                send_message,
+                inputs=[send_token_id, send_ch_id, message_input],
+                outputs=send_status
+            )
+            get_msgs_btn.click(
+                get_channel_messages,
+                inputs=[msg_token_id, msg_ch_id, limit_slider],
+                outputs=[msgs_status, messages_output]
+            )
+
+# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7860,
+        show_error=True,
+        share=False  # Set to True for public link (use cautiously!)
+    )