all of this was vibecoded. i just asked claude to fix all my bugs and he actually overhauled shit woaw. he only changed the name and position of a couple functions so if i want to write more things it should be fine. i love claude i love antrhopic i love vibecoding @claude make me a million dollars in a day make no mistake

bot.py

@@ -8,8 +8,8 @@ import random
 import traceback
 import discord
 import websockets
-from datetime import datetime
 from pathlib import Path
+from utils import nots, now_str, tail_lines
 
 def ignore_connection_closed_ok(loop, context): #this doesn't fucking work
     exc = context.get("exception")
@@ -19,9 +19,11 @@ def ignore_connection_closed_ok(loop, context): #this doesn't fucking work
 
 
 def load_system_prompt() -> str:
-    return Path("config/system_prompt.txt").read_text(encoding="utf-8")
+    return (CONFIG_DIR / "system_prompt.txt").read_text(encoding="utf-8")
 
-FILES_DIR    = Path("files")
+# resolve files relative to this script, not whatever dir it happens to get launched from
+SCRIPT_DIR   = Path(__file__).resolve().parent
+FILES_DIR    = SCRIPT_DIR / "files"
 LOG_DIR      = FILES_DIR / "log"
 MEDIA_DIR    = FILES_DIR / "media"
 CONFIG_DIR   = FILES_DIR / "config"
@@ -45,6 +47,10 @@ _config_lines = [l.strip() for l in (CONFIG_DIR / "tokens.txt").read_text(encodi
 TOKEN  = _config_lines[0]
 server = int(_config_lines[1])
 
+_conn_lines = [l.strip() for l in (CONFIG_DIR / "connection.txt").read_text(encoding="utf-8").splitlines() if l.strip() and not l.strip().startswith("#")]
+MAIN_URI   = _conn_lines[0]  # ws:// or wss:// address of main.py
+MAIN_TOKEN = _conn_lines[1]  # shared secret main.py checks on every payload
+
 intents = discord.Intents.default()
 intents.message_content = True
 intents.members = True
@@ -63,9 +69,6 @@ interaction_count = 0
 
 QUIET_COOLDOWN = 600  # seconds of silence before she's allowed to send a random message (10 mins)
 
-def timestamp() -> str:
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
 def log_error(text: str):
     with ERROR_FILE.open("a", encoding="utf-8") as f:
         f.write(text + "\n")
@@ -74,27 +77,19 @@ def log_message(text: str):
     with MEMORY_FILE.open("a", encoding="utf-8") as f:
         f.write(text + "\n")
 
-def nots(line: str) -> str:
-    if line.startswith("[") and "]" in line:
-        return line.split("]", 1)[1].lstrip()
-    return line
-
 def load_shortterm() -> list[str]:
     try:
-        with MEMORY_FILE.open("r", encoding="utf-8", errors="ignore") as f:
-            lines = f.readlines()[-15:]  # reads bottom 15 lines
-            return [line.strip() for line in lines if line.strip()]
+        return tail_lines(MEMORY_FILE, 15)  # reads bottom 15 lines without loading the whole file
     except Exception as e:
-        log_error(f"[{timestamp()}] error reading shortterm: {e}")
+        log_error(f"[{now_str()}] error reading shortterm: {e}")
         return []
 
 def load_longterm() -> list[str]:
     try:
-        with MEMORY_FILE.open("r", encoding="utf-8", errors="ignore") as f:
-            lines = [nots(line.strip()) for line in f if line.strip()]
-            return lines[-515:-15] if len(lines) > 15 else []
+        lines = [nots(l) for l in tail_lines(MEMORY_FILE, 515)]
+        return lines[:-15] if len(lines) > 15 else []
     except Exception as e:
-        log_error(f"[{timestamp()}] error reading longterm: {e}")
+        log_error(f"[{now_str()}] error reading longterm: {e}")
         return []
 
 def build_payload(user_input: str, rebuild: bool = False) -> str:
@@ -108,22 +103,28 @@ def build_payload(user_input: str, rebuild: bool = False) -> str:
         "shortterm":       load_shortterm(),
         "longterm":        load_longterm(),
         "rebuild_vectors": should_rebuild,
+        "auth_token":      MAIN_TOKEN,
     })
 
+_main_ws = None  # kept open across messages instead of reconnecting every time
+
 async def call_main(payload: str) -> tuple[bool, str]:
-    uri = "ws://0.0.0.0:8765"
+    global _main_ws
     try:
-        async with websockets.connect(uri, open_timeout=None, ping_timeout=None) as websocket:
-            await websocket.send(payload)
-            raw = await websocket.recv()
-            data = json.loads(raw)
-            if "error" in data:
-                return False, data["error"]
-            return True, data["ok"]
+        if _main_ws is None or _main_ws.closed:
+            _main_ws = await websockets.connect(MAIN_URI, open_timeout=None, ping_timeout=None)
+        await _main_ws.send(payload)
+        raw = await _main_ws.recv()
+        data = json.loads(raw)
+        if "error" in data:
+            return False, data["error"]
+        return True, data["ok"]
     except websockets.exceptions.ConnectionClosedOK:
-        return False, f"[{timestamp()}] websocket closed cleanly (no reply)"
+        _main_ws = None
+        return False, f"[{now_str()}] websocket closed cleanly (no reply)"
     except Exception as e:
-        return False, f"[{timestamp()}] websocket error: {e}"
+        _main_ws = None
+        return False, f"[{now_str()}] websocket error: {e}"
 
 async def handle_error(error_msg: str, notify_channel=None, notify_user=None):
     print(error_msg)
@@ -163,6 +164,22 @@ def steal_media(text: str):
     with MEDIA_FILE.open("a", encoding="utf-8") as f:
         f.write(text + "\n")
 
+def steal_attachments(message):
+    #steal images and gifs and stuff (always do this regardless of what else fires)
+    media_urls = [
+        a.url for a in message.attachments
+        if a.content_type and a.content_type.startswith(("image/", "video/"))
+    ]
+
+    for embed in message.embeds:
+        if embed.image and embed.image.url:
+            media_urls.append(embed.image.url)
+        if embed.video and embed.video.url:
+            media_urls.append(embed.video.url)
+
+    for url in media_urls:
+        steal_media(f"[{now_str()}] saved media: {url}")
+
 def resolve_mentions(content: str, guild) -> str:  # thank you claude
     if not guild:
         return content
@@ -205,17 +222,17 @@ async def random_dm():
                     dm = await victim.create_dm()
                     await dm.send(result)
                     dm_sent = True
-                    log_message(f"[{timestamp()}]Faggot-chan sent a random dm to {victim}: {result}")
-                    print(f"[{timestamp()}] random dm to {victim}: {result}")
+                    log_message(f"[{now_str()}]Faggot-chan sent a random dm to {victim}: {result}")
+                    print(f"[{now_str()}] random dm to {victim}: {result}")
                 except Exception as e:
-                    await handle_error(f"[{timestamp()}] failed to send dm to {victim}: {e}", notify_user=victim)
+                    await handle_error(f"[{now_str()}] failed to send dm to {victim}: {e}", notify_user=victim)
 async def random_message():
     await client.wait_until_ready()
     while not client.is_closed():
         await asyncio.sleep(600) #every 10 minutes
         if time.time() - last_server_message < QUIET_COOLDOWN: #only send if server has been quiet for 10 mins
             continue
-        if random.random() < 0.0001: #0.001%
+        if random.random() < 0.0001: #0.01%
             for guild in client.guilds:
                 channel = discord.utils.get(guild.text_channels, name="general")
                 if channel:
@@ -229,8 +246,8 @@ async def random_message():
                         await handle_error(result, notify_channel=channel)
                         continue
                     await channel.send(result)
-                    log_message(f"[{timestamp()}] random message: {result}")
-                    print(f"[{timestamp()}] random message: {result}")
+                    log_message(f"[{now_str()}] random message: {result}")
+                    print(f"[{now_str()}] random message: {result}")
 
 @client.event
 async def on_ready():
@@ -240,77 +257,64 @@ async def on_ready():
 
 
 @client.event
-async def on_random(message):
-    
-    RNG = random.randint(1,3)
-   
-    if message.author == client.user:
-        return
-
-
-    if not is_member_in_server(message.author):
-        return
-
-    if str(message.author.id) in block_id:
-         return
-
-    if not message.guild or message.guild.id != server:
-        return
-
-    if message.channel.name not in ["general", "announcements"]:
-         return
-
-    mentioned = client.user.mentioned_in(message)
-
-    #steal images and gifs and stuff (always do this regardless of what else fires)
-    media_urls = [
-        a.url for a in message.attachments
-        if a.content_type and a.content_type.startswith(("image/", "video/"))
-    ]
-
-    for embed in message.embeds:
-        if embed.image and embed.image.url:
-            media_urls.append(embed.image.url)
-        if embed.video and embed.video.url:
-            media_urls.append(embed.video.url)
-
-    for url in media_urls:
-        steal_media(f"[{timestamp()}] saved media: {url}")
-
-    #stickers - early exit, skip ai generation
+async def on_random(message) -> bool:
+    # single weighted pick between sticker/emoji/media, used as a substitute for an actual
+    # llm reply — only called once on_message already decided this message gets a response.
+    # returns True if it fired (caller should skip the llm call), False if it should proceed normally.
     stickers = list(message.guild.stickers)
-    if stickers and not mentioned and random.random() < 0.15: #15% chance of sending a sticker
-        chosen = random.choice(stickers)
-        try:
-            await message.channel.send(stickers=[chosen])
-            log_message(f"[{timestamp()}] Faggot-chan sent sticker: {chosen.name}")
-            print(f"[{timestamp()}] Faggot-chan sent sticker: {chosen.name}")
-        except websockets.exceptions.ConnectionClosedOK:
-            pass 
-        except Exception as e:
-            log_error(f"[{timestamp()}] error: {e}")
-            await message.reply("someone tell <@1000000000000001> there is a problem with my ai")
-            print(f"Sticker send failed: {e}")
-        return
-
     emojis = [str(e) for e in message.guild.emojis]
-    if emojis and not mentioned and random.random() < 0.2: #20% of reacting - early exit
-        try:
-            await message.add_reaction(random.choice(emojis))
-        except websockets.exceptions.ConnectionClosedOK:
-            pass 
-        except Exception as e:
-            log_error(f"[{timestamp()}] error: {e}")
-            await message.reply("someone tell <@1000000000000001> there is a problem with my ai")
-            print(f"Emoji reaction failed: {e}")
-        return
 
-    if random.random() < 0.1 and saved_media_urls: #10% of sending a stolen image - early exit, uses live set
-        chosen = random.choice(list(saved_media_urls))
-        await message.channel.send(chosen)
-        log_message(f"[{timestamp()}] Faggot-chan sent media: {chosen}")
-        print(f"[{timestamp()}] Faggot-chan sent media: {chosen}")
-        return
+    options = []
+    if stickers:
+        options.append(("sticker", 0.10))
+    if emojis:
+        options.append(("emoji", 0.13))
+    if saved_media_urls:
+        options.append(("media", 0.07))  # ~30% combined chance of firing when all three are available
+
+    if not options:
+        return False
+
+    roll = random.random()
+    cumulative = 0.0
+    for kind, weight in options:
+        cumulative += weight
+        if roll >= cumulative:
+            continue
+
+        if kind == "sticker":
+            chosen = random.choice(stickers)
+            try:
+                await message.channel.send(stickers=[chosen])
+                log_message(f"[{now_str()}] Faggot-chan sent sticker: {chosen.name}")
+                print(f"[{now_str()}] Faggot-chan sent sticker: {chosen.name}")
+            except websockets.exceptions.ConnectionClosedOK:
+                pass
+            except Exception as e:
+                log_error(f"[{now_str()}] error: {e}")
+                await message.reply("someone tell <@1000000000000001> there is a problem with my ai")
+                print(f"Sticker send failed: {e}")
+            return True
+
+        if kind == "emoji":
+            try:
+                await message.add_reaction(random.choice(emojis))
+            except websockets.exceptions.ConnectionClosedOK:
+                pass
+            except Exception as e:
+                log_error(f"[{now_str()}] error: {e}")
+                await message.reply("someone tell <@1000000000000001> there is a problem with my ai")
+                print(f"Emoji reaction failed: {e}")
+            return True
+
+        if kind == "media":
+            chosen = random.choice(list(saved_media_urls))
+            await message.channel.send(chosen)
+            log_message(f"[{now_str()}] Faggot-chan sent media: {chosen}")
+            print(f"[{now_str()}] Faggot-chan sent media: {chosen}")
+            return True
+
+    return False
 
 
 @client.event
@@ -332,6 +336,9 @@ async def on_message(message):
     if message.guild and message.channel.name not in ["general", "announcements"]:
         return
 
+    if message.guild:
+        steal_attachments(message)
+
     content = resolve_mentions(message.content, message.guild)
 
     # always detect replies
@@ -345,21 +352,19 @@ async def on_message(message):
                 if replied_message.author == client.user:
                     replied_to_bot = True
                 replied_content = resolve_mentions(replied_message.content, message.guild)
-                log_message(f'[{timestamp()}] {message.author} replied to {replied_message.author} saying: "{replied_content}" with reply: "{content}"')
+                log_message(f'[{now_str()}] {message.author} replied to {replied_message.author} saying: "{replied_content}" with reply: "{content}"')
             else:
-                log_message(f'[{timestamp()}] {message.author} said: {content}')
+                log_message(f'[{now_str()}] {message.author} said: {content}')
         except Exception as e:
-            log_error(f"[{timestamp()}] failed to resolve reply: {e}")
-            log_message(f'[{timestamp()}] {message.author} said: {content}')
+            log_error(f"[{now_str()}] failed to resolve reply: {e}")
+            log_message(f'[{now_str()}] {message.author} said: {content}')
     else:
-        log_message(f'[{timestamp()}] {message.author} said: {content}')
+        log_message(f'[{now_str()}] {message.author} said: {content}')
 
     interaction_count += 1
     rebuild = (interaction_count % 150 == 0)
 
     if message.guild is None: #dms now should work
-        if str(message.author.id) in block_id:
-            return
         dm_sent = False
         if replied_message:
             user_input = f'{message.author} replied to {replied_message.author} saying: "{replied_content}" with reply: "{content}"'
@@ -375,11 +380,10 @@ async def on_message(message):
             return
         try:
             await message.reply(result)
-            print(f"[{timestamp()}] DM from {message.author}: {content} Bot replied in DM: {result}")
-            log_message(f"[{timestamp()}] DM from {message.author}: {content}")
-            log_message(f"[{timestamp()}] Faggot-chan replied in DM: {result}")
+            print(f"[{now_str()}] DM from {message.author}: {content} Bot replied in DM: {result}")
+            log_message(f"[{now_str()}] Faggot-chan said in DM: {result}")
         except Exception as e:
-            await handle_error(f"[{timestamp()}] failed to send DM reply: {e}", notify_user=message.author)
+            await handle_error(f"[{now_str()}] failed to send DM reply: {e}", notify_user=message.author)
         return
 
     mentioned = client.user.mentioned_in(message)
@@ -397,6 +401,9 @@ async def on_message(message):
     if not mentioned and random.random() > 0.03: #3% chance of replying if not mentiond
         return
 
+    if await on_random(message):  # ~30% chance she just sends a sticker/emoji/media instead
+        return
+
     if replied_message:
         user_input = f'{message.author} replied to {replied_message.author} saying: "{replied_content}" with reply: "{content}"'
     else:
@@ -413,16 +420,14 @@ async def on_message(message):
 
     try:
         await message.reply(result)
-        print(f"[{timestamp()}] {message.author} said: {content}\n[{timestamp()}] Faggot-chan said: {result}")
-        log_message(f"[{timestamp()}] {message.author} said: {content}\n[{timestamp()}] Faggot-chan said: {result}")
+        print(f"[{now_str()}] {message.author} said: {content}\n[{now_str()}] Faggot-chan said: {result}")
+        log_message(f"[{now_str()}] Faggot-chan said: {result}")
         if str(message.author.id) == moralfag_id:
             moralfag_counter += 1
             if moralfag_counter >= faglimit:
                 moralfag_skip = True
                 moralfag_counter = 0
     except Exception as e:
-        await handle_error(f"[{timestamp()}] failed to send reply: {e}", notify_channel=message.channel)
-
-    await on_random(message)
+        await handle_error(f"[{now_str()}] failed to send reply: {e}", notify_channel=message.channel)
 
 client.run(TOKEN)