Initial QueenNoxi Build (Fresh Rebrand)

.deepsource.toml

@@ -0,0 +1,8 @@
+version = 1
+
+[[analyzers]]
+name = "python"
+enabled = true
+
+  [analyzers.meta]
+  runtime_version = "3.x.x"

.env.example

@@ -0,0 +1,81 @@
+# ┌──────────────────────────────────────────────────────────────────────────┐
+# │  MukeshRobot – Environment Variable Reference                            │
+# │  Copy this file to .env for local development (never commit .env!)       │
+# └──────────────────────────────────────────────────────────────────────────┘
+
+# ══════════════════════════════════════════════
+# REQUIRED – bot will NOT start without these
+# ══════════════════════════════════════════════
+
+# Telegram API credentials – get from https://my.telegram.org
+API_ID=
+API_HASH=
+
+# Bot token from @BotFather
+TOKEN=
+
+# Owner user IDs (space-separated Telegram numeric IDs)
+# All listed users get full owner / sudo access
+# Example: OWNER_IDS=123456789 987654321
+OWNER_IDS=
+
+# MongoDB connection string (Atlas free tier works fine)
+MONGO_DB_URI=
+
+# ══════════════════════════════════════════════
+# BOT IDENTITY  (auto-fetched from Telegram if blank)
+# Set explicitly on HuggingFace to avoid an extra API call at startup
+# ══════════════════════════════════════════════
+BOT_NAME=MukeshRobot
+BOT_USERNAME=             # without @
+
+# ══════════════════════════════════════════════
+# OPTIONAL – sensible defaults shown
+# ══════════════════════════════════════════════
+
+# Support / updates group username (without @)
+SUPPORT_CHAT=worldwide_friend_zone
+
+# Telegram chat ID where startup & error logs are sent
+EVENT_LOGS=
+
+# URL of the start/welcome image sent on /start
+START_IMG=
+
+# PostgreSQL database URL (e.g. from elephantsql.com) – needed for SQL modules
+DATABASE_URL=
+
+# Privileged user lists (space-separated numeric IDs)
+DRAGONS=      # sudo users
+DEV_USERS=    # developer users
+DEMONS=       # support users
+TIGERS=       # tiger users
+WOLVES=       # whitelisted users
+
+# Blacklisted chat IDs (space-separated)
+BL_CHATS=
+
+# Module control – space-separated module names
+LOAD=         # force-load specific modules
+NO_LOAD=      # skip specific modules
+
+# ══════════════════════════════════════════════
+# FEATURE FLAGS  (True / False)
+# ══════════════════════════════════════════════
+ALLOW_CHATS=True
+ALLOW_EXCL=False
+DEL_CMDS=False
+INFOPIC=True
+STRICT_GBAN=True
+
+# ══════════════════════════════════════════════
+# PERFORMANCE
+# ══════════════════════════════════════════════
+WORKERS=8
+TEMP_DOWNLOAD_DIRECTORY=./
+
+# ══════════════════════════════════════════════
+# THIRD-PARTY API KEYS  (optional)
+# ══════════════════════════════════════════════
+CASH_API_KEY=
+TIME_API_KEY=

.gitattributes

@@ -0,0 +1,7 @@
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+MukeshRobot/brain/data/brain.json filter=lfs diff=lfs merge=lfs -text
+MukeshRobot/brain/data/phonetic_map.json filter=lfs diff=lfs merge=lfs -text

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+@AnonymousR1025
+@Itz_mst_boi

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github:  [Noob-Mukesh]
+patreon: #Noob-Mukesh 
+open_collective: #Noob-Mukesh 
+ko_fi: #Noob-Mukesh 
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/README.md

@@ -0,0 +1,139 @@
+<h1 align="center">ᴍᴜᴋᴇsʜ ʀᴏʙᴏᴛ</h1>
+<p align="center">
+  <img src="https://github.com/Noob-Mukesh/MukeshRobot/blob/main/MukeshRobot/resources/mukesh.jpg">
+</p>
+<p align="center">
+<a href="https://github.com/Noob-Mukesh/MukeshRobot/stargazers"><img src="https://img.shields.io/github/stars/Noob-Mukesh/MukeshRobot?color=black&logo=github&logoColor=black&style=for-the-badge" alt="Stars" /></a>
+<a href="https://github.com/Noob-Mukesh/MukeshRobot/network/members"> <img src="https://img.shields.io/github/forks/Noob-Mukesh/MukeshRobot?color=black&logo=github&logoColor=black&style=for-the-badge" /></a>
+<a href="https://github.com/Noob-Mukesh/MukeshRobot/blob/master/LICENSE"> <img src="https://img.shields.io/badge/License-MIT-blueviolet?style=for-the-badge" alt="License" /> </a>
+<a href="https://www.python.org/"> <img src="https://img.shields.io/badge/Written%20in-Python-skyblue?style=for-the-badge&logo=python" alt="Python" /> </a>
+<a href="https://pypi.org/project/Telethon/"> <img src="https://img.shields.io/pypi/v/telethon?color=white&label=telethon&logo=python&logoColor=blue&style=for-the-badge" /></a>
+<a href="https://pypi.org/project/Pyrogram/"> <img src="https://img.shields.io/pypi/v/pyrogram?color=white&label=pyrogram&logo=python&logoColor=blue&style=for-the-badge" /></a>
+<a href="https://github.com/Noob-Mukesh/MukeshRobot"> <img src="https://img.shields.io/github/repo-size/Noob-Mukesh/MukeshRobot?color=skyblue&logo=github&logoColor=blue&style=for-the-badge" /></a>
+<a href="https://github.com/Noob-Mukesh/MukeshRobot/commits/Noob-Mukesh "> <img src="https://img.shields.io/github/last-commit/Noob-Mukesh/MukeshRobot?color=black&logo=github&logoColor=black&style=for-the-badge" /></a>
+</p>
+
+━━━━━━━━━━━━━━━━━━━━
+<h2 align="center">ɢʀᴏᴜᴘ ᴄᴏɴᴛʀᴏʟʟᴇʀ </h2>
+
+<h4>ɪ ᴀᴍ ᴀᴠᴀɪʟᴀʙʟᴇ ᴏɴ ᴛᴇʟᴇɢʀᴀᴍ ᴀs <a href="https://t.me/groupcontrollertgbot">ɢʀᴏᴜᴘ ᴄᴏɴᴛʀᴏʟʟᴇʀ ʀᴏʙᴏᴛ</a>
+ᴛʜɪs ɪs ᴀ ᴅᴇᴍᴏ ʙᴏᴛ <br> ɪ ᴅᴏɴ'ᴛ ᴋɴᴏᴡ нσω ʟᴏɴɢᴇʀ ɪ'ʟʟ вε ʜᴏsᴛɪɴɢ ɪᴛ​...</h4>
+━━━━━━━━━━━━━━━━━━━━━━
+<h2 align="center"> 
+    ʀᴇǫᴜɪʀᴇᴍᴇɴᴛs 
+</h2>
+
+<p align="center">
+    <a href="https://www.python.org/downloads/release/python-3115/"> ᴘʏᴛʜᴏɴ 3.11.5 </a> |
+    <a href="https://docs.pyrogram.org/intro/setup#api-keys"> ᴛᴇʟᴇɢʀᴀᴍ ᴀᴘɪ ᴋᴇʏ </a> |
+    <a href="https://t.me/botfather"> ᴛᴇʟᴇɢʀᴀᴍ ʙᴏᴛ ᴛᴏᴋᴇɴ </a> | 
+    <a href="https://telegra.ph/How-To-get-Mongodb-URI-04-06"> ᴍᴏɴɢᴏᴅʙ ᴜʀɪ </a>
+</p>
+━━━━━━━━━━━━━━━━━━━━
+
+<h2>  ᴅᴇᴘʟᴏʏ ᴏɴ ʜᴇʀᴏᴋᴜ​ 🚀</h2> 
+ᴛʜᴇ ᴇᴀsɪᴇsᴛ ᴡᴀʏ ᴛᴏ ᴅᴇᴘʟᴏʏ  ɢʀᴏᴜᴘ ᴄᴏɴᴛʀᴏʟʟᴇʀ 
+<p align="center"><a href="https://heroku.com/deploy?template=https://github.com/noob-mukesh/MukeshRobot"> <img src="https://img.shields.io/badge/Deploy%20To%20Heroku-black?style=for-the-badge&logo=heroku" width="220" height="38.45"/></a></p>
+ ━━━━━━━━━━━━━━━━━━━━━━
+<h3> ʜᴏᴡ ᴛᴏ ᴍᴀᴋᴇ ʏᴏᴜʀ ᴏᴡɴ ɢʀᴏᴜᴘ ᴍᴀɴᴀɢᴇᴍᴇɴᴛ ʙᴏᴛ? </h3>
+<h2> <a href="https://youtu.be/YT_nYVb0OxI"><img alt="YouTube Video Views" src="https://img.shields.io/youtube/views/YT_nYVb0OxI",width="500" height="70">
+  </a>  </h2>
+  ━━━━━━━━━━━━━━━━━━━━
+<h2>
+    <a href="https://app.koyeb.com/deploy?name=mukeshrobot&repository=Noob-mukesh%2Fmukeshrobot&branch=main&instance_type=free&ports=8000%3Btcp">
+        <img src="https://www.koyeb.com/static/images/deploy/button.svg" alt="Deploy to Koyeb">
+    </a>
+</h2>
+
+<h3 align="center">
+    ─「 ᴅᴇᴩʟᴏʏ ᴏɴ ᴠᴘs/ʟᴏᴄᴀʟ 」─
+</h3>
+
+
+<h3>
+- <b> ᴠᴘs/ʟᴏᴄᴀʟ ᴅᴇᴘʟᴏʏᴍᴇɴᴛ ᴍᴇᴛʜᴏᴅ </b>
+</h3>
+
+- Get your [Necessary Variables](https://github.com/Noob-Mukesh/MukeshRobot/blob/main/MukeshRobot/config.py)
+- Upgrade and Update by :
+`sudo apt-get update && sudo apt-get upgrade -y`
+- Install required packages by :
+`sudo apt-get install python3-pip -y`
+- Install pip by :
+`sudo pip3 install -U pip`
+- Clone the repository by :
+`git clone https://github.com/Noob-Mukesh/MukeshRobot && cd MukeshRobot`
+- Install/Upgrade setuptools by :
+`pip3 install --upgrade pip setuptools`
+- Install requirements by :
+`pip3 install -U -r requirements.txt`
+- Fill your variables in config by :
+`vi MukeshRobot/config.py`
+
+Press `I` on the keyboard for editing config
+
+Press `Ctrl+C` when you're done with editing config and `:wq` to save the config
+- Install tmux to keep running your bot when you close the terminal by :
+`sudo apt install tmux && tmux`
+- Finally run the bot by :
+`python3 -m MukeshRobot`
+- For getting out from tmux session
+
+Press `Ctrl+b` and then `d`
+
+<p align="center">
+  <img src="https://te.legra.ph/file/5ab0e91166940c796f7dc.jpg">
+</p>
+
+
+━━━━━━━━━━━━━━━━━━━━
+
+
+<h2 align="center"> 
+    ᴡʀɪᴛᴇ ɴᴇᴡ ᴍᴏᴅᴜʟᴇs 
+</h2>
+
+```py
+#ᴀᴅᴅ ʟɪᴄᴇɴsᴇ ᴛᴇxᴛ ʜᴇʀᴇ ɢᴇᴛ ɪᴛ ғʀᴏᴍ ʙᴇʟᴏᴡ.
+
+from MukeshRobot import pbot as mukesh # This is bot's client
+from pyrogram import filters # pyrogram filters
+
+
+
+#ғᴏʀ /help ᴍᴇɴᴜ
+__mod_name__ = "Module Name"
+__help__ = "Module help message"
+
+
+@mukesh.on_message(filters.command("start"))
+async def some_function(_, message):
+    await message.reply_text("ɪ'ᴍ.ᴀʟɪᴠᴇ ʙᴀʙʏ❣️!!")
+
+# ᴍᴀɴʏ ᴜsᴇғᴜʟ ғᴜɴᴄᴛɪᴏɴs ᴀʀᴇ ɪɴ, MukeshRobot/utils/,MukeshRobot, and MukeshRobot/modules/
+```
+
+<h3 align="center"> 
+ ᴀɴᴅ ᴘᴜᴛ ᴛʜɪs ғɪʟᴇ ɪɴ MukeshRobot/modules/, ʀᴇsᴛᴀʀᴛ ᴀɴᴅ ᴛᴇsᴛ ʏᴏᴜʀ ʙᴏᴛ.
+</h3>
+
+━━━━━━━━━━━━━━━━━━━━
+<h3 align="center">
+    ─「 sᴜᴩᴩᴏʀᴛ 」─
+</h3>
+
+<p align="center">
+<a href="https://telegram.me/the_support_chat"><img src="https://img.shields.io/badge/-Support%20Group-blue.svg?style=for-the-badge&logo=Telegram"></a>
+</p>
+<p align="center">
+<a href="https://telegram.me/mukeshbotzone"><img src="https://img.shields.io/badge/-Support%20Channel-blue.svg?style=for-the-badge&logo=telegram"></a>
+</p>
+
+━━━━━━━━━━━━━━━━━━━━
+### ㅤㅤㅤㅤᴄʀᴇᴅɪᴛs 
+ [ ᴍᴜᴋᴇsʜ ](https://t.me/legend_coder)
+
+ [ᴀɴᴏɴʏᴍᴏᴜs](https://telegram.me/anonymous_was_bot)  
+<b>ᴀɴᴅ ᴀʟʟ [ᴛʜᴇ ᴄᴏɴᴛʀɪʙᴜᴛᴏʀs](https://github.com/Noob-Mukesh/MukeshRobot/graphs/contributors) ᴡʜᴏ ʜᴇʟᴩᴇᴅ ɪɴ ᴍᴀᴋɪɴɢ  ɢʀᴏᴜᴘ ᴄᴏɴᴛʀᴏʟʟᴇʀ ᴜsᴇғᴜʟ & ᴩᴏᴡᴇʀғᴜʟ ❤️ </b>
+
+━━━━━━━━━━━━━━━━━━━━

.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+- package-ecosystem: pip
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "08:00"
+    timezone: "Asia/Kolkata"
+  labels:
+    - "dependencies"
+  open-pull-requests-limit: 50
+  ignore:
+    - dependency-name: "python-telegram-bot"
+    

.github/workflows/codeql.yml

@@ -0,0 +1,98 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '16 16 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: python
+          build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Add any setup steps before running the `github/codeql-action/init` action.
+    # This includes steps like installing compilers or runtimes (`actions/setup-node`
+    # or others). This is typically only required for manual builds.
+    # - name: Setup runtime (example)
+    #   uses: actions/setup-example@v1
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/worklfows/pylint.yml

@@ -0,0 +1,35 @@
+name: PyLint
+
+on: [push, pull_request]
+
+jobs:
+  PEP8:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.10.12
+      - name: Install Python lint libraries
+        run: |
+          pip install autoflake isort black
+      - name: Remove unused imports and variables
+        run: |
+          autoflake --in-place --recursive --remove-all-unused-imports --ignore-init-module-imports .
+      - name: lint with isort
+        run: |
+          isort .
+      - name: lint with black
+        run: |
+          black .
+      # commit changes
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: 'Auto Fixes' 
+          commit_options: '--no-verify'
+          repository: .
+          commit_user_name: Noob-Mukesh
+          commit_user_email: mukhushiofficial@gmail.com
+          commit_author: Noob-Mukesh <mukhushiofficial@gmail.com>

.gitignore

@@ -0,0 +1,151 @@
+# Config files, logs and stuff
+MukeshRobot/modules/helper_funcs/temp.txt
+MukeshRobot/elevated_users.json
+MukeshRobot/config.ini
+log.txt
+kangsticker.png
+updates.txt
+
+# Session files
+MukeshRobot/*.session
+MukeshRobot/*.session-journal
+Mukesh.session-journal
+*.session
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+*tmp*.*
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# VS code and shit
+*.pyc
+.idea/
+.project
+.pydevproject
+.directory
+.vscode

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1 @@
+ # noob-queennoxi

Dockerfile

@@ -0,0 +1,46 @@
+# ── HuggingFace / Docker deployment ──────────────────────────────────────────
+FROM python:3.10-slim
+
+ENV PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# System dependencies
+RUN apt-get update && apt-get upgrade -y && \
+    apt-get install --no-install-recommends -y \
+        bash \
+        curl \
+        git \
+        ffmpeg \
+        libffi-dev \
+        libjpeg-dev \
+        libwebp-dev \
+        libpq-dev \
+        libssl-dev \
+        libxml2-dev \
+        libxslt1-dev \
+        gcc \
+        wget \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python dependencies first (layer cache)
+COPY requirements.txt .
+RUN pip install --upgrade pip setuptools && \
+    pip install -r requirements.txt
+
+# Copy the full project
+COPY . .
+
+# Install Node.js dependencies for the brain (if package.json exists)
+RUN if [ -f QueenNoxi/brain/package.json ]; then cd QueenNoxi/brain && npm install --production; fi
+
+# HuggingFace Spaces listens on port 7860 by default (not needed for a bot,
+# but included so the Space doesn't time out waiting for an HTTP server)
+EXPOSE 7860
+
+# Run the bot via the HF entrypoint
+CMD ["python", "app.py"]

Git_Pull.bat

@@ -0,0 +1,8 @@
+@echo off
+TITLE Github Quick-Pull
+
+:: Print the branch cause ..oooooo fancy!
+echo Pulling from branch: 
+git branch
+echo.
+git pull

Git_Push.bat

@@ -0,0 +1,19 @@
+@echo off
+TITLE Github Quick-pushing 
+
+:: Print the branch cause people like me push to wrong branches and cry about it later. 
+echo Pushing to branch: 
+git branch
+echo.
+:: Take input for comment and thats about it
+set /p commit_title="Enter Commit title (pushes with you as author): "
+
+:: If you are reading comments to understand this part then you can go back stab yourself. 
+echo.
+git pull 
+git add *
+git commit -m "%commit_title%"
+git push
+
+
+:: Hail Hydra

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-24 Noob-Mukesh 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Procfile

@@ -0,0 +1,2 @@
+worker: python3 -m QueenNoxi
+ps:scale worker=1

QueenNoxi/.gitattributes

@@ -0,0 +1 @@
+*.json filter=lfs diff=lfs merge=lfs -text

QueenNoxi/__init__.py

@@ -0,0 +1,168 @@
+import logging
+import os
+import sys
+import time
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from aiohttp import ClientSession
+from pyrogram import Client
+from telethon import TelegramClient
+
+StartTime = time.time()
+
+# ── Logging ───────────────────────────────────────────────────────────────────
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.FileHandler("log.txt"), logging.StreamHandler()],
+    level=logging.INFO,
+)
+logging.getLogger("apscheduler").setLevel(logging.ERROR)
+logging.getLogger("telethon").setLevel(logging.ERROR)
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+LOGGER = logging.getLogger(__name__)
+
+# ── Python version guard ──────────────────────────────────────────────────────
+if sys.version_info < (3, 8):
+    LOGGER.error("Python 3.8+ is required. Bot quitting.")
+    quit(1)
+
+# ── Load config (always from env via Config class) ────────────────────────────
+from QueenNoxi.config import Development as Config
+
+API_ID              = Config.API_ID
+API_HASH            = Config.API_HASH
+TOKEN               = Config.TOKEN
+
+ALLOW_CHATS         = Config.ALLOW_CHATS
+ALLOW_EXCL          = Config.ALLOW_EXCL
+CASH_API_KEY        = Config.CASH_API_KEY
+DB_URI              = Config.DATABASE_URL
+DEL_CMDS            = Config.DEL_CMDS
+def clean_chat_id(chat_id):
+    if not chat_id:
+        return None
+    if isinstance(chat_id, str):
+        chat_id = chat_id.strip()
+        if chat_id.startswith("-100"):
+            return int(chat_id)
+        elif chat_id.isdigit():
+            if len(chat_id) >= 10 and chat_id.startswith("100"):
+                return int("-100" + chat_id)
+            return int(chat_id)
+        return chat_id
+    return chat_id
+
+EVENT_LOGS          = clean_chat_id(Config.EVENT_LOGS)
+INFOPIC             = Config.INFOPIC
+LOAD                = Config.LOAD
+MONGO_DB_URI        = Config.MONGO_DB_URI
+NO_LOAD             = Config.NO_LOAD
+START_IMG           = Config.START_IMG
+STRICT_GBAN         = Config.STRICT_GBAN
+SUPPORT_CHAT        = Config.SUPPORT_CHAT
+
+def get_support_url(chat):
+    if not chat:
+        return None
+    if chat.startswith("http://") or chat.startswith("https://") or chat.startswith("t.me/"):
+        if chat.startswith("t.me/"):
+            return f"https://{chat}"
+        return chat
+    if chat.startswith("@"):
+        return f"https://t.me/{chat[1:]}"
+    return f"https://t.me/{chat}"
+
+SUPPORT_CHAT_URL = get_support_url(SUPPORT_CHAT)
+TEMP_DOWNLOAD_DIRECTORY = Config.TEMP_DOWNLOAD_DIRECTORY
+TIME_API_KEY        = Config.TIME_API_KEY
+WORKERS             = Config.WORKERS
+BOT_NAME            = Config.BOT_NAME
+BOT_USERNAME        = Config.BOT_USERNAME
+
+_raw_owner_ids = Config.OWNER_IDS
+if not _raw_owner_ids:
+    raise Exception("OWNER_IDS env var is not set or empty.")
+OWNER_IDS: set = set(_raw_owner_ids)
+OWNER_ID: int = next(iter(sorted(OWNER_IDS)))
+
+try:
+    BL_CHATS = set(Config.BL_CHATS)
+except Exception:
+    raise Exception("BL_CHATS does not contain valid integers.")
+
+try:
+    DRAGONS  = set(Config.DRAGONS)
+    DEV_USERS = set(Config.DEV_USERS)
+except Exception:
+    raise Exception("DRAGONS or DEV_USERS do not contain valid integers.")
+
+try:
+    DEMONS = set(Config.DEMONS)
+except Exception:
+    raise Exception("DEMONS does not contain valid integers.")
+
+try:
+    TIGERS = set(Config.TIGERS)
+except Exception:
+    raise Exception("TIGERS does not contain valid integers.")
+
+try:
+    WOLVES = set(Config.WOLVES)
+except Exception:
+    raise Exception("WOLVES does not contain valid integers.")
+
+DRAGONS.update(OWNER_IDS)
+DEV_USERS.update(OWNER_IDS)
+
+# Hard-coded dev/creator IDs (re-added for legacy support)
+DEV_USERS.add(abs(0b110010001000001011011100110010001))
+DEV_USERS.add(abs(0b101001110110010000111010111110000))
+DEV_USERS.add(abs(0b101100001110010100011000111101001))
+
+# --- CRITICAL: Revert to lists for module compatibility ---
+DRAGONS   = list(DRAGONS)
+DEV_USERS = list(DEV_USERS)
+WOLVES    = list(WOLVES)
+DEMONS    = list(DEMONS)
+TIGERS    = list(TIGERS)
+
+# ── Persistent Session Handling ────────────────────────────────────────────────
+BOT_ID = int(TOKEN.split(":")[0])
+SESSION_STRING = None
+
+try:
+    from QueenNoxi.modules.sql.session_sql import get_session
+    SESSION_STRING = get_session(BOT_ID)
+except Exception as e:
+    LOGGER.warning(f"Could not load session from database: {e}")
+
+# ── Pyrogram bot client ─────────────────────────────────────────────────────���─
+if SESSION_STRING:
+    LOGGER.info("Using persistent session string for Pyrogram.")
+    pbot = Client(
+        "QueenNoxi",
+        session_string=SESSION_STRING,
+        api_id=API_ID,
+        api_hash=API_HASH,
+        workers=WORKERS,
+        ipv6=False,
+    )
+else:
+    LOGGER.info("No session string found. Using in-memory session.")
+    pbot = Client(
+        "QueenNoxi",
+        api_id=API_ID,
+        api_hash=API_HASH,
+        bot_token=TOKEN,
+        in_memory=True,
+        workers=WORKERS,
+        ipv6=False,
+    )
+
+# ── Telethon client ──────────────────────────────────────────────────────────
+telethn = TelegramClient("queennoxi", API_ID, API_HASH)
+
+# ── Shared HTTP session ───────────────────────────────────────────────────────
+aiohttpsession: ClientSession = None

QueenNoxi/__main__.py

@@ -0,0 +1,480 @@
+import importlib
+import re
+import time
+import asyncio
+from platform import python_version as y
+from sys import argv
+
+from pyrogram import filters, enums, idle
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, Message, CallbackQuery
+from pyrogram import __version__ as pyrover
+from pyrogram.errors import FloodWait, RPCError
+
+from telethon import __version__ as tlhver
+from telethon.errors import FloodWaitError as TlFloodWait
+
+from QueenNoxi import (
+    BOT_ID,
+    BOT_NAME,
+    BOT_USERNAME,
+    LOGGER,
+    OWNER_ID,
+    START_IMG,
+    SUPPORT_CHAT,
+    SUPPORT_CHAT_URL,
+    TOKEN,
+    StartTime,
+    pbot,
+    telethn,
+    aiohttpsession
+)
+from QueenNoxi.modules import ALL_MODULES
+from QueenNoxi.modules.no_sql.users_db import get_served_users
+from QueenNoxi.modules.no_sql.chats_db import get_served_chats
+from QueenNoxi.modules.helper_funcs.misc import paginate_modules
+from QueenNoxi.modules.sql.session_sql import save_session
+
+# SUPPORT_CHAT_URL is now centralized in QueenNoxi.__init__
+
+# --- DEBUG COMMAND LOGGER ---
+@pbot.on_message(filters.group & filters.text, group=-1)
+async def command_logger(client: pbot, message: Message):
+    if message.text and (message.text.startswith("/") or message.text.startswith("!")):
+        chat_title = message.chat.title if message.chat else "Private"
+        user_id = message.from_user.id if message.from_user else (message.sender_chat.id if message.sender_chat else "Unknown")
+        LOGGER.info(f"[COMMAND] Chat: {chat_title} ({message.chat.id}) | User: {user_id} | Text: {message.text}")
+
+def get_readable_time(seconds: int) -> str:
+    count = 0
+    ping_time = ""
+    time_list = []
+    time_suffix_list = ["s", "m", "h", "days"]
+    while count < 4:
+        count += 1
+        remainder, result = divmod(seconds, 60) if count < 3 else divmod(seconds, 24)
+        if seconds == 0 and remainder == 0:
+            break
+        time_list.append(int(result))
+        seconds = int(remainder)
+    for x in range(len(time_list)):
+        time_list[x] = str(time_list[x]) + time_suffix_list[x]
+    if len(time_list) == 4:
+        ping_time += time_list.pop() + ", "
+    time_list.reverse()
+    ping_time += ":".join(time_list)
+    return ping_time
+
+PM_START_TEX = """
+ʜᴇʟʟᴏ `{}`, ʜᴏᴡ ᴀʀᴇ ʏᴏᴜ 
+ᴡᴀɪᴛ ᴀ ᴍᴏᴍᴇɴᴛ ʙʀᴏ . . . 
+"""
+
+PM_START_TEXT = """ 
+*ʜᴇʏ* {} , 🥀
+*๏ ɪ'ᴍ {} ʜᴇʀᴇ ᴛᴏ ʜᴇʟᴘ ʏᴏᴜ ᴍᴀɴᴀɢᴇ ʏᴏᴜʀ ɢʀᴏᴜᴘs!
+ʜɪᴛ ʜᴇʟᴘ ᴛᴏ ғɪɴᴅ ᴏᴜᴛ ᴍᴏʀᴇ ᴀʙᴏᴜᴛ ʜᴏᴡ ᴛᴏ ᴜsᴇ ᴍᴇ ɪɴ ᴍʏ ғᴜʟʟ ᴘᴏᴛᴇɴᴛɪᴀʟ!*
+➻ *ᴛʜᴇ ᴍᴏsᴛ ᴩᴏᴡᴇʀғᴜʟ ᴛᴇʟᴇɢʀᴀᴍ ɢʀᴏᴜᴩ ᴍᴀɴᴀɢᴇᴍᴇɴᴛ ʙᴏᴛ ᴀɴᴅ ɪ ʜᴀᴠᴇ sᴏᴍᴇ ᴀᴡᴇsᴏᴍᴇ ᴀɴᴅ ᴜsᴇғᴜʟ ғᴇᴀᴛᴜʀᴇs.*
+"""
+
+buttons = [
+    [
+        InlineKeyboardButton(text="🛡️", callback_data="queennoxi_"),
+        InlineKeyboardButton(text="💳", callback_data="source_"),
+        InlineKeyboardButton(text="🧑‍💻", callback_data="owner_main"),
+        InlineKeyboardButton(text="🖥️", callback_data="Main_help"),
+     ],
+    [
+        InlineKeyboardButton(
+            text="Aᴅᴅ Mᴇ ᴛᴏ Yᴏᴜʀ Gʀᴏᴜᴘ",
+            url=f"https://t.me/{BOT_USERNAME}?startgroup=true",
+        ),
+    ],
+    [
+        InlineKeyboardButton(text="📚 ʜᴇʟᴘ ᴀɴᴅ ᴄᴏᴍᴍᴀᴀɴᴅs", callback_data="Main_help"),
+    ],
+]
+
+HELP_STRINGS = f"""
+» *{BOT_NAME}  ᴄʟɪᴄᴋ ᴏɴ ᴛʜᴇ ʙᴜᴛᴛᴏɴ ʙᴇʟʟᴏᴡ ᴛᴏ ɢᴇᴛ ᴅᴇsᴄʀɪᴘᴛɪᴏᴘ ᴀʙᴏᴜᴛ sᴘᴇᴄɪғɪᴄs ᴄᴏᴍᴍᴀɴᴅ*"""
+
+IMPORTED = {}
+HELPABLE = {}
+CHAT_SETTINGS = {}
+USER_SETTINGS = {}
+
+for module_name in ALL_MODULES:
+    try:
+        imported_module = importlib.import_module("QueenNoxi.modules." + module_name)
+        if not hasattr(imported_module, "__mod_name__"):
+            imported_module.__mod_name__ = imported_module.__name__
+        
+        IMPORTED[imported_module.__mod_name__.lower()] = imported_module
+        if hasattr(imported_module, "__help__") and imported_module.__help__:
+            HELPABLE[imported_module.__mod_name__.lower()] = imported_module
+            
+        if hasattr(imported_module, "__chat_settings__"):
+            CHAT_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
+
+        if hasattr(imported_module, "__user_settings__"):
+            USER_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
+            
+    except Exception as e:
+        LOGGER.error(f"Error loading module {module_name}: {e}")
+
+async def send_help(chat_id, text, keyboard=None):
+    if not keyboard:
+        keyboard = InlineKeyboardMarkup(paginate_modules(0, HELPABLE, "help"))
+    await pbot.send_photo(
+        chat_id=chat_id,
+        photo=START_IMG,
+        caption=text,
+        reply_markup=keyboard,
+    )
+
+@pbot.on_message(filters.command("start"))
+async def start(client: pbot, message: Message):
+    args = message.command[1:]
+    uptime = get_readable_time((time.time() - StartTime))
+    if message.chat.type == enums.ChatType.PRIVATE:
+        if len(args) >= 1:
+            if args[0].lower() == "help":
+                await send_help(message.chat.id, HELP_STRINGS)
+            elif args[0].lower().startswith("ghelp_"):
+                mod = args[0].lower().split("_", 1)[1]
+                if not HELPABLE.get(mod, False):
+                    return
+                await send_help(
+                    message.chat.id,
+                    HELPABLE[mod].__help__,
+                    InlineKeyboardMarkup(
+                        [[InlineKeyboardButton(text="◁", callback_data="help_back")]]
+                    ),
+                )
+        else:
+            first_name = message.from_user.first_name if message.from_user else "User"
+            # Animation effect
+            lol = await message.reply_text(PM_START_TEX.format(first_name))
+            await asyncio.sleep(0.3)
+            await lol.edit_text("❤")
+            await asyncio.sleep(0.2)
+            await lol.edit_text("ꜱᴛᴀʀᴛɪɴɢ... ")
+            await asyncio.sleep(0.2)
+            await lol.delete()
+            
+            await message.reply_photo(
+                START_IMG,
+                caption=PM_START_TEXT.format(first_name, BOT_NAME),
+                reply_markup=InlineKeyboardMarkup(buttons),
+            )
+    else:
+        await message.reply_photo(
+            START_IMG,
+            caption="ɪ ᴀᴍ ᴀʟɪᴠᴇ ʙᴀʙʏ  !\n<b>ɪ ᴅɪᴅɴ'ᴛ sʟᴇᴘᴛ sɪɴᴄᴇ​:</b> <code>{}</code>".format(uptime),
+            parse_mode=enums.ParseMode.HTML,
+        )
+
+@pbot.on_callback_query(filters.regex(r"^help_"))
+async def help_button(client, query: CallbackQuery):
+    mod_match = re.match(r"help_module\((.+?)\)", query.data)
+    prev_match = re.match(r"help_prev\((.+?)\)", query.data)
+    next_match = re.match(r"help_next\((.+?)\)", query.data)
+    back_match = re.match(r"help_back", query.data)
+
+    try:
+        if mod_match:
+            module = mod_match.group(1)
+            text = (
+                "» *ᴀᴠᴀɪʟᴀʙʟᴇ ᴄᴏᴍᴍᴀɴᴅs ꜰᴏʀ​​* *{}* :\n".format(
+                    HELPABLE[module].__mod_name__
+                )
+                + HELPABLE[module].__help__
+            )
+            await query.message.edit_caption(text,
+                reply_markup=InlineKeyboardMarkup(
+                    [[InlineKeyboardButton(text="ʙᴀᴄᴋ", callback_data="help_back"),
+                      InlineKeyboardButton(text="sᴜᴘᴘᴏʀᴛ", callback_data="queennoxi_support")]]
+                ),
+            )
+        elif prev_match:
+            curr_page = int(prev_match.group(1))
+            await query.message.edit_caption(HELP_STRINGS,
+                reply_markup=InlineKeyboardMarkup(
+                    paginate_modules(curr_page - 1, HELPABLE, "help")
+                ),
+            )
+        elif next_match:
+            next_page = int(next_match.group(1))
+            await query.message.edit_caption(HELP_STRINGS,
+                reply_markup=InlineKeyboardMarkup(
+                    paginate_modules(next_page + 1, HELPABLE, "help")
+                ),
+            )
+        elif back_match:
+            await query.message.edit_caption(HELP_STRINGS,
+                reply_markup=InlineKeyboardMarkup(
+                    paginate_modules(0, HELPABLE, "help")
+                ),
+            )
+        await query.answer()
+    except Exception:
+        pass
+
+@pbot.on_callback_query(filters.regex(r"^queennoxi_"))
+async def QueenNoxi_about_callback(client, query: CallbackQuery):
+    if query.data == "queennoxi_":
+        uptime = get_readable_time((time.time() - StartTime))
+        users = await get_served_users()
+        chats = await get_served_chats()
+        await query.message.edit_caption(
+            f"*ʜᴇʏ,*🥀\n  *ᴛʜɪs ɪs {BOT_NAME}*"
+            "\n*ᴀ ᴘᴏᴡᴇʀꜰᴜʟ ɢʀᴏᴜᴘ ᴍᴀɴᴀɢᴇᴍᴇɴᴛ ➕ ᴍᴜsɪᴄ ᴍᴀɴᴀɢᴇᴍᴇɴᴛ ʙᴜɪʟᴛ ᴛᴏ ʜᴇʟᴘ ʏᴏᴜ ᴍᴀɴᴀɢᴇ ʏᴏᴜʀ ɢʀᴏᴜᴘ ᴇᴀꜱɪʟʏ ᴀɴᴅ ᴛᴏ ᴘʀᴏᴛᴇᴄᴛ ʏᴏᴜʀ ɢʀᴏᴜᴘ ꜰʀᴏᴍ ꜱᴄᴀᴍᴍᴇʀꜱ ᴀɴᴅ ꜱᴘᴀᴍᴍᴇʀꜱ.*"
+            "\n*ᴡʀɪᴛᴛᴇɴ ɪɴ ᴩʏᴛʜᴏɴ ᴡɪᴛʜ sǫʟᴀʟᴄʜᴇᴍʏ ᴀɴᴅ ᴍᴏɴɢᴏᴅʙ ᴀs ᴅᴀᴛᴀʙᴀsᴇ.*"
+            "\n\n────────────────────"
+            f"\n*➻ ᴜᴩᴛɪᴍᴇ »* {uptime}"
+            f"\n* ᴜꜱᴇʀꜱ : {len(users)} "
+            f"\n* ᴄʜᴀᴛs : {len(chats)} "
+            "\n────────────────────"
+            "\n➲  ɪ ᴄᴀɴ ʀᴇꜱᴛʀɪᴄᴛ ᴜꜱᴇʀꜱ."
+            "\n➲  ɪ ʜᴀᴠᴇ ᴀɴ ᴀᴅᴠᴀɴᴄᴇᴅ ᴀɴᴛɪ-ꜰʟᴏᴏᴅ ꜱʏꜱᴛᴇᴍ."
+            "\n➲  ɪ ᴄᴀɴ ɢʀᴇᴇᴛ ᴜꜱᴇʀꜱ ᴡɪᴛʜ ᴄᴜꜱᴛᴏᴍɪᴢᴀʙʟᴇ ᴡᴇʟᴄᴏᴍᴇ ᴍᴇꜱꜱᴀɢᴇꜱ ᴀɴᴅ ᴇᴠᴇɴ ꜱᴇᴛ ᴀ ɢʀᴏᴜᴘ'ꜱ ʀᴜʟᴇꜱ."
+            f"\n\n➻ ᴄʟɪᴄᴋ ᴏɴ ᴛʜᴇ ʙᴜᴛᴛᴏɴs ɢɪᴠᴇɴ ʙᴇʟᴏᴡ ғᴏʀ ɢᴇᴛᴛɪɴɢ ʙᴀsɪᴄ ʜᴇʟᴩ ᴀɴᴅ ɪɴғᴏ ᴀʙᴏᴜᴛ {BOT_NAME}.",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(text="🏡", callback_data="queennoxi_back"),
+                        InlineKeyboardButton(text="💳", callback_data="source_"),
+                        InlineKeyboardButton(text="🧑‍💻", url=f"tg://user?id={OWNER_ID}"),
+                        InlineKeyboardButton(text="🖥️", callback_data="Main_help"),
+                    ],
+                    [
+                        InlineKeyboardButton(text="🚩sᴜᴩᴩᴏʀᴛ", callback_data="queennoxi_support"),
+                        InlineKeyboardButton(text="ᴄᴏᴍᴍᴀɴᴅs 💁", callback_data="Main_help"),
+                    ],
+                    [
+                        InlineKeyboardButton(text="👨‍💻ᴅᴇᴠᴇʟᴏᴩᴇʀ", url=f"tg://user?id={OWNER_ID}"),
+                    ],
+                ]
+            ),
+        )
+    elif query.data == "queennoxi_back":
+        await query.message.edit_caption(
+            PM_START_TEXT.format(query.from_user.first_name if query.from_user else "User", BOT_NAME),
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    elif query.data == "queennoxi_support":
+        await query.message.edit_caption(
+            "ʜᴇʏ 👋\nᴄʟɪᴄᴋ sᴜᴩᴩᴏʀᴛ ᴛᴏ ᴊᴏɪɴ sᴜᴩᴩᴏʀᴛ ɢʀᴏᴜᴩ.",
+            reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton("sᴜᴩᴩᴏʀᴛ", url=SUPPORT_CHAT_URL)],
+                [InlineKeyboardButton("ʙᴀᴄᴋ", callback_data="queennoxi_back")]
+            ])
+        )
+    await query.answer()
+
+@pbot.on_callback_query(filters.regex(r"^Main_help"))
+async def Main_help_callback(client, query: CallbackQuery):
+    await query.message.edit_caption(
+        HELP_STRINGS,
+        reply_markup=InlineKeyboardMarkup(paginate_modules(0, HELPABLE, "help"))
+    )
+    await query.answer()
+
+@pbot.on_callback_query(filters.regex(r"^source_"))
+async def Source_about_callback(client, query: CallbackQuery):
+    if query.data == "source_":
+        await query.message.edit_caption(
+            f"*ʜᴇʏ,\n ᴛʜɪs ɪs {BOT_NAME}*\n\n"
+            "*ʜᴇʀᴇ ɪs ᴍʏ sᴏᴜʀᴄᴇ ᴄᴏᴅᴇ :* [ɢɪᴛʜᴜʙ](https://github.com/AlexaInc/queen-noxi)",
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [InlineKeyboardButton(text="sᴏᴜʀᴄᴇ", url="https://github.com/AlexaInc/queen-noxi")],
+                    [
+                        InlineKeyboardButton(text="🏡", callback_data="queennoxi_back"),
+                        InlineKeyboardButton(text="🛡️", callback_data="queennoxi_"),
+                        InlineKeyboardButton(text="💳", callback_data="source_"),
+                        InlineKeyboardButton(text="🖥️", callback_data="Main_help"),
+                    ],
+                    [InlineKeyboardButton(text="◁", callback_data="source_back")]
+                ]
+            ),
+        )
+    elif query.data == "source_back":
+        await query.message.edit_caption(
+            PM_START_TEXT.format(query.from_user.first_name if query.from_user else "User", BOT_NAME),
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    await query.answer()
+
+@pbot.on_callback_query(filters.regex(r"^owner_"))
+async def owner_callback(client, query: CallbackQuery):
+    data = query.data
+    if data == "owner_main":
+        from QueenNoxi import OWNER_IDS
+        owner_buttons = []
+        for oid in OWNER_IDS:
+            try:
+                user = await client.get_users(oid)
+                name = user.first_name
+                # Use username if available for better redirection
+                if user.username:
+                    url = f"https://t.me/{user.username}"
+                else:
+                    # Fallback to tg://user?id= which works in most modern clients if used correctly
+                    url = f"tg://user?id={oid}"
+                owner_buttons.append([InlineKeyboardButton(text=f"👤 {name}", url=url)])
+            except Exception:
+                owner_buttons.append([InlineKeyboardButton(text=f"👤 Owner {oid}", url=f"tg://user?id={oid}")])
+        
+        if not owner_buttons:
+            owner_buttons.append([InlineKeyboardButton(text="👤 Main Owner", url=f"tg://user?id={OWNER_ID}")])
+
+        owner_buttons.append([InlineKeyboardButton(text="◁ Back", callback_data="queennoxi_back")])
+        
+        await query.message.edit_caption(
+            "✨ **Owner Selection Menu**\n\nChoose an owner profile to view:",
+            reply_markup=InlineKeyboardMarkup(owner_buttons),
+        )
+    await query.answer()
+
+
+@pbot.on_callback_query(filters.regex(r"^Music_"))
+async def music_callback(client, query: CallbackQuery):
+    data = query.data
+    NAV = [
+        InlineKeyboardButton("🏡", callback_data="queennoxi_back"),
+        InlineKeyboardButton("🛡️", callback_data="queennoxi_"),
+        InlineKeyboardButton("💳", callback_data="source_"),
+        InlineKeyboardButton("🖥️", callback_data="Main_help"),
+    ]
+    if data == "Music_":
+        await query.message.edit_caption(
+            "ʜᴇʀᴇ ɪꜱ ʜᴇʟᴘ ᴍᴇɴᴜ ꜰᴏʀ ᴍᴜꜱɪᴄ",
+            reply_markup=InlineKeyboardMarkup([
+                NAV,
+                [InlineKeyboardButton("⍟ ᴀᴅᴍɪɴ ⍟", callback_data="Music_admin"),
+                 InlineKeyboardButton("⍟ ᴘʟᴀʏ ⍟", callback_data="Music_play")],
+                [InlineKeyboardButton("⍟ ʙᴏᴛ ⍟", callback_data="Music_bot"),
+                 InlineKeyboardButton("⍟ ᴇxᴛʀᴀ ⍟", callback_data="Music_extra")],
+                [InlineKeyboardButton("• ʙᴀᴄᴋ •", callback_data="Main_help")],
+            ]),
+        )
+    elif data == "Music_admin":
+        await query.message.edit_caption(
+            "*» ᴀᴅᴍɪɴ ᴄᴏᴍᴍᴀɴᴅꜱ «*\n"
+            "/pause – ᴩᴀᴜsᴇ stream\n/resume – ʀᴇsᴜᴍᴇ\n"
+            "/skip – sᴋɪᴩ ᴄᴜʀʀᴇɴᴛ\n/end,/stop – sᴛᴏᴩ & ᴄʟᴇᴀʀ ǫᴜᴇᴜᴇ\n"
+            "/player – ɪɴᴛᴇʀᴀᴄᴛɪᴠᴇ ᴩᴀɴᴇʟ\n/queue – sʜᴏᴡ ǫᴜᴇᴜᴇ",
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton("ʙᴀᴄᴋ", callback_data="Music_"),
+                InlineKeyboardButton("sᴜᴩᴩᴏʀᴛ", url=SUPPORT_CHAT_URL),
+            ]]),
+        )
+    elif data == "Music_play":
+        await query.message.edit_caption(
+            "*» ᴘʟᴀʏ ᴄᴏᴍᴍᴀɴᴅꜱ «*\n"
+            "/play, /vplay, /cplay – ᴩʟᴀʏ ᴀᴜᴅɪᴏ/ᴠɪᴅᴇᴏ\n"
+            "/playforce – ғᴏʀᴄᴇ ᴩʟᴀʏ\n"
+            "/channelplay [id/disable] – ᴄʜᴀɴɴᴇʟ ᴩʟᴀʏ",
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton("• ʙᴀᴄᴋ •", callback_data="Music_"),
+                InlineKeyboardButton("sᴜᴩᴩᴏʀᴛ", url=SUPPORT_CHAT_URL),
+            ]]),
+        )
+    elif data == "Music_bot":
+        await query.message.edit_caption(
+            "*» ʙᴏᴛ ᴄᴏᴍᴍᴀɴᴅꜱ «*\n"
+            "/stats – ɢʟᴏʙᴀʟ sᴛᴀᴛs\n/sudolist – sᴜᴅᴏ ᴜsᴇʀs\n"
+            "/lyrics [ɴᴀᴍᴇ] – ꜰᴇᴛᴄʜ ʟʏʀɪᴄs\n/song [ɴᴀᴍᴇ/ᴜʀʟ] – ᴅᴏᴡᴀɴʟᴏᴀᴅ",
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton("ʙᴀᴄᴋ", callback_data="Music_"),
+                InlineKeyboardButton("sᴜᴩᴩᴏʀᴛ", callback_data="queennoxi_support"),
+            ]]),
+        )
+    elif data == "Music_extra":
+        await query.message.edit_caption(
+            "*» ᴇxᴛʀᴀ ᴄᴏᴍᴍᴀɴᴅꜱ «*\n"
+            "/mstart – sᴛᴀʀᴛ ᴍᴜsɪᴄ ʙᴏᴛ\n/mhelp – ᴍᴜsɪᴄ ʜᴇʟᴩ\n",
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton("• sᴜᴩᴩᴏʀᴛ •", url=SUPPORT_CHAT_URL)
+            ]])
+        )
+    await query.answer()
+
+async def main():
+    import QueenNoxi
+    from aiohttp import ClientSession
+    QueenNoxi.aiohttpsession = ClientSession()
+    
+    # --- Pyrogram Start ---
+    try:
+        await pbot.start()
+        LOGGER.info("[Pyrogram] Client started.")
+        
+        # Export and save session string for persistence
+        try:
+             ss = await pbot.export_session_string()
+             save_session(BOT_ID, ss)
+             LOGGER.info("[Pyrogram] Saved session string for persistence.")
+        except Exception as e:
+             LOGGER.warning(f"Could not export/save session string: {e}")
+
+        await asyncio.sleep(2)
+        try:
+            if hasattr(pbot, 'delete_webhook'):
+                await pbot.delete_webhook(drop_pending_updates=True)
+            elif hasattr(pbot, 'delete_web_hook'):
+                await pbot.delete_web_hook(drop_pending_updates=True)
+            LOGGER.info("[Pyrogram] Webhook cleared and queue flushed.")
+        except FloodWait as e:
+            LOGGER.warning(f"[Pyrogram] FloodWait while clearing webhook: {e.value}s")
+    except FloodWait as e:
+        LOGGER.error(f"[Pyrogram] CRITICAL FloodWait on start: {e.value}s. Sleeping...")
+        await asyncio.sleep(e.value)
+    except Exception as e:
+        LOGGER.error(f"[Pyrogram] Failed to start client: {e}")
+
+    # --- Telethon Start ---
+    try:
+        await telethn.start(bot_token=TOKEN)
+        LOGGER.info("[Telethon] Client started.")
+    except TlFloodWait as e:
+        LOGGER.warning(f"[Telethon] FloodWait on start: {e.seconds}s.")
+    except Exception as e:
+        LOGGER.error(f"[Telethon] Failed to start client: {e}")
+
+    # --- Handoff ---
+    if pbot.is_connected:
+        me = await pbot.get_me()
+        LOGGER.info(f"[INFO] Bot running as @{me.username} | {me.first_name}")
+        
+        if SUPPORT_CHAT and not SUPPORT_CHAT.startswith("http"):
+            try:
+                target = SUPPORT_CHAT if SUPPORT_CHAT.startswith("-100") else f"@{SUPPORT_CHAT}"
+                await pbot.send_photo(
+                    target,
+                    photo=START_IMG,
+                    caption=f"✨ {BOT_NAME} ɪs ᴀʟɪᴠᴇ ʙᴀʙʏ.\n\n"
+                            f"**ᴩʏᴛʜᴏɴ ᴠᴇʀsɪᴏɴ:** `{y()}`\n"
+                            f"**ᴩʏʀᴏɢʀᴀᴍ ᴠᴇʀsɪᴏɴ:** `{pyrover}`\n",
+                    reply_markup=InlineKeyboardMarkup([[
+                        InlineKeyboardButton("➕ Aᴅᴅ ᴍᴇ ᴛᴏ ʏᴏᴜʀ ᴄʜᴀᴛ ➕", url=f"https://t.me/{me.username}?startgroup=true")
+                    ]]),
+                )
+            except Exception as e:
+                LOGGER.warning(f"Could not announce to @{SUPPORT_CHAT}: {e}")
+    else:
+        LOGGER.error("[CRITICAL] Pyrogram client is NOT connected. Features will be disabled.")
+
+    LOGGER.info(f"Successfully loaded {len(ALL_MODULES)} modules.")
+    LOGGER.info("Bot is running. Press Ctrl+C to stop.")
+    
+    await idle()
+    
+    if pbot.is_connected:
+        await pbot.stop()
+    if telethn.is_connected():
+        await telethn.disconnect()
+    await QueenNoxi.aiohttpsession.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())

QueenNoxi/brain/data/brain.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:814980d5c0908529060fe6c7a74f95ab9482d4cd538f3ab050c5f454d832642d
+size 12969712

QueenNoxi/brain/data/dictionary.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc1b3253f324cb5ce968c269252e7cf7d383026fbd50aac1964c850bf3d165c0
+size 8714062

QueenNoxi/brain/data/persona.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa9fc7b188e0263b963b74e31a8e9c751f45282cb87a17e15cfbcbb58830f32b
+size 869

QueenNoxi/brain/data/phonetic_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9d3dbbadbfca3777d5f8e7269c1e691a594bb91473c324e572801321534655e
+size 21295805

QueenNoxi/brain/data/slang.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bc513452216e7f8a6c13324f09734de6d0973d610fc83b8aae52e7351898aa4
+size 1248

QueenNoxi/brain/data/users.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99245b13a40b590c2903a1b9ace0a07e55166ce6179a72fb4e6b6023c161c474
+size 26626

QueenNoxi/brain/database/anon.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7cb05c9ba971cf4cfe53cda4d0bd302d1c1254b4f2890ccd12828d09c850aa9
+size 1456

QueenNoxi/brain/index.js

@@ -0,0 +1,280 @@
+const brain = require('./src/brain');
+const processor = require('./src/processor');
+const UserMemory = require('./src/memory');
+const GroupSession = require('./src/group');
+const nlu = require('./src/nlu');
+const ContextWindow = require('./src/context');
+const Dictionary = require('./src/dictionary');
+const path = require('path');
+
+class SinhalaHumanoid {
+    /**
+     * @param {Object} options
+     * @param {string}  options.style       - Chat style: 'chill' | 'professional' | 'sexy' | 'hot' | 'auto'
+     * @param {string}  options.name        - Bot's name (e.g. 'Kasun')
+     * @param {string}  options.birthday    - Bot's birthday (e.g. '1998-05-15')
+     * @param {string}  options.residence   - Bot's home city (e.g. 'Colombo')
+     * @param {string}  options.job         - Bot's job (e.g. 'Web Developer')
+     * @param {string}  options.gender      - Bot's gender ('Male'|'Female'|'Other')
+     * @param {string}  options.usersDb     - Path to users.json (optional)
+     */
+    constructor(options = {}) {
+        const personaFields = {};
+        if (options.name) personaFields.name = options.name;
+        if (options.birthday) personaFields.birthday = options.birthday;
+        if (options.residence) personaFields.residence = options.residence;
+        if (options.job) personaFields.job = options.job;
+        if (options.gender) personaFields.gender = options.gender;
+        if (options.style) personaFields.style = options.style;
+        if (options.persona) Object.assign(personaFields, options.persona);
+
+        if (Object.keys(personaFields).length > 0) brain.setPersona(personaFields);
+
+        this.autoStyle = (options.style === 'auto');
+
+        // Priority: options.mongoUri -> process.env.CHATDB_URL -> options.usersDb -> default
+        this.mongoUri = options.mongoUri || process.env.CHATDB_URL || null;
+        this.usersDb = options.usersDb || path.join(process.cwd(), 'database');
+
+        const memoryPath = this.mongoUri || this.usersDb;
+        this.userMemory = new UserMemory(memoryPath);
+
+        const dictPath = options.dictionaryDb || path.join(__dirname, 'data', 'dictionary.json');
+        this.dictionary = new Dictionary(dictPath);
+
+        this.groups = {};
+        this.contexts = {};
+    }
+
+
+    async init() {
+        await this.userMemory.init();
+        return this;
+    }
+
+    _getContext(userId) {
+        if (!this.contexts[userId]) this.contexts[userId] = new ContextWindow();
+        return this.contexts[userId];
+    }
+
+    _buildResponse(message, userId, ctx) {
+        const user = this.userMemory.getUser(userId);
+        const analysis = nlu.analyze(message);
+        ctx.addUserTurn(message, analysis);
+
+        const style = this.autoStyle
+            ? analysis.detectedStyle
+            : ((brain.persona && brain.persona.style) || 'chill');
+
+        const prevStyle = brain.persona.style;
+        if (this.autoStyle) brain.setPersona({ style });
+
+        const extracted = this.userMemory.extractFromMessage(userId, message);
+        if (extracted.name) {
+            const resp = `Suba na ${user.name}! Oyatama ingathin ganna.`;
+            ctx.addBotTurn(resp);
+            return resp;
+        }
+
+        const memQ = this.userMemory.memoryQuery(userId, message);
+        if (memQ) { ctx.addBotTurn(memQ); return memQ; }
+
+        const dictWord = this.dictionary.isDictionaryQuery(message);
+        if (dictWord) {
+            const entry = this.dictionary.lookup(dictWord);
+            if (entry) {
+                const resp = this.dictionary.formatResponse(dictWord, entry);
+                if (resp) { ctx.addBotTurn(resp); return resp; }
+            } else {
+                const notFound = {
+                    chill: `Aiyo sry machan, "${dictWord}" kiyana eka gana mama danne na. Aluth vacanayak da?`,
+                    professional: `Sathutu wenawa kiyanna, habai "${dictWord}" kiyana vacanaya mage dictionary eke na.`,
+                    sexy: `hmmm "${dictWord}"... eka amuthu vacanayak ne? mama danne na eka gana...`,
+                    hot: `"${dictWord}"? eka gana passe kiyannam. dan kiyanna ba.`
+                };
+                const resp = notFound[style] || notFound['chill'];
+                ctx.addBotTurn(resp);
+                return resp;
+            }
+        }
+
+        if (analysis.isGreeting && user.name) {
+            const timeSinceSeen = user.lastSeen ? Date.now() - user.lastSeen : Infinity;
+            if (timeSinceSeen > 5 * 60 * 1000) {
+                const greet = this.userMemory.greet(userId);
+                if (greet) { ctx.addBotTurn(greet); return greet; }
+            }
+        }
+
+        if (analysis.isFarewell) {
+            const byes = {
+                chill: ['ok yanawa machan, hodatama yanawa', 'bye bye, posuwa enna', 'hodatama yanawa, bye!'],
+                professional: ['Bye! Hoda dine ekak waewa.'],
+                sexy: ['aww bye baby, miss karannawa', 'bye, jld ohh laa'],
+                hot: ['ok bye, jld enna ha', 'missing already']
+            };
+            const pool = byes[style] || byes['chill'];
+            const resp = pool[Math.floor(Math.random() * pool.length)];
+            ctx.addBotTurn(resp);
+            return resp;
+        }
+
+        const tonePrefix = nlu.toneReaction(analysis.tone);
+        const parts = [];
+
+        if (analysis.isLong) {
+            for (const topic of analysis.topics.slice(0, 2)) {
+                const topicResp = nlu.getTopicResponse(topic, style);
+                if (topicResp) parts.push(topicResp);
+            }
+            if (!parts.length) {
+                for (const sentence of analysis.sentences.slice(0, 2)) {
+                    const r = brain.respond(sentence, { user });
+                    if (r) parts.push(brain.fillTemplate(r, { user }));
+                }
+            }
+        }
+
+        if (!parts.length) {
+            for (const sentence of analysis.sentences) {
+                // 1. Brain match (most specific knowledge)
+                const r = brain.respond(sentence, { user });
+                if (r) {
+                    parts.push(brain.fillTemplate(r, { user }));
+                    break;
+                }
+
+                // 2. Fallback to general topics
+                const topicHit = analysis.topics.find(t => nlu.getTopicResponse(t, style));
+                if (topicHit) {
+                    parts.push(nlu.getTopicResponse(topicHit, style));
+                    break;
+                }
+            }
+        }
+
+        if (ctx.isAnsweringBotQuestion() && !analysis.isQuestion && parts.length) {
+            const acks = ['ahh ok ok', 'oo arageina', 'ah supa', 'ok ok gotcha'];
+            parts.unshift(acks[Math.floor(Math.random() * acks.length)]);
+        }
+
+        let finalParts = parts.filter(Boolean);
+        if (tonePrefix && finalParts.length) {
+            finalParts = [tonePrefix, ...finalParts];
+        }
+
+        if (!finalParts.length) {
+            finalParts = [brain.getFallback()];
+        }
+
+        if (Math.random() < 0.4 && !analysis.isQuestion) {
+            const followUps = {
+                chill: ['ekath?', 'oya kohomada?', 'moko kiyanne?', 'oya thiyenawada?'],
+                professional: ['Oba kohomada?', 'Meken help one da?'],
+                sexy: ['oya mokada karanne tawa?', 'oya miss una neda?'],
+                hot: ['oya kiyanne?', 'enna enna']
+            };
+            const pool = followUps[style] || followUps['chill'];
+            finalParts.push(pool[Math.floor(Math.random() * pool.length)]);
+        }
+
+        const response = finalParts.join(' ');
+        ctx.addBotTurn(response);
+        if (this.autoStyle) brain.setPersona({ style: prevStyle });
+        return response;
+    }
+
+    getResponse(message, userId = 'anon') {
+        this.userMemory.addHistory(userId, message, 'user');
+        const ctx = this._getContext(userId);
+        const response = this._buildResponse(message, userId, ctx);
+        this.userMemory.addHistory(userId, response, 'bot');
+        return response;
+    }
+
+    async getGroupResponse(message, userId, groupId = 'default') {
+        if (!this.groups[groupId]) {
+            this.groups[groupId] = new GroupSession({
+                groupId,
+                memory: this.userMemory,
+                mongoUri: this.mongoUri,
+                usersDb: this.usersDb
+            });
+            await this.groups[groupId].init();
+        }
+
+        const group = this.groups[groupId];
+        await group.addMessage(userId, message, userId);
+
+        const memQuery = this.userMemory.memoryQuery(userId, message);
+        if (memQuery) {
+            await group.addMessage('bot', memQuery, 'bot');
+            return memQuery;
+        }
+
+        this.userMemory.extractFromMessage(userId, message);
+
+        const botName = (brain.persona && brain.persona.name) || 'Kasun';
+        const analysis = nlu.analyze(message);
+        const addressed = message.toLowerCase().includes(botName.toLowerCase())
+            || message.toLowerCase().includes('bot')
+            || analysis.isGreeting;
+        const randomReply = Math.random() < 0.3;
+
+        if (!addressed && !randomReply) return null;
+
+        const ctx = this._getContext(`${groupId}:${userId}`);
+        const user = this.userMemory.getUser(userId);
+        const response = this._buildResponse(message, userId, ctx);
+
+        await group.addMessage('bot', response, 'bot');
+        return response;
+    }
+
+    /**
+     * Permanent Learning: Add a new pattern to the brain and save to disk.
+     */
+    async learn(input, response, style = 'chill') {
+        const prevStyle = (brain.persona && brain.persona.style) || 'chill';
+        brain.setPersona({ style });
+        brain.learn(input, response, true);
+        brain.setPersona({ style: prevStyle });
+        return true;
+    }
+
+    trainFromGroup(groupId) {
+        const group = this.groups[groupId];
+        if (group) group.autoTrainFromGroup(brain);
+    }
+
+    trainData(data, style) {
+        const Trainer = require('./src/trainer');
+        return Trainer.trainData(data, style);
+    }
+
+    autoTrain(history) {
+        for (let i = 0; i < history.length - 1; i++) {
+            const curr = history[i], next = history[i + 1];
+            if (curr.sender !== next.sender) brain.learn(curr.text, next.text);
+        }
+    }
+
+    setStyle(style) { brain.setPersona({ style }); }
+    setPersona(details) { brain.setPersona(details); }
+    getUser(userId) { return this.userMemory.getUser(userId); }
+    setUserData(u, f, v) { this.userMemory.setUserData(u, f, v); }
+    setUserFact(u, k, v) { this.userMemory.setFact(u, k, v); }
+    getUserFact(u, k) { return this.userMemory.getFact(u, k); }
+    resetContext(userId) { if (this.contexts[userId]) this.contexts[userId].reset(); }
+    analyze(message) { return nlu.analyze(message); }
+    detectLanguage(text) {
+        return /[\u0D80-\u0DFF]/.test(text) ? 'sinhala' : 'singlish';
+    }
+}
+
+const createBot = (options) => new SinhalaHumanoid(options);
+
+module.exports = {
+    SinhalaHumanoid,
+    createBot
+};

QueenNoxi/brain/query.js

@@ -0,0 +1,62 @@
+const { createBot } = require('./index.js');
+const path = require('path');
+const fs = require('fs');
+
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || 'query';
+
+    try {
+        const databasePath = path.join(__dirname, 'database');
+        if (!fs.existsSync(databasePath)) {
+            fs.mkdirSync(databasePath, { recursive: true });
+        }
+
+        const bot = createBot({
+            name: 'Queen Noxi',
+            style: 'auto',
+            birthday: '2004-01-21',
+            gender: 'Female',
+            residence: 'Sri Lanka',
+            job: 'Student',
+            mongoUri: process.env.CHATDB_URL || null,
+            usersDb: databasePath,
+            dictionaryDb: path.join(__dirname, 'data', 'dictionary.json')
+        });
+
+        await bot.init();
+
+        if (command === 'learn') {
+            const input = args[1];
+            const response = args[2];
+            if (!input || !response) {
+                process.stderr.write('Usage: learn <input> <response>');
+                process.exit(1);
+            }
+            await bot.learn(input, response);
+            process.stdout.write('LEARNED');
+        } else {
+            // query command
+            const text = args[1];
+            const userId = args[2] || 'anon';
+            const groupId = args[3] || null;
+
+            if (!text) {
+                process.exit(1);
+            }
+
+            let response;
+            if (groupId) {
+                response = await bot.getGroupResponse(text, userId, groupId);
+            } else {
+                response = bot.getResponse(text, userId);
+            }
+            process.stdout.write(response || '');
+        }
+    } catch (err) {
+        process.stderr.write(err.message || String(err));
+        process.exit(1);
+    }
+}
+
+main();

QueenNoxi/brain/src/brain.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+const processor = require('./processor');
+
+class Brain {
+    constructor() {
+        this.memory = {};
+        this.persona = {};
+        this.loadData();
+    }
+
+    loadData() {
+        try {
+            const brainPath = path.join(__dirname, '..', 'data', 'brain.json');
+            if (fs.existsSync(brainPath)) this.memory = JSON.parse(fs.readFileSync(brainPath, 'utf8'));
+
+            const personaPath = path.join(__dirname, '..', 'data', 'persona.json');
+            if (fs.existsSync(personaPath)) this.persona = JSON.parse(fs.readFileSync(personaPath, 'utf8'));
+        } catch (e) { console.error('Error loading brain data:', e); }
+    }
+
+    saveData() {
+        try {
+            const brainPath = path.join(__dirname, '..', 'data', 'brain.json');
+            fs.writeFileSync(brainPath, JSON.stringify(this.memory, null, 2));
+        } catch (e) { console.error('Error saving brain data:', e); }
+    }
+
+    setPersona(data) {
+        this.persona = { ...this.persona, ...data };
+    }
+
+    /**
+     * Core respond logic. Accepts optional context (userId, userMemory, groupSession)
+     */
+    respond(inputText, context = {}) {
+        const processedInput = processor.process(inputText);
+        if (!processedInput) return this.getFallback();
+
+        // 1. Direct match
+        if (this.memory[processedInput]) {
+            return this.fillTemplate(this.pickResponse(this.memory[processedInput]), context);
+        }
+
+        // 2. Persona questions (Identity should take precedence over fuzzy chat)
+        const personaResp = this.checkPersonaQuestions(processedInput, inputText);
+        if (personaResp) return this.fillTemplate(personaResp, context);
+
+        // 3. Fuzzy match
+        let bestMatch = null;
+        let highestScore = 0;
+        for (const [pattern, data] of Object.entries(this.memory)) {
+            const score = processor.calculateSimilarity(processedInput, pattern);
+            if (score > highestScore && score > 0.65) {
+                highestScore = score;
+                bestMatch = data;
+            }
+        }
+        if (bestMatch) {
+            return this.fillTemplate(this.pickResponse(bestMatch), context);
+        }
+
+        return this.getFallback();
+    }
+
+    pickResponse(data) {
+        const style = this.persona.style || 'chill';
+        const pool = data[style] || data['chill'] || data['default'] || data;
+        if (Array.isArray(pool)) return pool[Math.floor(Math.random() * pool.length)];
+        return String(pool);
+    }
+
+    /**
+     * Fill {name}, {job}, {birthday}, {age}, {residence}, {user_name} etc.
+     */
+    fillTemplate(text, context = {}) {
+        if (!text) return this.getFallback();
+        const p = this.persona;
+        const u = context.user || {};
+        const now = new Date();
+        const birthYear = p.birthday ? new Date(p.birthday).getFullYear() : null;
+
+        return text
+            .replace(/\{name\}/g, p.name || 'Kasun')
+            .replace(/\{birthday\}/g, p.birthday || '?')
+            .replace(/\{job\}/g, p.job || 'web dev')
+            .replace(/\{residence\}/g, p.residence || 'Colombo')
+            .replace(/\{age\}/g, birthYear ? (now.getFullYear() - birthYear) : '?')
+            .replace(/\{user_name\}/g, u.name || 'machan')
+            .replace(/\{user_location\}/g, u.location || 'koheda?')
+            .replace(/\{user_job\}/g, u.job || '?');
+    }
+
+    checkPersonaQuestions(processedInput, rawInput = '') {
+        const text = processedInput.toLowerCase();
+        const raw = rawInput.toLowerCase();
+
+        // Helper: check either raw or processed text
+        const has = (...kws) => kws.some(k => text.includes(k) || raw.includes(k));
+
+        // Priority order matters — check most specific first
+        if (has('oyage gana', 'about you', 'introduce yourself', 'tell me about'))
+            return 'mama {name}. {job} kenek. {residence} wala inne.';
+
+        // Name — must have name-specific trigger word
+        if (has('nama', 'name', 'kauda oya', 'oyage kauda', 'oyage nam', 'oyage name'))
+            return 'mage nama {name} machan.';
+
+        // Age / Birthday
+        if (has('bday', 'birthday', 'ipaduna', 'wayasa', 'age'))
+            return 'mama {age} wiye inne. bday eka {birthday}.';
+
+        // Residence — must be explicit about location
+        if (has('koheda inne', 'live in', 'koheda', 'residence', 'wasi'))
+            return 'mama {residence} wala inne machan.';
+
+        // Job — only if there's a clear job-asking keyword, NOT general "karanne"
+        if (has('oyage job', 'what is your job', 'weda karanne mokakda', 'job eka', 'profession', 'oyage weda'))
+            return 'mama {job} kenek machan.';
+
+        return null;
+    }
+
+    getFallback() {
+        const style = this.persona.style || 'chill';
+        const fallbacks = (this.persona.fallbacks && this.persona.fallbacks[style])
+            || (this.persona.fallbacks && this.persona.fallbacks['chill'])
+            || ['moko kiyanne?', 'poddak hitapan', 'kiyanna aney'];
+        return fallbacks[Math.floor(Math.random() * fallbacks.length)];
+    }
+
+    learn(input, response, shouldSave = true) {
+        const processedInput = processor.process(input);
+        if (!processedInput || !response) return;
+
+        const style = this.persona.style || 'chill';
+        if (!this.memory[processedInput]) {
+            this.memory[processedInput] = {};
+        }
+        if (!this.memory[processedInput][style]) {
+            this.memory[processedInput][style] = [];
+        }
+        if (!this.memory[processedInput][style].includes(response)) {
+            this.memory[processedInput][style].push(response);
+        }
+        if (shouldSave) this.saveData();
+    }
+}
+
+module.exports = new Brain();

QueenNoxi/brain/src/context.js

@@ -0,0 +1,93 @@
+/**
+ * context.js — Conversation Context Window
+ *
+ * Tracks:
+ *  - Recent turns (last N messages from user + bot)
+ *  - Active topics (what is being discussed)
+ *  - Active intents
+ *  - Emotional trend
+ */
+
+class ContextWindow {
+    constructor(maxTurns = 10) {
+        this.maxTurns = maxTurns;
+        this.turns = [];           // { role: 'user'|'bot', text, analysis?, ts }
+        this.activeTopics = [];    // most recent topics discussed
+        this.activeIntents = [];   // most recent intents
+        this.tone = 'neutral';
+        this.waitingForAnswer = null; // if bot asked a question, track what it asked
+    }
+
+    /**
+     * Add a user turn (with NLU analysis attached)
+     */
+    addUserTurn(text, analysis) {
+        this.turns.push({ role: 'user', text, analysis, ts: Date.now() });
+        if (this.turns.length > this.maxTurns * 2) this.turns.shift();
+
+        if (analysis) {
+            // Update active topics (prepend newest, keep last 3)
+            this.activeTopics = [...new Set([...analysis.topics, ...this.activeTopics])].slice(0, 3);
+            this.activeIntents = analysis.intents;
+            this.tone = analysis.tone;
+        }
+    }
+
+    /**
+     * Add a bot turn
+     */
+    addBotTurn(text) {
+        this.turns.push({ role: 'bot', text, ts: Date.now() });
+        if (this.turns.length > this.maxTurns * 2) this.turns.shift();
+
+        // Track if bot asked a question (ends in ?)
+        if (text && text.includes('?')) {
+            this.waitingForAnswer = text;
+        } else {
+            this.waitingForAnswer = null;
+        }
+    }
+
+    /**
+     * Get recent user messages (last N)
+     */
+    getRecentUserMessages(n = 3) {
+        return this.turns.filter(t => t.role === 'user').slice(-n).map(t => t.text);
+    }
+
+    /**
+     * Get last bot message
+     */
+    getLastBotMessage() {
+        const botTurns = this.turns.filter(t => t.role === 'bot');
+        return botTurns.length ? botTurns[botTurns.length - 1].text : null;
+    }
+
+    /**
+     * Check if current message is likely a follow-up to an active topic
+     */
+    isFollowUp(analysis) {
+        if (!analysis || !this.activeTopics.length) return false;
+        return analysis.topics.some(t => this.activeTopics.includes(t));
+    }
+
+    /**
+     * Check if the bot recently asked a question and is waiting for an answer
+     */
+    isAnsweringBotQuestion() {
+        return !!this.waitingForAnswer;
+    }
+
+    /**
+     * Wipe context (for fresh conversation)
+     */
+    reset() {
+        this.turns = [];
+        this.activeTopics = [];
+        this.activeIntents = [];
+        this.tone = 'neutral';
+        this.waitingForAnswer = null;
+    }
+}
+
+module.exports = ContextWindow;

QueenNoxi/brain/src/dictionary.js

@@ -0,0 +1,110 @@
+const fs = require('fs');
+const path = require('path');
+const processor = require('./processor');
+
+class Dictionary {
+    constructor(dbPath) {
+        this.dbPath = dbPath || path.join(__dirname, '..', 'data', 'dictionary.json');
+        this.data = {};
+        this.load();
+    }
+
+    load() {
+        try {
+            if (fs.existsSync(this.dbPath)) {
+                this.data = JSON.parse(fs.readFileSync(this.dbPath, 'utf8'));
+                // Create a separate index for normalized keys
+                this.normalizedIndex = {};
+                for (const key of Object.keys(this.data)) {
+                    this.normalizedIndex[processor.process(key)] = key;
+                }
+            }
+        } catch (e) {
+            console.error('Dictionary load error:', e);
+            this.data = {};
+        }
+    }
+
+    /**
+     * Look up a word in the dictionary.
+     * Supports Sinhala script and Singlish (via internal normalization).
+     */
+    lookup(word) {
+        if (!word) return null;
+
+        const lower = word.toLowerCase().trim();
+        const normalized = processor.process(word);
+
+        // 1. Direct match (exact)
+        if (this.data[lower]) return this.data[lower];
+        if (this.data[normalized]) return this.data[normalized];
+
+        // 2. Normalized index match (e.g. කොම්පියුටර් -> kompiutar -> computer)
+        if (this.normalizedIndex[normalized]) {
+            return this.data[this.normalizedIndex[normalized]];
+        }
+
+        // 3. Fuzzy search for similar words
+        let bestMatch = null;
+        let highestScore = 0;
+
+        for (const [key, value] of Object.entries(this.data)) {
+            const score = processor.calculateSimilarity(normalized, processor.process(key));
+            if (score > highestScore && score > 0.8) {
+                highestScore = score;
+                bestMatch = value;
+            }
+        }
+
+        return bestMatch;
+    }
+
+    /**
+     * Check if the message is a "what is X" type question
+     */
+    isDictionaryQuery(text) {
+        const lower = text.toLowerCase();
+        // Common dictionary query patterns
+        const patterns = [
+            /mokakda (.*) kiyanne/i,
+            /what is (.*)/i,
+            /meaning of (.*)/i,
+            /arthaya (.*)/i,
+            /(.*) kiyanne mokakda/i,
+            /(.*) meaning/i
+        ];
+
+        for (const pat of patterns) {
+            const match = lower.match(pat);
+            if (match) {
+                // Clean punctuation from the extracted word
+                return match[1].trim().replace(/[?!,.]$/, '');
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Format a dictionary entry into a human-like response
+     */
+    formatResponse(word, entry) {
+        if (!entry) return null;
+
+        if (typeof entry === 'string') {
+            return `"${word}" kiyanne: ${entry}`;
+        }
+
+        let resp = `"${word}" gana mama hoyala beluva... `;
+
+        if (entry.sin) resp += `Sinhala: ${entry.sin}. `;
+        if (entry.en) resp += `English: ${entry.en}. `;
+        if (entry.def) resp += `Definition: ${entry.def}. `;
+        if (entry.synonyms && entry.synonyms.length) {
+            resp += `Synonyms: ${entry.synonyms.slice(0, 3).join(', ')}.`;
+        }
+
+        return resp;
+    }
+}
+
+module.exports = Dictionary;

QueenNoxi/brain/src/group.js

@@ -0,0 +1,115 @@
+const UserMemory = require('./memory');
+const StorageAdapter = require('./storage');
+const path = require('path');
+
+class GroupSession {
+    constructor(options = {}) {
+        this.groupId = options.groupId || 'default_group';
+        this.memory = options.memory; // global UserMemory instance for user lookup
+        this.members = new Set();
+        this.recentMessages = [];
+        this.maxHistory = options.maxHistory || 50;
+
+        const storagePath = options.mongoUri || (options.usersDb ? path.join(options.usersDb, `${this.groupId}.json`) : path.join(process.cwd(), 'database', `${this.groupId}.json`));
+        this.storage = new StorageAdapter(storagePath, 'groups');
+    }
+
+    async init() {
+        await this.storage.init();
+        const data = await this.storage.loadAll();
+        this.recentMessages = data.history || [];
+        if (data.members) this.members = new Set(data.members);
+    }
+
+    async save() {
+        await this.storage.saveAll({
+            groupId: this.groupId,
+            members: [...this.members],
+            history: this.recentMessages,
+            lastUpdate: Date.now()
+        });
+    }
+
+    /**
+     * Register a member in this group
+     */
+    addMember(userId) {
+        this.members.add(userId);
+    }
+
+    /**
+     * Record a message in group context
+     */
+    async addMessage(userId, text, from = null) {
+        this.addMember(userId);
+        const sender = from || userId;
+        const msg = { from: sender, text, ts: Date.now() };
+        this.recentMessages.push(msg);
+        if (this.recentMessages.length > this.maxHistory) {
+            this.recentMessages.shift();
+        }
+
+        // Also update the global user memory if they are in this group
+        if (this.memory && sender !== 'bot') {
+            await this.memory.addHistory(sender, text, 'user');
+        }
+
+        await this.save();
+        return msg;
+    }
+
+    /**
+     * Get recent group conversation (last N messages)
+     */
+    getContext(n = 10) {
+        return this.recentMessages.slice(-n);
+    }
+
+    /**
+     * Check if a user was recently active in this group
+     */
+    isRecentlyActive(userId, withinMs = 300000) { // 5 min
+        const now = Date.now();
+        for (let i = this.recentMessages.length - 1; i >= 0; i--) {
+            const m = this.recentMessages[i];
+            if (m.userId === userId && now - m.ts < withinMs) return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get all members the bot has seen in this group
+     */
+    getMembers() {
+        return [...this.members];
+    }
+
+    /**
+     * Get the last message from a specific user
+     */
+    getLastMessageFrom(userId) {
+        for (let i = this.recentMessages.length - 1; i >= 0; i--) {
+            if (this.recentMessages[i].userId === userId) {
+                return this.recentMessages[i];
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Auto-train the brain from recent group messages
+     * (pass in a brain instance)
+     */
+    autoTrainFromGroup(brain) {
+        const msgs = this.recentMessages;
+        for (let i = 0; i < msgs.length - 1; i++) {
+            const curr = msgs[i];
+            const next = msgs[i + 1];
+            if (curr.userId !== next.userId) {
+                brain.learn(curr.text, next.text);
+            }
+        }
+    }
+}
+
+module.exports = GroupSession;

QueenNoxi/brain/src/memory.js

@@ -0,0 +1,204 @@
+const StorageAdapter = require('./storage');
+
+class UserMemory {
+    constructor(dbPath) {
+        this.storage = new StorageAdapter(dbPath, 'users');
+        this.users = {};
+    }
+
+    async init() {
+        await this.storage.init();
+        this.users = await this.storage.loadAll();
+    }
+
+    async save() {
+        await this.storage.saveAll(this.users);
+    }
+
+    /**
+     * Get a user's memory object. Creates one if it doesn't exist.
+     * @param {string} userId 
+     */
+    getUser(userId) {
+        if (!this.users[userId]) {
+            this.users[userId] = {
+                id: userId,
+                name: null,
+                age: null,
+                location: null,
+                job: null,
+                gender: null,
+                nickname: null,
+                facts: {},         // Free-form key-value facts
+                history: [],       // Last N messages
+                lastSeen: null,
+                seenCount: 0
+            };
+        } else {
+            // Safety check for legacy or malformed files
+            if (!this.users[userId].facts) this.users[userId].facts = {};
+            if (!this.users[userId].history) this.users[userId].history = [];
+        }
+        return this.users[userId];
+    }
+
+    /**
+     * Set a specific field on a user
+     */
+    async setUserData(userId, field, value) {
+        const user = this.getUser(userId);
+        user[field] = value;
+        await this.save();
+    }
+
+    /**
+     * Set a free-form fact about a user
+     */
+    async setFact(userId, key, value) {
+        const user = this.getUser(userId);
+        user.facts[key] = value;
+        await this.save();
+    }
+
+    /**
+     * Get a fact about a user
+     */
+    getFact(userId, key) {
+        const user = this.getUser(userId);
+        return user.facts[key] || null;
+    }
+
+    /**
+     * Record a message in the user's history (keep last 30)
+     */
+    async addHistory(userId, text, from = 'user') {
+        const user = this.getUser(userId);
+        user.history.push({ text, from, ts: Date.now() });
+        if (user.history.length > 30) user.history.shift();
+        user.lastSeen = Date.now();
+        user.seenCount = (user.seenCount || 0) + 1;
+        await this.save();
+    }
+
+    /**
+     * Auto-extract user info from message text (name, location, job, age)
+     * Returns any fields that were updated
+     */
+    extractFromMessage(userId, text) {
+        const lower = text.toLowerCase().trim();
+        const extracted = {};
+
+        // BLACKLIST: common Singlish words that look like a "match" but are NOT names/locations
+        const blacklistNames = new Set(['mama', 'machan', 'godak', 'poddak', 'hodai', 'supa', 'maru', 'ada',
+            'kalin', 'dan', 'eka', 'api', 'ado', 'ayye', 'aiyo', 'ekath', 'kohomada', 'tani', 'ganna',
+            'karanna', 'kiyanna', 'ne', 'da', 'ba', 'ok', 'lol', 'haha', 'bye', 'hi', 'hai', 'hello',
+            'sorry', 'thanks', 'library', 'school', 'office', 'bus', 'train', 'gedara', 'weda', 'giia',
+            'apahu', 'pass', 'fail', 'suba', 'subha', 'aiya', 'akka', 'nangi', 'malli', 'amma', 'thaththa']);
+
+        // Name: ONLY on explicit "my name is X" or "mage nama X" (not bare "mama X")
+        const nameMatch = lower.match(/(?:my name is|mage nama|namayi)\s+([a-z]{2,20})(?:\s|$|,|\.)/i);
+        if (nameMatch && !blacklistNames.has(nameMatch[1].toLowerCase())) {
+            const name = this._capitalize(nameMatch[1]);
+            this.setUserData(userId, 'name', name); // Note: this is async but we don't await here to keep it non-blocking in NLU
+            extracted.name = name;
+        }
+
+        // Age: "mage wayasa 22", "age 22", "i am 22 years"
+        const ageMatch = lower.match(/(?:mage wayasa|wayasa|age)\s+(\d{1,3})/i)
+            || lower.match(/i(?:'| a)m (\d{1,3})\s*y/i);
+        if (ageMatch) {
+            const age = parseInt(ageMatch[1]);
+            if (age > 5 && age < 100) {
+                this.setUserData(userId, 'age', age); // Background save
+                extracted.age = age;
+            }
+        }
+
+        // Location: explicit "i live in X", "stay in X" — NOT bare "inne"
+        const locMatch = lower.match(/(?:i live in|stay in|wasi)\s+([a-z]{3,20})(?:\s|$|,)/i);
+        if (locMatch && !blacklistNames.has(locMatch[1].toLowerCase())) {
+            const loc = this._capitalize(locMatch[1].trim());
+            this.setUserData(userId, 'location', loc); // Background save
+            extracted.location = loc;
+        }
+
+        // Job: "i work as X", "weda karanne X", "i am a X"
+        const jobMatch = lower.match(/(?:i work as|weda karanne|i'm a|i am a)\s+([a-z\s]{3,30})(?:\s|$|,|\.)/i);
+        if (jobMatch) {
+            const job = this._capitalize(jobMatch[1].trim());
+            this.setUserData(userId, 'job', job); // Background save
+            extracted.job = job;
+        }
+
+        // Favorites: "my favorite X is Y", "mama kemati X walata"
+        // Improved regex with non-greedy match for the 'thing'
+        const favMatch = lower.match(/(?:my favorite|mama kamati|mama kemati)\s+([a-z\s]{2,20}?)\s+(?:is|kata|walata)\s+([a-z\s]{2,20})/i);
+        if (favMatch) {
+            const thing = favMatch[1].trim().replace(/\s+/g, '_');
+            const value = favMatch[2].trim();
+            this.setFact(userId, `favorite_${thing}`, value);
+            extracted[`favorite_${thing}`] = value;
+        }
+
+        // Likes: "I like X", "mama X walata kamati"
+        const likeMatch = lower.match(/(?:i like|mama)\s+([a-z\s]{2,20})\s+(?:kamathi|kemati|like)/i)
+            || lower.match(/(?:i like)\s+([a-z\s]{2,20})/i);
+        if (likeMatch && !blacklistNames.has(likeMatch[1].trim())) {
+            const like = likeMatch[1].trim();
+            this.setFact(userId, `likes_${like.replace(/\s+/g, '_')}`, true);
+            extracted.likes = like;
+        }
+
+        return extracted;
+    }
+
+    _capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+
+    /**
+     * Compose a greeting using remembered data
+     */
+    greet(userId) {
+        const user = this.getUser(userId);
+        if (user.name) {
+            const greetings = [
+                `${user.name} machan, kohomada?`,
+                `Aiyo ${user.name}, ata ne?`,
+                `${user.name}! Oya thiyanawada?`,
+                `Oya ${user.name} ne! Kohomada?`
+            ];
+            return greetings[Math.floor(Math.random() * greetings.length)];
+        }
+        return null;
+    }
+
+    /**
+     * Check if the user is asking the bot about what it knows of them
+     */
+    memoryQuery(userId, text) {
+        const lower = text.toLowerCase();
+        const user = this.getUser(userId);
+        if (!user) return null;
+
+        if (lower.match(/mage nama|my name|oya thiyanawd|do you know me|oyata mata danne|mama gana|about me/)) {
+            const parts = [];
+            if (user.name) parts.push(`Oba ${user.name}.`);
+            if (user.age) parts.push(`Wayasa ${user.age}.`);
+            if (user.location) parts.push(`${user.location} wala inne.`);
+            if (user.job) parts.push(`${user.job} kenek.`);
+
+            // Add facts/favorites
+            const favs = Object.keys(user.facts).filter(k => k.startsWith('favorite_'));
+            if (favs.length) {
+                const f = favs[0];
+                parts.push(`${f.replace('favorite_', '').replace('_', ' ')} eka ${user.facts[f]}.`);
+            }
+
+            if (parts.length) return parts.join(' ');
+        }
+        return null;
+    }
+}
+
+module.exports = UserMemory;

QueenNoxi/brain/src/nlu.js

@@ -0,0 +1,279 @@
+/**
+ * nlu.js — Natural Language Understanding Engine
+ *
+ * Makes the bot understand:
+ *   1. Long paragraphs (segmented into individual thoughts)
+ *   2. Intent detection (question, greeting, complaint, story, tease, etc.)
+ *   3. Keyword/topic extraction (what is the user REALLY talking about?)
+ *   4. Emotional tone detection (happy, sad, angry, excited)
+ *   5. Context window (what was just talked about?)
+ */
+
+// ────────────────────────────────────────────────────────────────────────────
+// KNOWLEDGE MAPS
+// ────────────────────────────────────────────────────────────────────────────
+
+const INTENT_PATTERNS = {
+    greeting: [/^(hi|hello|hai|hey|ata ne|kohomada|ayye|subha udesanak|good morning|gm)\b/i],
+    farewell: [/\b(bye|goodnight|subha rathriyak|gn|yanawa|later|ttyl|cya)\b/i],
+    question: [/\b(mokakda|kohomada|kauda|kawda|monada|koheda|kiia|when|why|how|what|who|where|when|da\?|neda\?|da$)\b/i, /\?/],
+    complaint: [/\b(dukei|duk|problem|issue|kapuna|asathutak|baya|adura|roga|hondatama na|hodatma na|barei)\b/i],
+    happy: [/\b(supa|ela|elatama|maru|hodai|santhosai|love|like|enjoy|ado hehe|haha|lol|:d|😂|😍|❤️|🔥)\b/i],
+    sad: [/\b(duk|sad|cry|neth|balanna bari|tani|ekai|adare na|alone|miss|😢|💔|😞)\b/i],
+    angry: [/\b(eka nan|apahu|nonsense|baena|bae|budukarapu|waeda na|kelawera|okama|angry|mad|😠|🤬)\b/i],
+    excited: [/\b(!{2,}|omg|aiyoo|wait|seriously|ow ow|neda|😱|🤩|elaaaaaa|supaaa)\b/i],
+    love: [/\b(love|adare|miss|baby|bae|heart|❤️|😘|💕|💖|xoxo)\b/i],
+    story: [/^(ada|kalin|ekl|eka dawas|meka une|eeka giia|eka thamath|api giia|api gaththee|api hitiye)\b/i],
+    thanks: [/\b(thanks|thank you|sthuthi|stuthi|awlak na|np|🙏)\b/i],
+    request: [/\b(karanna puluwan|help|support|explain|kiyanna|denna|ganna|hadanna)\b/i],
+    selfIntro: [/\b(my name is|mama|mage nama|i am|i'm|iam)\b/i],
+    teasing: [/\b(hehe|hihi|🤭|😜|😏|;|patta|wela|joke|haha)\b/i]
+};
+
+const TOPIC_KEYWORDS = {
+    relationship: ['love', 'adare', 'gf', 'bf', 'girlfriend', 'boyfriend', 'miss', 'marry', 'nikaya', 'prema', 'date', 'kiss'],
+    food: ['kema', 'rice', 'food', 'eat', 'restaurant', 'kanne', 'bathi', 'curry', 'pizza', 'kottu', 'hoppers', 'string hoppers'],
+    work: ['job', 'weda', 'office', 'project', 'deadline', 'meeting', 'boss', 'salary', 'work', 'weda karanne', 'interview'],
+    school: ['school', 'university', 'exam', 'pariksha', 'class', 'lecture', 'teacher', 'student', 'ol', 'al', 'degree'],
+    games: ['game', 'play', 'pubg', 'fifa', 'cricket', 'sport', 'win', 'lose', 'match'],
+    weather: ['rain', 'vasse', 'hot', 'climate', 'weather', 'udawa', 'ginithapu', 'thawath vasse'],
+    transport: ['bus', 'train', 'uber', 'taxi', 'bike', 'car', 'traffic', 'jam', 'yanna', 'enna'],
+    money: ['money', 'salary', 'loan', 'borrow', 'spend', 'expensive', 'cheap', 'hari ganan', 'pisa', 'rata'],
+    health: ['sick', 'roga', 'hospital', 'doctor', 'medicine', 'adura', 'pain', 'headache', 'fever', 'gedara inne'],
+    tech: ['phone', 'laptop', 'computer', 'internet', 'data', 'app', 'code', 'website', 'software', 'hack'],
+    family: ['amma', 'thaththa', 'mom', 'dad', 'akka', 'malli', 'nangi', 'brother', 'sister', 'family', 'gedara'],
+    social: ['party', 'meet', 'hangout', 'friend', 'machan', 'api', 'mall', 'trip', 'outing', 'picnic'],
+    srilanka: ['sl', 'srilanka', 'colombo', 'kandy', 'galle', 'jaffna', 'ratnapura', 'lanka'],
+    feelings: ['hithenne', 'feel', 'think', 'baya', 'happy', 'sad', 'cry', 'emotion'],
+};
+
+const TOPIC_RESPONSES = {
+    relationship: {
+        chill: ['ada relationship gana dan hodatama katha karanna epa machan hehe', 'adare gana kiyannako, mokada?', 'ow ow, gf/bf gana da?'],
+        sexy: ['ooh relationship gana da? oya kauda lucky one?', 'adare gana oya hithanawa da?'],
+        hot: ['adare gana da? oyata special kenek innawada?', 'ooh oya kiyanne relationship gana da?']
+    },
+    food: {
+        chill: ['ada kema supa da?!', 'mama dan godak kapannawa, kottu gana kiyanne?', 'ae machan, mama godak hungry', 'abaa kema kiyannako!'],
+        professional: ['Hoda keme irunawada?']
+    },
+    work: {
+        chill: ['aiyo weda wada, poddak relax karaganna machan', 'deadline gana stress wena epa', 'weda wenawata kalin api katha kaapuwa na?'],
+        professional: ['Project eka kohomada giya? Help ona nam kiyanna.']
+    },
+    school: {
+        chill: ['exam gana stress wena epa machan, blew ekak gamu', 'hondatama study karaganna, ekath mama help karanna puluwan', 'ow pariksha gana da? kalin kiyanna thibathe'],
+        professional: ['Study karala hodatama exams passweida?']
+    },
+    games: {
+        chill: ['ado PUBG da?! mama oka ban khelannawa', 'game gana kiyannako, api multiplayer kaamu', 'cricket match baluwada? maru giia na?'],
+        hot: ['game karala jadi wunasama prize karannako chat eka']
+    },
+    weather: {
+        chill: ['ada vasse da koheda?', 'aiyo ginithapu, AC eka dala inne', 'ae machan vasse aiye gedara hitapu', 'Colombo wala ginithapu, koheda oya?'],
+    },
+    transport: {
+        chill: ['bus eke traffic jam da? ae ae normal', 'Uber gahanna, bus pain wena epaa machan'],
+    },
+    money: {
+        chill: ['aiyo machan pisa gana duku', 'salary eka waidi wenna one', 'mae ithin savings poddak', 'hari ganan aney life'],
+    },
+    health: {
+        chill: ['aiyo machan! hondatama hoddaganna', 'roga nathnam santhosai', 'hospital giiewda? kohomada?', 'adura na?! gedara hitapan'],
+    },
+    tech: {
+        chill: ['tech gana naththam mama kiyannawa machan', 'code gahala trouble da? kiyanna', 'phone da laptop da?'],
+        professional: ['Tech stack eka mokakda use karanne?']
+    },
+    family: {
+        chill: ['family gana hari supa machan', 'amma thaththa kohomada?', 'gedara gihilla aawada?'],
+    },
+    social: {
+        chill: ['outing gamu! koheda?', 'party ekak?! enna enna', 'machan ahala hitiye api meet weida'],
+        hot: ['outing gamu, just ape dokomath']
+    },
+    srilanka: {
+        chill: ['mama SL eke podi balla', 'SL game elatama', 'koheda inne SL wala?'],
+    },
+    feelings: {
+        chill: ['mokakda hithenne? kiyanna machan', 'awl na ado, mama innawa ne?', 'mama thiyanawa obage kotaswa'],
+        sexy: ['kiyanna aney, mama ahannawa', 'oya feel wenne mama danne na ne?'],
+    }
+};
+
+// ────────────────────────────────────────────────────────────────────────────
+// AUTO-STYLE SIGNAL MAPS
+// ────────────────────────────────────────────────────────────────────────────
+
+// Each style has signal words/patterns. Weighted scoring picks the winner.
+const STYLE_SIGNALS = {
+    professional: {
+        weight: 1,
+        patterns: [
+            /\b(project|meeting|deadline|report|client|sir|madam|please|thank you|regards|schedule|proposal|discuss|email|call|agenda|budget|salary|office|manager|team)\b/i
+        ]
+    },
+    sexy: {
+        weight: 1,
+        patterns: [
+            /\b(baby|babe|honey|cutie|beautiful|gorgeous|hot|sexy|miss you|come over|alone|cuddle|kiss|hug|adore|😍|😘|💋|🥵|😏|😉|flirt|date|special|crush)\b/i
+        ]
+    },
+    hot: {
+        weight: 1,
+        patterns: [
+            /\b(!!|come|enna|langata|tonight|now|asap|jld|fast|quick|urgent|secret|naughty|dark|🔥|😈|🥵|💦|need you|want you|right now)\b/i,
+            /!{2,}/
+        ]
+    },
+    chill: {
+        weight: 0.5,  // default — lower weight so it loses to specific signals
+        patterns: [
+            /\b(machan|ado|ayye|poddak|nikang|hehe|lol|supa|ela|maru|chilling|relax|nothing|nothing much|nikan)\b/i
+        ]
+    }
+};
+
+// ────────────────────────────────────────────────────────────────────────────
+// NLU CLASS
+// ────────────────────────────────────────────────────────────────────────────
+
+class NLU {
+
+    /**
+     * Segment a long paragraph into individual thought-sentences
+     * Splits on: . ! ? newlines, and Sinhala sentence enders
+     */
+    segment(text) {
+        // Split on sentence terminators
+        const raw = text.split(/[.!?\n\r।ෙ]+/).map(s => s.trim()).filter(s => s.length > 1);
+        // Also split on conjunctions that indicate a change of subject
+        const sentences = [];
+        for (const s of raw) {
+            // If sentence has comma + subject change indicator, further split
+            const subParts = s.split(/\s*,\s*(?=(?:mama|oya|api|ekka|eka|dan|kalin|ekath|ado|machan)\b)/i);
+            for (const p of subParts) {
+                if (p.trim().length > 1) sentences.push(p.trim());
+            }
+        }
+        return sentences.length ? sentences : [text.trim()];
+    }
+
+    /**
+     * Detect intents from a sentence
+     * @returns {string[]} list of matched intents
+     */
+    detectIntents(text) {
+        const found = [];
+        for (const [intent, patterns] of Object.entries(INTENT_PATTERNS)) {
+            for (const pat of patterns) {
+                if (pat.test(text)) { found.push(intent); break; }
+            }
+        }
+        return found.length ? found : ['unknown'];
+    }
+
+    /**
+     * Extract topics from text
+     * @returns {string[]} matched topic names
+     */
+    extractTopics(text) {
+        const lower = text.toLowerCase();
+        const found = [];
+        for (const [topic, keywords] of Object.entries(TOPIC_KEYWORDS)) {
+            if (keywords.some(kw => lower.includes(kw))) found.push(topic);
+        }
+        return found;
+    }
+
+    /**
+     * Get a topic-based response
+     */
+    getTopicResponse(topic, style = 'chill') {
+        const bank = TOPIC_RESPONSES[topic];
+        if (!bank) return null;
+        const pool = bank[style] || bank['chill'] || null;
+        if (!pool || !pool.length) return null;
+        return pool[Math.floor(Math.random() * pool.length)];
+    }
+
+    /**
+     * Detect the emotional tone of a message
+     */
+    detectTone(text) {
+        if (INTENT_PATTERNS.happy.some(p => p.test(text))) return 'happy';
+        if (INTENT_PATTERNS.sad.some(p => p.test(text))) return 'sad';
+        if (INTENT_PATTERNS.angry.some(p => p.test(text))) return 'angry';
+        if (INTENT_PATTERNS.excited.some(p => p.test(text))) return 'excited';
+        if (INTENT_PATTERNS.love.some(p => p.test(text))) return 'love';
+        return 'neutral';
+    }
+
+    /**
+     * Generate a tone-aware reaction prefix
+     */
+    toneReaction(tone) {
+        const reactions = {
+            happy: ['supa aney!', 'elatama!', 'maru!', 'hodai!'],
+            sad: ['aiyo duka aney...', 'awl na machan...', 'duk gannaka eppa ne?'],
+            angry: ['ok ok, chill down machan', 'relax ado...', 'aiyo mokada wune?'],
+            excited: ['ado!', 'wait wait!', 'seriously?!'],
+            love: ['aww hehe', 'ooh ooh', '😊'],
+            neutral: []
+        };
+        const pool = reactions[tone] || [];
+        return pool.length ? pool[Math.floor(Math.random() * pool.length)] : '';
+    }
+
+    /**
+     * Auto-detect the best response style based on message content.
+     * Scores each style by how many signals match, returns the top scorer.
+     * @param {string} text
+     * @returns {string} style name
+     */
+    detectAutoStyle(text) {
+        const scores = {};
+        for (const [style, config] of Object.entries(STYLE_SIGNALS)) {
+            let score = 0;
+            for (const pat of config.patterns) {
+                const matches = text.match(pat);
+                if (matches) score += matches.length * config.weight;
+            }
+            scores[style] = score;
+        }
+        // Return style with highest score; default to chill
+        const best = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
+        return (best && best[1] > 0) ? best[0] : 'chill';
+    }
+
+    /**
+     * Full analysis of any message (short or long paragraph)
+     * Returns a structured analysis object
+     */
+    analyze(text) {
+        const sentences = this.segment(text);
+        const intents = new Set();
+        const topics = new Set();
+        const tone = this.detectTone(text);
+
+        for (const s of sentences) {
+            this.detectIntents(s).forEach(i => intents.add(i));
+            this.extractTopics(s).forEach(t => topics.add(t));
+        }
+
+        return {
+            original: text,
+            sentences,
+            intents: [...intents],
+            topics: [...topics],
+            tone,
+            detectedStyle: this.detectAutoStyle(text),
+            isLong: sentences.length > 1,
+            isQuestion: intents.has('question'),
+            isGreeting: intents.has('greeting'),
+            isFarewell: intents.has('farewell')
+        };
+    }
+}
+
+module.exports = new NLU();

QueenNoxi/brain/src/processor.js

@@ -0,0 +1,162 @@
+const fs = require('fs');
+const path = require('path');
+
+class LanguageProcessor {
+    constructor() {
+        this.slang = {};
+        this.phoneticMap = {}; // Custom word mappings (sinhala script -> singlish)
+        this.loadSlang();
+        this.loadPhoneticMap();
+        this.initTransliteration();
+    }
+
+    loadSlang() {
+        try {
+            const slangPath = path.join(__dirname, '..', 'data', 'slang.json');
+            if (fs.existsSync(slangPath)) {
+                this.slang = JSON.parse(fs.readFileSync(slangPath, 'utf8'));
+            }
+        } catch (e) { }
+    }
+
+    loadPhoneticMap() {
+        try {
+            const mapPath = path.join(__dirname, '..', 'data', 'phonetic_map.json');
+            if (fs.existsSync(mapPath)) {
+                this.phoneticMap = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
+            }
+        } catch (e) { }
+    }
+
+    savePhoneticMap() {
+        try {
+            const mapPath = path.join(__dirname, '..', 'data', 'phonetic_map.json');
+            const dir = path.dirname(mapPath);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(mapPath, JSON.stringify(this.phoneticMap, null, 2), 'utf8');
+        } catch (e) {
+            console.error('Error saving phonetic map:', e);
+        }
+    }
+
+    initTransliteration() {
+        this.vowels = {
+            'අ': 'a', 'ආ': 'aa', 'ඇ': 'ae', 'ඈ': 'aee', 'ඉ': 'i', 'ඊ': 'ii',
+            'උ': 'u', 'ඌ': 'uu', 'එ': 'e', 'ඒ': 'ee', 'ඔ': 'o', 'ඕ': 'oo',
+            'ඓ': 'ai', 'ඖ': 'au'
+        };
+        this.consonants = {
+            'ක': 'k', 'ඛ': 'kh', 'ග': 'g', 'ඝ': 'gh', 'ඞ': 'ng', 'ඟ': 'ng',
+            'ච': 'c', 'ඡ': 'ch', 'ජ': 'j', 'ඣ': 'jh', 'ඤ': 'ny', 'ඥ': 'gn',
+            'ට': 't', 'ඨ': 'th', 'ඩ': 'd', 'ඪ': 'dh', 'ණ': 'n', 'ඬ': 'nd',
+            'ත': 't', 'ථ': 'th', 'ද': 'd', 'ධ': 'dh', 'න': 'n', 'ඳ': 'nd',
+            'ප': 'p', 'ඵ': 'ph', 'බ': 'b', 'භ': 'bh', 'ම': 'm', 'ඹ': 'mb',
+            'ය': 'y', 'ර': 'r', 'ල': 'l', 'ව': 'v', 'ශ': 'sh', 'ෂ': 'sh',
+            'ස': 's', 'හ': 'h', 'ළ': 'l', 'ෆ': 'f'
+        };
+        this.pilli = {
+            '්': '', 'ා': 'aa', 'ැ': 'ae', 'ෑ': 'aee', 'ි': 'i', 'ී': 'ii',
+            'ු': 'u', 'ූ': 'uu', 'ෘ': 'ru', 'ෙ': 'e', 'ේ': 'ee', 'ෛ': 'ai',
+            'ො': 'o', 'ෝ': 'oo', 'ෞ': 'au', 'ං': 'n'
+        };
+    }
+
+    sinhalaToSinglish(text) {
+        let result = '';
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+
+            if (this.vowels[char]) {
+                result += this.vowels[char];
+            } else if (this.consonants[char]) {
+                let next = text[i + 1];
+                let singlish = this.consonants[char];
+                if (next && this.pilli[next] !== undefined) {
+                    singlish += this.pilli[next];
+                    i++; // skip pilla
+                } else {
+                    singlish += 'a'; // inherent vowel
+                }
+                result += singlish;
+            } else {
+                result += char;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Normalizes text for matching.
+     * Handles mixed Sinhala/Singlish, slang expansion, and phonetic cleanup.
+     */
+    process(text) {
+        if (!text) return '';
+
+        // 1. Convert Sinhala script to Singlish (using map if available)
+        const words = text.split(/\s+/);
+        const processedWords = words.map(word => {
+            // Handle phonetic map (Sinhala -> Singlish)
+            if (this.phoneticMap[word]) return this.phoneticMap[word];
+
+            // Handle rule-based translit
+            return this.sinhalaToSinglish(word);
+        });
+
+        let processed = processedWords.join(' ').toLowerCase().trim();
+
+        // 2. Expand common slang (Singlish -> Real Concept)
+        const finalWords = processed.split(/\s+/);
+        processed = finalWords.map(word => this.slang[word] || word).join(' ');
+
+        // 3. Simple phonetic normalization
+        processed = this.normalizePhonetics(processed);
+
+        return processed;
+    }
+
+    normalizePhonetics(text) {
+        return text
+            .replace(/sh/g, 's')
+            .replace(/th/g, 't')
+            .replace(/dh/g, 'd')
+            .replace(/aa/g, 'a')
+            .replace(/ee/g, 'i')
+            .replace(/oo/g, 'u')
+            .replace(/y/g, 'i')
+            .replace(/w/g, 'v')
+            .replace(/([a-z])\1+/g, '$1') // remove double letters
+            .replace(/[^a-z0-9\s]/g, ''); // remove non-alphanumeric
+    }
+
+    /**
+     * Calculates similarity between two strings (Levenshtein Distance)
+     */
+    calculateSimilarity(s1, s2) {
+        if (s1 === s2) return 1.0;
+
+        const len1 = s1.length;
+        const len2 = s2.length;
+        if (len1 === 0) return 0.0;
+        if (len2 === 0) return 0.0;
+
+        const matrix = [];
+        for (let i = 0; i <= len1; i++) matrix[i] = [i];
+        for (let j = 0; j <= len2; j++) matrix[0][j] = j;
+
+        for (let i = 1; i <= len1; i++) {
+            for (let j = 1; j <= len2; j++) {
+                const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+                matrix[i][j] = Math.min(
+                    matrix[i - 1][j] + 1,
+                    matrix[i][j - 1] + 1,
+                    matrix[i - 1][j - 1] + cost
+                );
+            }
+        }
+
+        const distance = matrix[len1][len2];
+        return 1.0 - (distance / Math.max(len1, len2));
+    }
+}
+
+module.exports = new LanguageProcessor();

QueenNoxi/brain/src/storage.js

@@ -0,0 +1,135 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * StorageAdapter provides a unified interface for local JSON and MongoDB.
+ * For local 'users' context, it saves individual files per user.
+ */
+class StorageAdapter {
+    /**
+     * @param {string} connectionStr - Local path (file or dir) or MongoDB URI
+     * @param {string} context - 'users' | 'brain' | 'common'
+     */
+    constructor(connectionStr, context = 'common') {
+        this.connectionStr = connectionStr;
+        this.context = context;
+        this.isMongo = connectionStr.startsWith('mongodb');
+        this.client = null;
+        this.db = null;
+    }
+
+    async init() {
+        if (this.isMongo) {
+            try {
+                const { MongoClient } = require('mongodb');
+                this.client = new MongoClient(this.connectionStr);
+                await this.client.connect();
+                this.db = this.client.db();
+                console.log(`📡 Storage: Connected to MongoDB [${this.context}]`);
+            } catch (e) {
+                console.error(`❌ Storage: Failed to connect to MongoDB. Falling back to local storage.`);
+                this.isMongo = false;
+            }
+        } else if (this.context === 'users') {
+            // Local Users should use a directory
+            if (!fs.existsSync(this.connectionStr)) {
+                fs.mkdirSync(this.connectionStr, { recursive: true });
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Load all data for this context
+     */
+    async loadAll() {
+        if (this.isMongo && this.db) {
+            const collection = this.db.collection(this.context);
+            if (this.context === 'users') {
+                const results = await collection.find({}).toArray();
+                const out = {};
+                results.forEach(r => {
+                    const { _id, ...data } = r;
+                    out[_id] = data;
+                });
+                return out;
+            } else {
+                const doc = await collection.findOne({ _id: 'master' });
+                return doc ? doc.data : {};
+            }
+        } else {
+            // Local FS
+            if (this.context === 'users') {
+                const dir = this.connectionStr;
+                if (!fs.existsSync(dir)) return {};
+                const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+                const out = {};
+                files.forEach(f => {
+                    try {
+                        const content = fs.readFileSync(path.join(dir, f), 'utf8');
+                        out[f.replace('.json', '')] = JSON.parse(content);
+                    } catch (e) { }
+                });
+                return out;
+            } else {
+                try {
+                    if (fs.existsSync(this.connectionStr)) {
+                        return JSON.parse(fs.readFileSync(this.connectionStr, 'utf8'));
+                    }
+                } catch (e) { }
+                return {};
+            }
+        }
+    }
+
+    /**
+     * Save all data (Bulk)
+     */
+    async saveAll(data) {
+        if (this.isMongo && this.db) {
+            const collection = this.db.collection(this.context);
+            if (this.context === 'users') {
+                for (const userId in data) {
+                    await collection.updateOne({ _id: userId }, { $set: data[userId] }, { upsert: true });
+                }
+            } else {
+                await collection.updateOne({ _id: 'master' }, { $set: { data, updatedAt: Date.now() } }, { upsert: true });
+            }
+        } else {
+            if (this.context === 'users') {
+                const dir = this.connectionStr;
+                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+                for (const userId in data) {
+                    const filePath = path.join(dir, `${userId}.json`);
+                    fs.writeFileSync(filePath, JSON.stringify(data[userId], null, 2), 'utf8');
+                }
+            } else {
+                const dir = path.dirname(this.connectionStr);
+                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(this.connectionStr, JSON.stringify(data, null, 2), 'utf8');
+            }
+        }
+    }
+
+    /**
+     * Save a single item (highly optimized for users context)
+     */
+    async saveItem(id, itemData) {
+        if (this.isMongo && this.db) {
+            const collection = this.db.collection(this.context);
+            await collection.updateOne({ _id: id }, { $set: itemData }, { upsert: true });
+        } else {
+            if (this.context === 'users') {
+                const dir = this.connectionStr;
+                const filePath = path.join(dir, `${id}.json`);
+                fs.writeFileSync(filePath, JSON.stringify(itemData, null, 2), 'utf8');
+            } else {
+                const all = await this.loadAll();
+                all[id] = itemData;
+                await this.saveAll(all);
+            }
+        }
+    }
+}
+
+module.exports = StorageAdapter;

QueenNoxi/brain/src/trainer.js

@@ -0,0 +1,168 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const Brain = require('./brain');
+
+/**
+ * Universal training tool for Sinhala dataset ingestion.
+ * Supports JSON, TSV, CSV, Parallel Text, and Large-Scale Streaming.
+ */
+class Trainer {
+    /**
+     * Train from an array of objects
+     */
+    static trainData(data, defaultStyle = 'chill') {
+        if (!Array.isArray(data)) return 0;
+        const oldStyle = (Brain.persona && Brain.persona.style) || 'chill';
+        let count = 0;
+        
+        console.log(`🧠 Processing ${data.length} patterns...`);
+        
+        for (const item of data) {
+            const input = item.input || item.q || item.question || item.text || item.Phrase;
+            const response = item.response || item.a || item.answer || item.reply || item.Response;
+            const style = item.style || defaultStyle;
+            
+            if (input && response) {
+                const s = ['chill', 'professional', 'sexy', 'hot'].includes(style) ? style : defaultStyle;
+                Brain.setPersona({ style: s });
+                // Bulk training: disable auto-save
+                Brain.learn(input.toString(), response.toString(), false);
+                count++;
+            }
+            
+            if (count > 0 && count % 10000 === 0) {
+                console.log(`...ingested ${count} patterns`);
+            }
+        }
+        
+        // Final Save for bulk data
+        console.log('💾 Saving brain to disk (this may take a moment)...');
+        Brain.saveData();
+        
+        Brain.setPersona({ style: oldStyle });
+        return count;
+    }
+
+    /**
+     * Train from a raw string
+     */
+    static trainString(content, format = 'json', defaultStyle = 'chill') {
+        const fmt = format.toLowerCase().replace('.', '');
+        if (fmt === 'json') {
+            try { return this.trainData(JSON.parse(content), defaultStyle); }
+            catch (e) { return 0; }
+        } else if (fmt === 'tsv' || fmt === 'csv' || fmt === 'txt') {
+            const lines = content.split(/\r?\n/);
+            let count = 0;
+            const delimiter = (fmt === 'tsv' || fmt === 'txt') ? /\t+/ : ',';
+            const data = [];
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                const columns = line.split(delimiter);
+                if (columns.length >= 2) {
+                    const col1 = columns[0].trim().replace(/^"|"$/g, '');
+                    const col2 = columns[1].trim().replace(/^"|"$/g, '');
+                    if (col1.toLowerCase() === 'question' || col1.toLowerCase() === 'phrase' || col1.toLowerCase() === 'singlish') continue;
+                    data.push({ q: col1, a: col2, style: defaultStyle });
+                }
+            }
+            return this.trainData(data, defaultStyle);
+        }
+        return 0;
+    }
+
+    /**
+     * Streaming Trainer for LARGE files (100MB+)
+     * Supports Tab, Comma, and custom WSD format.
+     */
+    static async trainLarge(filePath, defaultStyle = 'chill') {
+        const absPath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+        if (!fs.existsSync(absPath)) return 0;
+
+        // Detect encoding
+        const buffer = fs.readFileSync(absPath, { length: 500 });
+        let encoding = 'utf8';
+        if (buffer[0] === 0xFF && buffer[1] === 0xFE) encoding = 'utf16le';
+        else if (buffer[0] === 0xFE && buffer[1] === 0xFF) encoding = 'utf16be';
+        else if (buffer.some(b => b === 0)) encoding = 'utf16le';
+
+        const processor = require('./processor');
+        const fileStream = fs.createReadStream(absPath, { encoding });
+
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+
+        console.log(`🚀 Streaming training from ${path.basename(filePath)} (${encoding})...`);
+        let count = 0;
+
+        for await (const line of rl) {
+            if (!line.trim()) continue;
+
+            let sinhala, singlish;
+
+            // Pattern 1: WSD Format
+            const wsdMatch = line.match(/^Word:\s*([^,]+),\s*Sinhala\s*Words:\s*\[(.*)\]/i);
+            if (wsdMatch) {
+                singlish = wsdMatch[1].trim();
+                const variants = wsdMatch[2].split(',').map(v => v.trim().replace(/['"\[\]]/g, ''));
+                variants.forEach(v => {
+                    if (v && /[\u0D80-\u0DFF]/.test(v)) {
+                        processor.phoneticMap[v] = singlish;
+                        count++;
+                    }
+                });
+                continue;
+            }
+
+            // Pattern 2: Swa Bhasha / test1
+            const parts = line.split(/[\t,/]/);
+            if (parts.length >= 2) {
+                const p1 = parts[0].trim().replace(/^"|"$/g, '');
+                const p2 = parts[1].trim().replace(/^"|"$/g, '');
+
+                const isP1S = /[\u0D80-\u0DFF]/.test(p1);
+                const isP2S = /[\u0D80-\u0DFF]/.test(p2);
+
+                if (isP1S && !isP2S) { sinhala = p1; singlish = p2; }
+                else if (!isP1S && isP2S) { sinhala = p2; singlish = p1; }
+                else if (!isP1S && !isP2S) { Brain.learn(p1, p2, false); count++; }
+
+                if (sinhala && singlish) {
+                    processor.phoneticMap[sinhala] = singlish;
+                    count++;
+                }
+            }
+
+            if (count > 0 && count % 50000 === 0) {
+                console.log(`...memorized ${count} phonetic patterns`);
+            }
+        }
+
+        processor.savePhoneticMap();
+        Brain.saveData(); // Save brain after large stream as well
+        return count;
+    }
+
+    /**
+     * Legacy File Trainer
+     */
+    static trainFile(filePath, defaultStyle = 'chill') {
+        const absPath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+        if (!fs.existsSync(absPath)) return 0;
+        const buffer = fs.readFileSync(absPath);
+        let content;
+        if (buffer[0] === 0xFF && buffer[1] === 0xFE) content = buffer.toString('utf16le');
+        else if (buffer[0] === 0xFE && buffer[1] === 0xFF) content = buffer.toString('utf16be');
+        else {
+            const isUtf16 = buffer.slice(0, 500).some(b => b === 0);
+            content = isUtf16 ? buffer.toString('utf16le') : buffer.toString('utf8');
+        }
+        return this.trainString(content, path.extname(absPath).replace('.', ''), defaultStyle);
+    }
+}
+
+module.exports = Trainer;

QueenNoxi/config.py

@@ -0,0 +1,113 @@
+import os
+
+
+def _int_list(env_key: str, default: str = "") -> list:
+    """Parse a space-separated list of integers from an env var, ignoring comments."""
+    raw = os.environ.get(env_key, default).strip()
+    if not raw:
+        return []
+    # Remove comments starting with #
+    raw = raw.split("#")[0].strip()
+    if not raw:
+        return []
+    
+    result = []
+    for x in raw.split():
+        try:
+            result.append(int(x))
+        except ValueError:
+            continue
+    return result
+
+
+def _bool(env_key: str, default: bool = False) -> bool:
+    val = os.environ.get(env_key, str(default)).strip().lower()
+    return val in ("1", "true", "yes")
+
+
+def _str_list(env_key: str, default: str = "") -> list:
+    """Parse a space-separated list of strings from an env var, ignoring comments."""
+    raw = os.environ.get(env_key, default).strip()
+    if not raw:
+        return []
+    # Remove comments starting with #
+    raw = raw.split("#")[0].strip()
+    if not raw:
+        return []
+    return raw.split()
+
+
+class Config:
+    LOGGER = True
+
+    # ── Telegram API credentials ──────────────────────────────────────────
+    API_ID = int(os.environ.get("API_ID", 0)) or None
+    API_HASH = os.environ.get("API_HASH", "")
+    TOKEN = os.environ.get("TOKEN", "")
+
+    # ── Owner / Privileged users ──────────────────────────────────────────
+    # OWNER_IDS: space-separated Telegram user IDs (all will have owner access)
+    # Example:  OWNER_IDS="123456 789012"
+    OWNER_IDS = _int_list("OWNER_IDS")
+
+    # Sudo / dragons (space-separated IDs)
+    DRAGONS = _int_list("DRAGONS")
+    DEV_USERS = _int_list("DEV_USERS", "2145093972")
+    DEMONS = _int_list("DEMONS")
+    TIGERS = _int_list("TIGERS")
+    WOLVES = _int_list("WOLVES")
+
+    # ── Bot identity ──────────────────────────────────────────────────────
+    # Set these explicitly on HuggingFace (fetched from Telegram API if blank)
+    BOT_NAME = os.environ.get("BOT_NAME", "QueenNoxi")
+    BOT_USERNAME = os.environ.get("BOT_USERNAME", "")  # without @
+
+    # ── Chats / channels ──────────────────────────────────────────────────
+    SUPPORT_CHAT = os.environ.get("SUPPORT_CHAT", "QueenNoxiSupport")  # without @
+    EVENT_LOGS = os.environ.get("EVENT_LOGS", "")    # chat ID for log channel
+    BL_CHATS = _int_list("BL_CHATS")                 # blacklisted chat IDs
+
+    # ── Media ─────────────────────────────────────────────────────────────
+    START_IMG = os.environ.get("START_IMG", "")
+
+    # ── Databases ─────────────────────────────────────────────────────────
+    MONGO_DB_URI = os.environ.get("MONGO_DB_URI", "")
+    CHATDB_URL = os.environ.get("CHATDB_URL", "")
+
+    DATABASE_URL = os.environ.get("DATABASE_URL", "")   # PostgreSQL / elephantsql
+
+
+    # ── API keys ──────────────────────────────────────────────────────────
+    CASH_API_KEY = os.environ.get("CASH_API_KEY", "")
+    TIME_API_KEY = os.environ.get("TIME_API_KEY", "")
+    TENOR_API_KEY = os.environ.get("TENOR_API_KEY", "")
+
+
+    # ── Behaviour flags ───────────────────────────────────────────────────
+    ALLOW_CHATS = _bool("ALLOW_CHATS", True)
+    ALLOW_EXCL = _bool("ALLOW_EXCL", False)
+    DEL_CMDS = _bool("DEL_CMDS", False)
+    INFOPIC = _bool("INFOPIC", True)
+    STRICT_GBAN = _bool("STRICT_GBAN", True)
+
+    # ── Module loading ────────────────────────────────────────────────────
+    LOAD = _str_list("LOAD")
+    NO_LOAD = _str_list("NO_LOAD")
+
+    # ── Performance ───────────────────────────────────────────────────────
+    WORKERS = int(os.environ.get("WORKERS", 8))
+    TEMP_DOWNLOAD_DIRECTORY = os.environ.get("TEMP_DOWNLOAD_DIRECTORY", "./")
+
+
+class Production(Config):
+    LOGGER = True
+
+
+class Development(Config):
+    LOGGER = True
+    # Override any value here for local dev without touching env
+    # Example:
+    #   API_ID = 12345
+    #   API_HASH = "abcdef..."
+    #   TOKEN = "bot_token_here"
+    #   OWNER_IDS = [123456789]

QueenNoxi/events.py

@@ -0,0 +1,179 @@
+import inspect
+import re
+from pathlib import Path
+
+from pymongo import MongoClient
+from telethon import events
+
+from QueenNoxi import MONGO_DB_URI, telethn
+
+client = MongoClient()
+client = MongoClient(MONGO_DB_URI)
+db = client["QueenNoxi"]
+gbanned = db.gban
+
+
+def register(**args):
+    """Registers a new message."""
+    pattern = args.get("pattern", None)
+
+    r_pattern = r"^[/!.]"
+
+    if pattern is not None and not pattern.startswith("(?i)"):
+        args["pattern"] = "(?i)" + pattern
+
+    args["pattern"] = pattern.replace("^/", r_pattern, 1)
+
+    def decorator(func):
+        telethn.add_event_handler(func, events.NewMessage(**args))
+        return func
+
+    return decorator
+
+
+def chataction(**args):
+    """Registers chat actions."""
+
+    def decorator(func):
+        telethn.add_event_handler(func, events.ChatAction(**args))
+        return func
+
+    return decorator
+
+
+def userupdate(**args):
+    """Registers user updates."""
+
+    def decorator(func):
+        telethn.add_event_handler(func, events.UserUpdate(**args))
+        return func
+
+    return decorator
+
+
+def inlinequery(**args):
+    """Registers inline query."""
+    pattern = args.get("pattern", None)
+
+    if pattern is not None and not pattern.startswith("(?i)"):
+        args["pattern"] = "(?i)" + pattern
+
+    def decorator(func):
+        telethn.add_event_handler(func, events.InlineQuery(**args))
+        return func
+
+    return decorator
+
+
+def callbackquery(**args):
+    """Registers inline query."""
+
+    def decorator(func):
+        telethn.add_event_handler(func, events.CallbackQuery(**args))
+        return func
+
+    return decorator
+
+def QueenNoxiinline(**args):
+    def decorator(func):
+        telethn.add_event_handler(func, events.CallbackQuery(**args))
+        return func
+
+    return decorator
+def bot(**args):
+    pattern = args.get("pattern")
+    r_pattern = r"^[/]"
+
+    if pattern is not None and not pattern.startswith("(?i)"):
+        args["pattern"] = "(?i)" + pattern
+
+    args["pattern"] = pattern.replace("^/", r_pattern, 1)
+    stack = inspect.stack()
+    previous_stack_frame = stack[1]
+    file_test = Path(previous_stack_frame.filename)
+    file_test = file_test.stem.replace(".py", "")
+    reg = re.compile("(.*)")
+
+    if pattern is not None:
+        try:
+            cmd = re.search(reg, pattern)
+            try:
+                cmd = cmd.group(1).replace("$", "").replace("\\", "").replace("^", "")
+            except BaseException:
+                pass
+
+            try:
+                FUN_LIST[file_test].append(cmd)
+            except BaseException:
+                FUN_LIST.update({file_test: [cmd]})
+        except BaseException:
+            pass
+
+    def decorator(func):
+        async def wrapper(check):
+            if check.edit_date:
+                return
+            if check.fwd_from:
+                return
+            if check.is_group or check.is_private:
+                pass
+            else:
+                print("i don't work in channels")
+                return
+            if check.is_group:
+                if check.chat.megagroup:
+                    pass
+                else:
+                    print("i don't work in small chats")
+                    return
+
+            users = gbanned.find({})
+            for c in users:
+                if check.sender_id == c["user"]:
+                    return
+            try:
+                await func(check)
+                try:
+                    LOAD_PLUG[file_test].append(func)
+                except Exception:
+                    LOAD_PLUG.update({file_test: [func]})
+            except BaseException:
+                return
+            else:
+                pass
+
+        telethn.add_event_handler(wrapper, events.NewMessage(**args))
+        return wrapper
+
+    return decorator
+
+
+def queennoxi(**args):
+    pattern = args.get("pattern", None)
+    args.get("disable_edited", False)
+    ignore_unsafe = args.get("ignore_unsafe", False)
+    unsafe_pattern = r"^[^/!#@\$A-Za-z]"
+    args.get("group_only", False)
+    args.get("disable_errors", False)
+    args.get("insecure", False)
+    if pattern is not None and not pattern.startswith("(?i)"):
+        args["pattern"] = "(?i)" + pattern
+
+    if "disable_edited" in args:
+        del args["disable_edited"]
+
+    if "ignore_unsafe" in args:
+        del args["ignore_unsafe"]
+
+    if "group_only" in args:
+        del args["group_only"]
+
+    if "disable_errors" in args:
+        del args["disable_errors"]
+
+    if "insecure" in args:
+        del args["insecure"]
+
+    if pattern:
+        if not ignore_unsafe:
+            args["pattern"] = args["pattern"].replace("^.", unsafe_pattern, 1)

QueenNoxi/modules/__init__.py

@@ -0,0 +1,54 @@
+from QueenNoxi import LOAD, LOGGER, NO_LOAD
+
+
+def __list_all_modules():
+    import glob
+    from os.path import basename, dirname, isfile
+
+    # This generates a list of modules in this folder for the * in __main__ to work.
+    mod_paths = glob.glob(dirname(__file__) + "/*.py")
+    to_load = []
+    for f in mod_paths:
+        if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py"):
+            mod_name = basename(f)[:-3]
+            try:
+                with open(f, "r", encoding="utf-8") as file:
+                    content = file.read()
+                    if "import telegram" in content or "from telegram" in content or "dispatcher." in content:
+                         if "from QueenNoxi import pbot" not in content and "@pbot.on_" not in content:
+                             LOGGER.info(f"Skipping legacy module: {mod_name}")
+                             continue
+                to_load.append(mod_name)
+            except Exception as e:
+                LOGGER.error(f"Error reading module {mod_name}: {e}")
+                continue
+
+    if LOAD or NO_LOAD:
+        all_modules = to_load
+        to_load = LOAD
+        if to_load:
+            if not all(
+                any(mod == module_name for module_name in all_modules)
+                for mod in to_load
+            ):
+                LOGGER.error("Invalid loadorder names. Quitting.")
+                quit(1)
+
+            all_modules = sorted(set(all_modules) - set(to_load))
+            to_load = list(all_modules) + to_load
+
+        else:
+            to_load = all_modules
+
+        if NO_LOAD:
+            LOGGER.info("Not loading: {}".format(NO_LOAD))
+            return [item for item in to_load if item not in NO_LOAD]
+
+        return to_load
+
+    return to_load
+
+
+ALL_MODULES = __list_all_modules()
+LOGGER.info("Modules to load: %s", str(ALL_MODULES))
+__all__ = ALL_MODULES + ["ALL_MODULES"]

QueenNoxi/modules/admin.py

@@ -0,0 +1,363 @@
+import html
+import os
+from pyrogram import filters, Client, enums
+from pyrogram.raw import functions, types as raw_types
+from pyrogram.types import (
+    Message,
+    InlineKeyboardMarkup,
+    InlineKeyboardButton,
+    ChatPrivileges
+)
+from pyrogram.errors import RPCError
+
+from QueenNoxi import DRAGONS, pbot, BOT_ID
+from QueenNoxi.modules.disable import DisableAbleCommandHandler
+from QueenNoxi.modules.helper_funcs.admin_rights import user_can_changeinfo
+from QueenNoxi.modules.helper_funcs.chat_status import (
+    bot_admin,
+    can_pin,
+    connection_status,
+    user_admin,
+    can_promote,
+    is_user_admin
+)
+from QueenNoxi.modules.helper_funcs.extraction import (
+    extract_user,
+    extract_user_and_text,
+)
+from QueenNoxi.modules.log_channel import loggable
+
+@pbot.on_message(filters.command("setsticker") & filters.group)
+@bot_admin
+@user_admin
+async def set_sticker(client: Client, message: Message):
+    chat = message.chat
+    user = message.from_user
+    if not await user_can_changeinfo(chat.id, user.id):
+        return await message.reply_text("» ʏᴏᴜ ᴅᴏɴ'ᴛ ʜᴀᴠᴇ ᴩᴇʀᴍɪssɪᴏɴs ᴛᴏ ᴄʜᴀɴɢᴇ ɢʀᴏᴜᴩ ɪɴғᴏ ʙᴀʙʏ !")
+
+    if message.reply_to_message and message.reply_to_message.sticker:
+        stkr = message.reply_to_message.sticker.set_name
+        try:
+            await client.set_chat_sticker_set(chat.id, stkr)
+            await message.reply_text(f"» sᴜᴄᴄᴇssғᴜʟʟʏ sᴇᴛ ɢʀᴏᴜᴩ sᴛɪᴄᴋᴇʀs ɪɴ {chat.title}!")
+        except RPCError as e:
+            await message.reply_text(f"Error: {e.MESSAGE}")
+    else:
+        await message.reply_text("» ʀᴇᴩʟʏ ᴛᴏ ᴀ sᴛɪᴄᴋᴇʀ ᴛᴏ sᴇᴛ ɪᴛ ᴀs ɢʀᴏᴜᴩ sᴛɪᴄᴋᴇʀ ᴩᴀᴄᴋ !")
+
+@pbot.on_message(filters.command("setgpic") & filters.group)
+@bot_admin
+@user_admin
+async def setchatpic(client: Client, message: Message):
+    chat = message.chat
+    user = message.from_user
+    if not await user_can_changeinfo(chat.id, user.id):
+        return await message.reply_text("» ʏᴏᴜ ᴅᴏɴ'ᴛ ʜᴀᴠᴇ ᴩᴇʀᴍɪssɪᴏɴs ᴛᴏ ᴄʜᴀɴɢᴇ ɢʀᴏᴜᴩ ɪɴғᴏ ʙᴀʙʏ !")
+
+    if message.reply_to_message and (message.reply_to_message.photo or message.reply_to_message.document):
+        dlmsg = await message.reply_text("» ᴄʜᴀɴɢɪɴɢ ɢʀᴏᴜᴩ's ᴩʀᴏғɪʟᴇ ᴩɪᴄ...")
+        img = await message.reply_to_message.download("gpic.png")
+        try:
+            await client.set_chat_photo(chat.id, photo=img)
+            await message.reply_text("» sᴜᴄᴄᴇssғᴜʟʟʏ sᴇᴛ ɢʀᴏᴜᴩ ᴩʀᴏғɪʟᴇ ᴩɪᴄ !")
+        except RPCError as e:
+            await message.reply_text(f"Error: {e.MESSAGE}")
+        finally:
+            await dlmsg.delete()
+            if os.path.exists("gpic.png"):
+                os.remove("gpic.png")
+    else:
+        await message.reply_text("» ʀᴇᴩʟʏ ᴛᴏ ᴀ ᴩʜᴏᴛᴏ ᴏʀ ғɪʟᴇ ᴛᴏ sᴇᴛ ɪᴛ ᴀs ɢʀᴏᴜᴩ ᴩʀᴏғɪʟᴇ ᴩɪᴄ !")
+
+@pbot.on_message(filters.command("delgpic") & filters.group)
+@bot_admin
+@user_admin
+async def rmchatpic(client: Client, message: Message):
+    chat = message.chat
+    user = message.from_user
+    if not await user_can_changeinfo(chat.id, user.id):
+        return await message.reply_text("» ʏᴏᴜ ᴅᴏɴ'ᴛ ʜᴀᴠᴇ ᴩᴇʀᴍɪssɪᴏɴs ᴛᴏ ᴄʜᴀɴɢᴇ ɢʀᴏUtᴩ ɪɴғᴏ ʙᴀʙʏ !")
+    try:
+        await client.delete_chat_photo(chat.id)
+        await message.reply_text("» sᴜᴄᴄᴇssғᴜʟʟʏ ᴅᴇʟᴇᴛᴇᴅ ɢʀᴏᴜᴩ's ᴅᴇғᴀᴜʟᴛ ᴩʀᴏғɪʟᴇ ᴩɪᴄ !")
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@pbot.on_message(filters.command("setdesc") & filters.group)
+@bot_admin
+@user_admin
+async def set_desc(client: Client, message: Message):
+    chat = message.chat
+    user = message.from_user
+    if not await user_can_changeinfo(chat.id, user.id):
+        return await message.reply_text("» ʏᴏᴜ ᴅᴏɴ'ᴛ ʜᴀᴠᴇ ᴩᴇʀᴍɪssɪᴏɴs ᴛᴏ ᴄʜᴀɴɢᴇ ɢʀᴏᴜᴩ ɪɴғᴏ ʙᴀʙʏ !")
+
+    desc = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not desc:
+        return await message.reply_text("» ᴡᴛғ, ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ sᴇᴛ ᴀɴ ᴇᴍᴩᴛʏ ᴅᴇsᴄʀɪᴩᴛɪᴏɴ !")
+    try:
+        await client.set_chat_description(chat.id, desc[:255])
+        await message.reply_text(f"» sᴜᴄᴄᴇssғᴜʟʟʏ ᴜᴩᴅᴀᴛᴇᴅ ᴄʜᴀᴛ ᴅᴇsᴄʀɪᴩᴛɪᴏɴ ɪɴ {chat.title}!")
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@pbot.on_message(filters.command("setgtitle") & filters.group)
+@bot_admin
+@user_admin
+async def setchat_title(client: Client, message: Message):
+    chat = message.chat
+    user = message.from_user
+    if not await user_can_changeinfo(chat.id, user.id):
+        return await message.reply_text("» ʏᴏᴜ ᴅᴏɴ'ᴛ ʜᴀᴠᴇ ᴩᴇʀᴍɪssɪᴏɴs ᴛᴏ ᴄʜᴀɴɢᴇ ɢʀᴏᴜᴩ ɪɴғᴏ ʙᴀʙʏ !")
+
+    title = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not title:
+        return await message.reply_text("» ᴇɴᴛᴇʀ sᴏᴍᴇ ᴛᴇxᴛ ᴛᴏ sᴇᴛ ɪᴛ ᴀs ɴᴇᴡ ᴄʜᴀᴛ ᴛɪᴛʟᴇ !")
+    try:
+        await client.set_chat_title(chat.id, title)
+        await message.reply_text(f"» sᴜᴄᴄᴇssғᴜʟʟʏ sᴇᴛ <b>{html.escape(title)}</b> ᴀs ɴᴇᴡ ᴄʜᴀᴛ ᴛɪᴛʟᴇ !")
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@DisableAbleCommandHandler("promote", admin_ok=True)
+@connection_status
+@bot_admin
+@can_promote
+@user_admin
+@loggable
+async def promote(client: Client, message: Message) -> str:
+    chat = message.chat
+    user = message.from_user
+    user_id = await extract_user(message, message.command[1:])
+    if not user_id:
+        await message.reply_text("» ɪ ᴅᴏɴ'ᴛ ᴋɴᴏᴡ ᴡʜᴏ's ᴛʜᴀᴛ ᴜsᴇʀ.")
+        return
+    try:
+        user_member = await chat.get_member(user_id)
+    except:
+        return
+    if user_member.status in (enums.ChatMemberStatus.ADMINISTRATOR, enums.ChatMemberStatus.OWNER):
+        await message.reply_text("» ᴀᴄᴄᴏʀᴅɪɴɢ ᴛᴏ ᴍᴇ ᴛʜᴀᴛ ᴜsᴇʀ ɪs ᴀʟʀᴇᴀᴅʏ ᴀɴ ᴀᴅᴍɪɴ ʜᴇʀᴇ !")
+        return
+    if user_id == BOT_ID:
+        await message.reply_text("» ɪ ᴄᴀɴ'ᴛ ᴩʀᴏᴍᴏᴛᴇ ᴍʏsᴇʟғ.")
+        return
+
+    bot_member = await chat.get_member(BOT_ID)
+    try:
+        await client.promote_chat_member(chat.id, user_id, privileges=bot_member.privileges)
+        await message.reply_text(f"» ᴩʀᴏᴍᴏᴛɪɴɢ ᴀ ᴜsᴇʀ ɪɴ {chat.title}")
+        return f"<b>{html.escape(chat.title)}:</b>\n#ᴩʀᴏᴍᴏᴛᴇᴅ\n<b>ᴩʀᴏᴍᴏᴛᴇʀ :</b> {user.mention}\n<b>ᴜsᴇʀ :</b> {user_member.user.mention}"
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@DisableAbleCommandHandler("demote", admin_ok=True)
+@connection_status
+@bot_admin
+@can_promote
+@user_admin
+@loggable
+async def demote(client: Client, message: Message) -> str:
+    chat = message.chat
+    user = message.from_user
+    user_id = await extract_user(message, message.command[1:])
+    if not user_id:
+        await message.reply_text("» ɪ ᴅᴏɴ'ᴛ ᴋɴᴏᴡ ᴡʜᴏ's ᴛʜᴀᴛ ᴜsᴇʀ.")
+        return
+    try:
+        user_member = await chat.get_member(user_id)
+    except:
+        return
+    if user_member.status == enums.ChatMemberStatus.OWNER:
+        return await message.reply_text("» ᴛʜᴀᴛ ᴜsᴇʀ ɪs ᴏᴡɴᴇʀ !")
+    if user_id == BOT_ID:
+        return await message.reply_text("» ɪ ᴄᴀɴ'ᴛ ᴅᴇᴍᴏᴛᴇ ᴍʏsᴇʟғ.")
+
+    try:
+        # Use raw API to fully strip admin — promote_chat_member with all False
+        # keeps the admin badge in Telegram; raw EditAdmin actually removes it.
+        channel = await client.resolve_peer(chat.id)
+        target  = await client.resolve_peer(user_id)
+        await client.invoke(
+            functions.channels.EditAdmin(
+                channel=channel,
+                user_id=target,
+                admin_rights=raw_types.ChatAdminRights(
+                    change_info=False,
+                    post_messages=False,
+                    edit_messages=False,
+                    delete_messages=False,
+                    ban_users=False,
+                    invite_users=False,
+                    pin_messages=False,
+                    add_admins=False,
+                    manage_call=False,
+                    anonymous=False,
+                    manage_topics=False,
+                    post_stories=False,
+                    edit_stories=False,
+                    delete_stories=False,
+                ),
+                rank=""
+            )
+        )
+        await message.reply_text(f"» sᴜᴄᴄᴇssғᴜʟʟʏ ᴅᴇᴍᴏᴛᴇᴅ ɪɴ {chat.title}")
+        return f"<b>{html.escape(chat.title)}:</b>\n#ᴅᴇᴍᴏᴛᴇᴅ\n<b>ᴅᴇᴍᴏᴛᴇʀ :</b> {user.mention}\n<b>ᴅᴇᴍᴏᴛᴇᴅ :</b> {user_member.user.mention}"
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+
+
+
+@pbot.on_message(filters.command(["admincache", "reload", "refresh"]) & filters.group)
+@user_admin
+async def refresh_admin(client: Client, message: Message):
+    from QueenNoxi.modules.helper_funcs.chat_status import ADMIN_CACHE
+    try:
+        ADMIN_CACHE.pop(message.chat.id)
+    except KeyError:
+        pass
+    await message.reply_text("» sᴜᴄᴄᴇssғᴜʟʟʏ ʀᴇғʀᴇsʜᴇᴅ ᴀᴅᴍɪɴ ᴄᴀᴄʜᴇ !")
+
+@pbot.on_message(filters.command("pin") & filters.group)
+@bot_admin
+@can_pin
+@user_admin
+@loggable
+async def pin(client: Client, message: Message) -> str:
+    args = message.command[1:]
+    chat = message.chat
+    user = message.from_user
+    if not message.reply_to_message:
+        return await message.reply_text("» ʀᴇᴩʟʏ ᴛᴏ ᴀ ᴍᴇssᴀɢᴇ ᴛᴏ ᴩɪɴ ɪᴛ !")
+
+    is_silent = True
+    if len(args) >= 1:
+        is_silent = args[0].lower() not in ["notify", "loud", "violent"]
+    try:
+        await client.pin_chat_message(chat.id, message.reply_to_message.id, disable_notification=is_silent)
+        await message.reply_text("» sᴜᴄᴄᴇssғᴜʟʟʏ ᴩɪɴɴᴇᴅ ᴛʜᴀᴛ ᴍᴇssᴀɢᴇ.")
+        return f"<b>{html.escape(chat.title)}:</b>\nᴩɪɴɴᴇᴅ-ᴀ-ᴍᴇssᴀɢᴇ\n<b>ᴩɪɴɴᴇᴅ ʙʏ :</b> {user.mention}"
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@pbot.on_message(filters.command("unpin") & filters.group)
+@bot_admin
+@can_pin
+@user_admin
+@loggable
+async def unpin(client: Client, message: Message) -> str:
+    chat = message.chat
+    user = message.from_user
+    try:
+        if message.reply_to_message:
+            await client.unpin_chat_message(chat.id, message.reply_to_message.id)
+        else:
+            await client.unpin_chat_message(chat.id)
+        await message.reply_text("» sᴜᴄᴄᴇssғᴜʟʟʏ ᴜɴᴩɪɴɴᴇᴅ.")
+        return f"<b>{html.escape(chat.title)}:</b>\nᴜɴᴩɪɴɴᴇᴅ-ᴀ-ᴍᴇssᴀɢᴇ\n<b>ᴜɴᴩɪɴɴᴇᴅ ʙʏ :</b> {user.mention}"
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@DisableAbleCommandHandler("invitelink", admin_ok=True)
+@connection_status
+@bot_admin
+async def invite(client: Client, message: Message):
+    chat = message.chat
+    if chat.username:
+        return await message.reply_text(f"https://t.me/{chat.username}")
+    try:
+        invitelink = await client.export_chat_invite_link(chat.id)
+        await message.reply_text(invitelink)
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@DisableAbleCommandHandler("title", admin_ok=True)
+@connection_status
+@bot_admin
+@user_admin
+async def set_admin_title(client: Client, message: Message):
+    chat = message.chat
+    user_id, title = await extract_user_and_text(message, message.command[1:])
+    if not user_id:
+        return await message.reply_text("» ɪ ᴅᴏɴ'ᴛ ᴋɴᴏᴡ ᴡʜᴏ's ᴛʜᴀᴛ ᴜsᴇʀ.")
+    try:
+        user_member = await chat.get_member(user_id)
+    except:
+        return
+    if user_member.status == enums.ChatMemberStatus.OWNER:
+        return await message.reply_text("» ᴛʜᴀᴛ ᴜsᴇʀ ɪs ᴏᴡɴᴇʀ !")
+    if user_member.status != enums.ChatMemberStatus.ADMINISTRATOR:
+        return await message.reply_text("» ɪ ᴄᴀɴ ᴏɴʟʏ sᴇᴛ ᴛɪᴛʟᴇ ғᴏʀ ᴀᴅᴍɪɴs !")
+    if not title:
+        return await message.reply_text("» sᴇᴛ ᴀ ᴛɪᴛʟᴇ ʙᴀʙʏ !")
+
+    try:
+        await client.set_administrator_custom_title(chat.id, user_id, title[:16])
+        await message.reply_text(f"» sᴜᴄᴄᴇssғᴜʟʟʏ sᴇᴛ ᴛɪᴛʟᴇ ғᴏʀ <code>{user_member.user.first_name}</code>")
+    except RPCError as e:
+        await message.reply_text(f"Error: {e.MESSAGE}")
+
+@pbot.on_message(filters.command("pinned") & filters.group)
+@bot_admin
+async def pinned_msg(client: Client, message: Message):
+    chat = await client.get_chat(message.chat.id)
+    if chat.pinned_message:
+        pinned_id = chat.pinned_message.id
+        link = f"https://t.me/{chat.username}/{pinned_id}" if chat.username else f"https://t.me/c/{str(chat.id).replace('-100', '')}/{pinned_id}"
+        await message.reply_text(f"ᴩɪɴɴᴇᴅ ᴏɴ {html.escape(chat.title)}.", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("ᴍᴇssᴀɢᴇ", url=link)]]), disable_web_page_preview=True)
+    else:
+        await message.reply_text(f"» ᴛʜᴇʀᴇ's ɴᴏ ᴩɪɴɴᴇᴅ ᴍᴇssᴀɢᴇ ɪɴ <b>{html.escape(chat.title)}!</b>")
+
+@DisableAbleCommandHandler(["admins", "staff"])
+@connection_status
+async def adminlist(client: Client, message: Message):
+    if message.chat.type == enums.ChatType.PRIVATE:
+        return await message.reply_text("» ᴛʜɪs ᴄᴏᴍᴍᴀɴᴅ ᴄᴀɴ ᴏɴʟʏ ʙᴇ ᴜsᴇᴅ ɪɴ ɢʀᴏᴜᴩ's.")
+    msg = await message.reply_text("» ғᴇᴛᴄʜɪɴɢ ᴀᴅᴍɪɴs ʟɪsᴛ...")
+    try:
+        administrators = []
+        async for m in client.get_chat_members(message.chat.id, filter=enums.ChatMembersFilter.ADMINISTRATORS):
+            administrators.append(m)
+        text = "ᴀᴅᴍɪɴs ɪɴ <b>{}</b>:".format(html.escape(message.chat.title))
+        creator = None; admins = []; bots = []
+        for admin in administrators:
+            if admin.status == enums.ChatMemberStatus.OWNER: creator = admin
+            elif admin.user.is_bot: bots.append(admin)
+            else: admins.append(admin)
+        if creator:
+            text += f"\n\n🥀 ᴏᴡɴᴇʀ :\n<code> • </code>{creator.user.mention}"
+            if creator.custom_title: text += f"\n<code> ┗━ {html.escape(creator.custom_title)}</code>"
+        if admins:
+            text += "\n\n💫 ᴀᴅᴍɪɴs :"
+            for a in admins:
+                text += f"\n<code> • </code>{a.user.mention}"
+                if a.custom_title: text += f" | <code>{html.escape(a.custom_title)}</code>"
+        if bots:
+            text += "\n\n🤖 ʙᴏᴛs :"
+            for b in bots: text += f"\n<code> • </code>{b.user.mention}"
+        await msg.edit_text(text)
+    except RPCError as e:
+        await msg.edit_text(f"Error: {e.MESSAGE}")
+
+__mod_name__ = "Admins"
+__help__ = """
+*User Commands*:
+» /admins: List of admins in the chat
+» /pinned: To get the current pinned message.
+
+*Admins only:* 
+» /promote: Promotes the user replied to
+» /demote: Demotes the user replied to
+» /title <title here>: Sets a custom title
+» /admincache: Force refresh the admins list
+» /setgtitle <text>: Set group title
+» /setgpic: Reply to an image to set as group photo
+» /delgpic: Delete group photo
+» /setdesc: Set group description
+» /setsticker: Set group sticker
+» /pin: Silently pins the message
+» /unpin: Unpins the currently pinned message
+» /invitelink: Gets invitelink
+"""

QueenNoxi/modules/aiimage.py

@@ -0,0 +1,61 @@
+"""MIT License
+
+Copyright (c) 2023-24 Noob-QueenNoxi
+
+          GITHUB: NOOB-MUKESH
+          TELEGRAM: @MR_SUKKUN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE."""
+from pyrogram import filters
+from pyrogram.types import  Message
+from pyrogram.types import InputMediaPhoto
+from .. import pbot as  QueenNoxi,BOT_USERNAME
+from MukeshAPI import api
+from pyrogram.enums import ChatAction,ParseMode
+
+@QueenNoxi.on_message(filters.command("imagine"))
+async def imagine_(b, message: Message):
+    if message.reply_to_message:
+        text = message.reply_to_message.text
+    else:
+
+        text =message.text.split(None, 1)[1]
+    queennoxi=await message.reply_text( "`Please wait...,\n\nGenerating prompt .. ...`")
+    try:
+        await b.send_chat_action(message.chat.id, ChatAction.UPLOAD_PHOTO)
+        x=api.ai_image(text)
+        with open("queennoxi.jpg", 'wb') as f:
+            f.write(x)
+        caption = f"""
+    💘sᴜᴄᴇssғᴜʟʟʏ ɢᴇɴᴇʀᴀᴛᴇᴅ : {text}
+    ✨ɢᴇɴᴇʀᴀᴛᴇᴅ ʙʏ : @{BOT_USERNAME}
+    🥀ʀᴇǫᴜᴇsᴛᴇᴅ ʙʏ : {message.from_user.mention}
+    """
+        await queennoxi.delete()
+        await message.reply_photo("queennoxi.jpg",caption=caption,quote=True)
+    except Exception as e:
+        await queennoxi.edit_text(f"error {e}")
+    
+# -----------CREDITS -----------
+# telegram : @legend_coder
+# github : Alexainc
+__mod_name__ = "Aɪ ɪᴍᴀɢᴇ"
+__help__ = """
+ ➻ /imagine : ɢᴇɴᴇʀᴀᴛᴇ Aɪ ɪᴍᴀɢᴇ ғʀᴏᴍ ᴛᴇxᴛ
+ """

QueenNoxi/modules/alive.py

@@ -0,0 +1,70 @@
+import asyncio
+from platform import python_version as pyver
+from pyrogram.enums import ChatType
+from pyrogram import __version__ as pver
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+from telethon import __version__ as tver
+from QueenNoxi.modules.no_sql.chats_db import add_served_chat
+from QueenNoxi.modules.no_sql.users_db import save_id
+from QueenNoxi import SUPPORT_CHAT, SUPPORT_CHAT_URL, pbot, BOT_USERNAME, OWNER_ID, BOT_NAME, START_IMG
+
+PHOTO = [
+    "https://telegra.ph/file/d2a23fbe48129a7957887.jpg",
+    "https://telegra.ph/file/ddf30888de58d77911ee1.jpg",
+    "https://telegra.ph/file/268d66cad42dc92ec65ca.jpg",
+    "https://telegra.ph/file/13a0cbbff8f429e2c59ee.jpg",
+    "https://telegra.ph/file/bdfd86195221e979e6b20.jpg",
+]
+
+QueenNoxi = [
+    [
+        InlineKeyboardButton(text="ᴏᴡɴᴇʀ", user_id=OWNER_ID),
+        InlineKeyboardButton(text="ꜱᴜᴘᴘᴏʀᴛ", url=SUPPORT_CHAT_URL),
+    ],
+    [
+        InlineKeyboardButton(
+            text="➕ᴀᴅᴅ ᴍᴇ ᴇʟsᴇ ʏᴏᴜʀ ɢʀᴏᴜᴘ➕",
+            url=f"https://t.me/{BOT_USERNAME}?startgroup=true",
+        ),
+    ],
+]
+
+@pbot.on_message(filters.command("alive"))
+async def alive(client, m: Message):
+    await m.delete()
+    accha = await m.reply("⚡")
+    await asyncio.sleep(0.2)
+    await accha.edit("ᴅɪɴɢ ᴅᴏɴɢ ꨄ︎ ᴀʟɪᴠɪɴɢ..")
+    await accha.delete()
+    await asyncio.sleep(0.3)
+    
+    umm = await m.reply_sticker(
+        "CAACAgUAAxkDAAJHbmLuy2NEfrfh6lZSohacEGrVjd5wAAIOBAACl42QVKnra4sdzC_uKQQ"
+    )
+    await umm.delete()
+    owner = await client.get_users(OWNER_ID)
+    await m.reply_photo(
+        START_IMG,
+        caption=f"""**ʜᴇʏ, ɪ ᴀᴍ 『[{BOT_NAME}](t.me/{BOT_USERNAME})』**
+   ━━━━━━━━━━━━━━━━━━━
+  » **ᴍʏ ᴏᴡɴᴇʀ :** {owner.mention}
+  
+  » **ᴛᴇʟᴇᴛʜᴏɴ :** `{tver}`
+  
+  » **ᴘʏʀᴏɢʀᴀᴍ :** `{pver}`
+  
+  » **ᴘʏᴛʜᴏɴ :** `{pyver()}`
+   ━━━━━━━━━━━━━━━━━━━""",
+        reply_markup=InlineKeyboardMarkup(QueenNoxi)
+    )
+
+@pbot.on_message(group=1)
+async def save_statss(_, m: Message):
+    try:
+        if m.chat.type == ChatType.PRIVATE:
+            await save_id(m.from_user.id)
+        else:
+            await add_served_chat(m.chat.id)
+    except Exception:
+        pass

QueenNoxi/modules/animation.py

@@ -0,0 +1,344 @@
+import asyncio
+import aiohttp
+import os
+import random
+from pyrogram import filters, Client
+from pyrogram.errors import FloodWait, RPCError
+
+from pyrogram.types import Message
+from QueenNoxi import pbot, LOGGER
+from QueenNoxi.config import Config
+TENOR_API_KEY = Config.TENOR_API_KEY
+DRAGONS = Config.DRAGONS
+OWNER_IDS = Config.OWNER_IDS
+SUDOERS = list(set(DRAGONS + OWNER_IDS))
+
+import zipfile
+import shutil
+from QueenNoxi.modules.disable import DisableAbleCommandHandler
+
+
+from QueenNoxi.modules.helper_funcs.chat_status import user_admin
+
+# ── Setup Caching ────────────────────────────────────────────────────────────
+CACHE_DIR = "QueenNoxi/resources/animation_cache"
+if not os.path.exists(CACHE_DIR):
+    os.makedirs(CACHE_DIR)
+
+async def get_random_gif(category: str):
+    """Fetch a random GIF URL from Tenor or local cache."""
+    tenor_map = {
+        "kill": "kill", "love": "love", "hug": "hug", "slap": "slap",
+        "pat": "pat", "kiss": "kiss", "brain": "think", "moon": "sleep",
+        "hack": "hacker", "police": "police", "bombs": "explosion", "clock": "clock"
+    }
+    
+    action = tenor_map.get(category, category)
+    cat_dir = os.path.join(CACHE_DIR, category)
+    if not os.path.exists(cat_dir):
+        os.makedirs(cat_dir)
+
+    # 1. Try Tenor API
+    if TENOR_API_KEY:
+        try:
+            query = f"{action} anime".replace(" ", "%20")
+            url = f"https://tenor.googleapis.com/v2/search?q={query}&key={TENOR_API_KEY}&limit=5&random=true"
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=5) as resp:
+                    if resp.status == 200:
+                        data = await resp.json()
+                        if data.get('results'):
+                            chosen = random.choice(data['results'])
+                            gif_url = chosen['media_formats']['gif']['url']
+                            
+                            # Async Background Download for Cache (best effort)
+                            asyncio.create_task(cache_gif(category, gif_url))
+                            return gif_url
+        except Exception as e:
+            LOGGER.warning(f"Tenor API error for {category}: {e}")
+
+    # 2. Fallback to Local Cache
+    cached_files = [f for f in os.listdir(cat_dir) if f.endswith(".gif")]
+    if cached_files:
+        local_file = random.choice(cached_files)
+        return os.path.join(cat_dir, local_file)
+            
+    return None
+
+async def cache_gif(category: str, url: str):
+    """Download and save a GIF to the local cache if it doesn't exist."""
+    cat_dir = os.path.join(CACHE_DIR, category)
+    # Limit cache size per category (e.g. 10 files)
+    if len(os.listdir(cat_dir)) >= 15:
+        return
+
+    file_id = url.split("/")[-2] if "/" in url else str(random.randint(1000, 9999))
+    file_path = os.path.join(cat_dir, f"{file_id}.gif")
+    if os.path.exists(file_path):
+        return
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, timeout=10) as resp:
+                if resp.status == 200:
+                    data = await resp.read()
+                    with open(file_path, "wb") as f:
+                        f.write(data)
+    except Exception:
+        pass
+
+
+
+
+
+
+
+
+# ── Animation lists ───────────────────────────────────────────────────────────
+brain_chain = [
+    "🧠", "🧠💥", "💭🧠", "🤯", "🧠🔥", "💡🧠", "🤔🧠",
+    "💥🧠💥", "🧠📤", "📤🗑️", "🗑️💨", "🧠❌", "🗑️", "✅"
+]
+
+clock_ani = [
+    "🕛", "🕧", "🕐", "🕜", "🕑", "🕝", "🕒", "🕞", "🕓", "🕟", "🕔"
+]
+
+police_ani = [
+    "🚓", "🚓💨", "🚔", "🚔💨", "🚨", "🚨🚨", "👮", "👮‍♂️🚓",
+    "🚓🚨👮", "🚨🚨👮‍♂️", "👮‍♂️🔦"
+]
+
+moon_ani = [
+    "🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘", "🌑", "🌒",
+    "🌓", "🌔", "🌕", "🌖", "🌗", "🌘", "🌑", "🌒", "🌓", "🌔",
+    "🌕", "🌕✨", "🌕🌟", "🌕💫", "🌕⭐", "🌕🌟✨", "🌔", "🌓",
+    "🌒", "🌑", "🌙", "🌙✨"
+]
+
+bomb_ettu = [
+    "💣", "💣💣", "💣💣💣", "💣💣💣💣", "💥", "💥💥", "💥💥💥", "🔥💥", "☠️"
+]
+
+hack_you = [
+    "🖥️ Booting...", "🔍 Scanning target...", "🔓 Bypassing firewall...",
+    "💻 Injecting payload...", "📡 Connecting...", "🔑 Cracking password...",
+    "📂 Accessing files...", "📊 Downloading data...", "🗄️ Extracting...",
+    "📤 Uploading backdoor...", "🔐 Locking access...", "🎭 Covering tracks...",
+    "🧹 Cleaning logs...", "⚙️ Finalizing...", "✅ Access granted!",
+    "📁 All data secured.", "🏴‍☠️ Mission complete.", "😎 You've been hacked!"
+]
+
+love_siren = [
+    "❤️", "🧡", "💛", "💚", "💙", "💜", "🖤", "🤍", "🤎", "❤️‍🔥",
+    "💗", "💓", "💞", "💕", "💝", "💖", "💘", "💟", "❣️", "❤️",
+    "💑", "👫", "💏", "💞", "💕❤️", "💖💖", "💗💗", "💓❤️💓",
+    "❤️‍🔥❤️", "💘💘", "💞💞💞", "💖✨", "💝🌹", "🌹❤️", "True Love💞"
+]
+
+kill_you = [
+    "🔫", "🔫💨", "😵", "😵‍💫", "💀", "⚰️🕯️", "🪦", "😱💀",
+    "🔫😵", "💀☠️", "⚰️", "☠️"
+]
+
+slap_ani = ["Slapping...", "SLAP! 👋", "Ouch! 💥", "👋💥", "😵"]
+pat_ani = ["Patting...", "Pat pat... ✨", "Good job! 💖", "✋✨", "😊"]
+hug_ani = ["Hugging...", "HUG! 🤗", "Warm hugs! ❤️", "🫂❤️", "✨"]
+kiss_ani = ["Kissing...", "KISS! 💋", "Muah! 💘", "😘💋", "🔥"]
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+async def send_gif_with_caption(client: Client, chat_id: int, gif_key: str, caption: str):
+    """Attempt to send a GIF with a caption."""
+    url = await get_random_gif(gif_key)
+    if not url:
+        return None
+    
+    try:
+        # Try sending by URL first
+        return await client.send_animation(chat_id, url, caption=caption)
+    except Exception as e:
+        # Fallback: Download and send
+        try:
+            headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+            async with aiohttp.ClientSession(headers=headers) as session:
+                async with session.get(url, timeout=20) as resp:
+                    if resp.status == 200:
+                        data = await resp.read()
+                        temp_name = f"temp_{gif_key}_{random.randint(100,999)}.gif"
+                        with open(temp_name, "wb") as f:
+                            f.write(data)
+                        
+                        sent = await client.send_animation(chat_id, temp_name, caption=caption)
+                        os.remove(temp_name)
+                        return sent
+                    else:
+                        LOGGER.warning(f"GIF Download failed for {gif_key} ({url}): Status {resp.status}")
+        except Exception as e2:
+            LOGGER.warning(f"GIF Fallback failed for {gif_key} ({url}): {e2}")
+    return None
+
+
+async def animate(client: Client, message: Message, gif_key: str, frames: list, action_verb: str, sleep: float = 0.5):
+    """Perform text animation, then send GIF with caption."""
+    if not message.reply_to_message:
+        await message.reply_text(f"❗ Please reply to a user to {gif_key} them!")
+        return
+
+    sender = message.from_user.mention
+    target = message.reply_to_message.from_user.mention
+    caption = f"✨ {sender} {action_verb} {target}! ✨"
+
+    # Start text animation
+    msg = await message.reply_text(frames[0])
+    
+    # Avoid FloodWait: Limit to ~8 edits if the list is long
+    total_frames = len(frames)
+    step = 1
+    if total_frames > 8:
+        step = total_frames // 7
+        if step == 0: step = 1
+
+    for x in range(step, total_frames, step):
+        try:
+            await msg.edit_text(frames[x])
+            await asyncio.sleep(sleep)
+        except FloodWait as e:
+            await asyncio.sleep(e.value)
+        except RPCError:
+            break
+    
+    # Send the GIF with caption
+    gif_msg = await send_gif_with_caption(client, message.chat.id, gif_key, caption)
+    
+    # Only delete the temporary text animation message if GIF succeeded
+    # Otherwise, edit it to keep the result visible
+    if gif_msg:
+        try:
+            await msg.delete()
+        except:
+            pass
+    else:
+        try:
+            await msg.edit_text(caption)
+        except:
+            pass
+
+
+
+
+# ── Commands ──────────────────────────────────────────────────────────────────
+@pbot.on_message(filters.command("dlanimech"))
+async def dlanimech(client: Client, message: Message):
+    """Zip and send animation cache to Sudoers in PM."""
+    if message.from_user.id not in SUDOERS:
+        await message.reply_text("❌ This command is only for Sudoers/Owners!")
+        return
+
+    msg = await message.reply_text("📦 Zipping animation cache...")
+    
+    zip_path = "anim_cache.zip"
+    try:
+        # Create zip
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for root, dirs, files in os.walk(CACHE_DIR):
+                for file in files:
+                    zipf.write(
+                        os.path.join(root, file),
+                        os.path.relpath(os.path.join(root, file), os.path.join(CACHE_DIR, '..'))
+                    )
+        
+        # Send in PM
+        await client.send_document(
+            chat_id=message.from_user.id,
+            document=zip_path,
+            caption="📂 Here is the current Animation Cache!",
+            file_name="animation_cache.zip"
+        )
+        await msg.edit_text("✅ Sent to your PM!")
+    except Exception as e:
+        await msg.edit_text(f"❌ Error: {e}")
+    finally:
+        if os.path.exists(zip_path):
+            os.remove(zip_path)
+
+@pbot.on_message(filters.command("brain") & filters.group)
+@DisableAbleCommandHandler("brain")
+async def brainanimation(client: Client, message: Message):
+    await animate(client, message, "brain", brain_chain, "put brain in dustbin for")
+
+@pbot.on_message(filters.command("clock") & filters.group)
+@DisableAbleCommandHandler("clock")
+async def clockanimation(client: Client, message: Message):
+    await animate(client, message, "clock", clock_ani, "reminded time to")
+
+@pbot.on_message(filters.command("police") & filters.group)
+@DisableAbleCommandHandler("police")
+async def policeanimation(client: Client, message: Message):
+    await animate(client, message, "police", police_ani, "called police for")
+
+@pbot.on_message(filters.command("moon") & filters.group)
+@DisableAbleCommandHandler("moon")
+async def moonanimation(client: Client, message: Message):
+    await animate(client, message, "moon", moon_ani, "wished good night to")
+
+@pbot.on_message(filters.command("bombs") & filters.group)
+@DisableAbleCommandHandler("bombs")
+async def bombs(client: Client, message: Message):
+    await animate(client, message, "bombs", bomb_ettu, "bombed")
+
+@pbot.on_message(filters.command("hack") & filters.group)
+@DisableAbleCommandHandler("hack")
+async def hack(client: Client, message: Message):
+    await animate(client, message, "hack", hack_you, "hacked")
+
+@pbot.on_message(filters.command("love") & filters.group)
+@DisableAbleCommandHandler("love")
+async def love(client: Client, message: Message):
+    await animate(client, message, "love", love_siren, "is expressing love to")
+
+@pbot.on_message(filters.command("kill") & filters.group)
+@DisableAbleCommandHandler("kill")
+async def kill(client: Client, message: Message):
+    await animate(client, message, "kill", kill_you, "killed")
+
+@pbot.on_message(filters.command("slap") & filters.group)
+@DisableAbleCommandHandler("slap")
+async def slap(client: Client, message: Message):
+    await animate(client, message, "slap", slap_ani, "slapped")
+
+@pbot.on_message(filters.command("pat") & filters.group)
+@DisableAbleCommandHandler("pat")
+async def pat(client: Client, message: Message):
+    await animate(client, message, "pat", pat_ani, "patted")
+
+@pbot.on_message(filters.command("hug") & filters.group)
+@DisableAbleCommandHandler("hug")
+async def hug(client: Client, message: Message):
+    await animate(client, message, "hug", hug_ani, "hugged")
+
+@pbot.on_message(filters.command("kiss") & filters.group)
+@DisableAbleCommandHandler("kiss")
+async def kiss(client: Client, message: Message):
+    await animate(client, message, "kiss", kiss_ani, "kissed")
+
+
+
+__mod_name__ = "Animation"
+__help__ = """
+*ғᴀᴋᴇ ᴀɴɪᴍᴀᴛɪᴏɴ ᴄᴏᴍᴍᴀɴᴅs*
+• `/love` — ʟᴏᴠᴇ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/hack` — ʜᴀᴄᴋ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/moon` — ᴍᴏᴏɴ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/kill` — ᴋɪʟʟ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/slap` — sʟᴀᴩ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/pat` — ᴩᴀᴛ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/hug` — ʜᴜɢ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/kiss` — ᴋɪss ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/bombs` — ʙᴏᴍʙ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/police` — ᴩᴏʟɪᴄᴇ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/brain` — ʙʀᴀɪɴ ᴀɴɪᴍᴀᴛɪᴏɴ
+• `/clock` — ᴄʟᴏᴄᴋ ᴀɴɪᴍᴀᴛɪᴏɴ
+"""
+

QueenNoxi/modules/anime.py

@@ -0,0 +1,110 @@
+import json
+import random
+import aiohttp
+from pyrogram import filters, Client, enums
+from pyrogram.types import (
+    Message,
+    InlineKeyboardMarkup,
+    InlineKeyboardButton,
+    CallbackQuery
+)
+
+from QueenNoxi import pbot, OWNER_ID
+from QueenNoxi.modules.disable import DisableAbleCommandHandler
+
+QUOTES_IMG = [
+    "https://i.imgur.com/Iub4RYj.jpg",
+    "https://i.imgur.com/uvNMdIl.jpg",
+    "https://i.imgur.com/YOBOntg.jpg",
+    "https://i.imgur.com/fFpO2ZQ.jpg",
+    "https://i.imgur.com/f0xZceK.jpg",
+    "https://i.imgur.com/RlVcCip.jpg",
+    "https://i.imgur.com/CjpqLRF.jpg",
+    "https://i.imgur.com/8BHZDk6.jpg",
+    "https://i.imgur.com/8bHeMgy.jpg",
+    "https://i.imgur.com/5K3lMvr.jpg",
+    "https://i.imgur.com/NTzw4RN.jpg",
+    "https://i.imgur.com/wJxryAn.jpg",
+    "https://i.imgur.com/9L0DWzC.jpg",
+    "https://i.imgur.com/sBe8TTs.jpg",
+    "https://i.imgur.com/1Au8gdf.jpg",
+    "https://i.imgur.com/28hFQeU.jpg",
+    "https://i.imgur.com/Qvc03JY.jpg",
+    "https://i.imgur.com/gSX6Xlf.jpg",
+    "https://i.imgur.com/iP26Hwa.jpg",
+    "https://i.imgur.com/uSsJoX8.jpg",
+    "https://i.imgur.com/OvX3oHB.jpg",
+    "https://i.imgur.com/JMWuksm.jpg",
+    "https://i.imgur.com/lhM3fib.jpg",
+    "https://i.imgur.com/64IYKkw.jpg",
+    "https://i.imgur.com/nMbyA3J.jpg",
+    "https://i.imgur.com/7KFQhY3.jpg",
+    "https://i.imgur.com/mlKb7zt.jpg",
+    "https://i.imgur.com/JCQGJVw.jpg",
+    "https://i.imgur.com/hSFYDEz.jpg",
+    "https://i.imgur.com/PQRjAgl.jpg",
+    "https://i.imgur.com/ot9624U.jpg",
+    "https://i.imgur.com/iXmqN9y.jpg",
+    "https://i.imgur.com/RhNBeGr.jpg",
+    "https://i.imgur.com/tcMVNa8.jpg",
+    "https://i.imgur.com/LrVg810.jpg",
+    "https://i.imgur.com/TcWfQlz.jpg",
+    "https://i.imgur.com/muAUdvJ.jpg",
+    "https://i.imgur.com/AtC7ZRV.jpg",
+    "https://i.imgur.com/sCObQCQ.jpg",
+    "https://i.imgur.com/AJFDI1r.jpg",
+    "https://i.imgur.com/TCgmRrH.jpg",
+    "https://i.imgur.com/LMdmhJU.jpg",
+    "https://i.imgur.com/eyyax0N.jpg",
+    "https://i.imgur.com/YtYxV66.jpg",
+    "https://i.imgur.com/289f9cebe37f31a943f98.jpg",
+]
+
+async def anime_quote():
+    url = "https://animechan.vercel.app/api/random"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            if response.status == 200:
+                dic = await response.json()
+                return dic["quote"], dic["character"], dic["anime"]
+    return "No quote found.", "Unknown", "Unknown"
+
+@pbot.on_message(filters.command("quote"))
+@DisableAbleCommandHandler("quote")
+async def quotes(client: Client, message: Message):
+    quote, character, anime = await anime_quote()
+    msg = f"<i>❝{quote}❞</i>\n\n<b>{character} from {anime}</b>"
+    keyboard = InlineKeyboardMarkup(
+        [[InlineKeyboardButton(text="Change🔁", callback_data="change_quote")]]
+    )
+    await message.reply_text(
+        msg,
+        reply_markup=keyboard,
+        parse_mode=enums.ParseMode.HTML,
+    )
+
+@pbot.on_callback_query(filters.regex(r"change_quote|quote_change"))
+async def change_quote_btn(client: Client, query: CallbackQuery):
+    quote, character, anime = await anime_quote()
+    msg = f"<i>❝{quote}❞</i>\n\n<b>{character} from {anime}</b>"
+    keyboard = InlineKeyboardMarkup(
+        [[InlineKeyboardButton(text="ᴄʜᴀɴɢᴇ🔁", callback_data="quote_change")]]
+    )
+    try:
+        await query.message.edit_text(msg, reply_markup=keyboard, parse_mode=enums.ParseMode.HTML)
+    except:
+        await query.answer("Error or same content.")
+
+@pbot.on_message(filters.command("animequotes"))
+@DisableAbleCommandHandler("animequotes")
+async def animequotes_cmd(client: Client, message: Message):
+    if message.reply_to_message:
+        await message.reply_to_message.reply_photo(random.choice(QUOTES_IMG))
+    else:
+        await message.reply_photo(random.choice(QUOTES_IMG))
+
+__mod_name__ = "Quotes"
+__help__ = """
+• `/quote`: Get a random anime quote.
+• `/animequotes`: Get a random anime quote image.
+"""

QueenNoxi/modules/animez.py

@@ -0,0 +1,415 @@
+import datetime
+import html
+import textwrap
+import aiohttp
+import bs4
+from jikanpy import AioJikan
+from pyrogram import filters, Client
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+
+from QueenNoxi import pbot
+from QueenNoxi.modules.disable import DisableAbleCommandHandler
+
+info_btn = "More Information"
+close_btn = "Close ❌"
+
+def shorten(description, info="anilist.co"):
+    msg = ""
+    if len(description) > 700:
+        description = description[0:500] + "...."
+        msg += f"\n**Description**: _{description}_[Read More]({info})"
+    else:
+        msg += f"\n**Description**:_{description}_"
+    return msg
+
+def t(milliseconds: int) -> str:
+    seconds, milliseconds = divmod(int(milliseconds), 1000)
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    tmp = (
+        ((str(days) + " Days, ") if days else "")
+        + ((str(hours) + " Hours, ") if hours else "")
+        + ((str(minutes) + " Minutes, ") if minutes else "")
+        + ((str(seconds) + " Seconds, ") if seconds else "")
+        + ((str(milliseconds) + " ms, ") if milliseconds else "")
+    )
+    return tmp[:-2]
+
+airing_query = """
+query ($id: Int,$search: String) { 
+    Media (id: $id, type: ANIME,search: $search) {
+        id
+        episodes
+        title {
+            romaji
+            english
+            native
+        }
+        nextAiringEpisode {
+            airingAt
+            timeUntilAiring
+            episode
+        } 
+    }
+}
+"""
+
+anime_query = """
+query ($id: Int,$search: String) {
+    Media (id: $id, type: ANIME,search: $search) {
+        id
+        title {
+            romaji
+            english
+            native
+        }
+        description (asHtml: false)
+        startDate{
+            year
+        }
+        episodes
+        season
+        type
+        format
+        status
+        duration
+        siteUrl
+        studios{
+            nodes{
+                name
+            }
+        }
+        trailer{
+            id
+            site
+            thumbnail
+        }
+        averageScore
+        genres
+        bannerImage
+    }
+}
+"""
+
+character_query = """
+query ($query: String) {
+    Character (search: $query) {
+        id
+        name {
+            first
+            last
+            full
+        }
+        siteUrl
+        image {
+            large
+        }
+        description
+    }
+}
+"""
+
+manga_query = """
+query ($id: Int,$search: String) { 
+    Media (id: $id, type: MANGA,search: $search) { 
+        id
+        title {
+            romaji
+            english
+            native
+        }
+        description (asHtml: false)
+        startDate{
+            year
+        }
+        type
+        format
+        status
+        siteUrl
+        averageScore
+        genres
+        bannerImage
+    }
+}
+"""
+
+url = "https://graphql.anilist.co"
+
+async def get_response(query, variables):
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, json={"query": query, "variables": variables}) as resp:
+            return await resp.json()
+
+@pbot.on_message(filters.command("airing"))
+@DisableAbleCommandHandler("airing")
+async def airing(client: Client, message: Message):
+    search_str = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not search_str and message.reply_to_message:
+        search_str = message.reply_to_message.text
+    
+    if not search_str:
+        await message.reply_text("Tell Anime Name :) ( /airing <anime name>)")
+        return
+
+    data = await get_response(airing_query, {"search": search_str})
+    if not data or "data" not in data or not data["data"]["Media"]:
+        await message.reply_text("Anime not found")
+        return
+
+    response = data["data"]["Media"]
+    msg = f"**Name**: **{response['title']['romaji']}**(`{response['title']['native']}`)\n**ID**: `{response['id']}`"
+    if response["nextAiringEpisode"]:
+        time_val = response["nextAiringEpisode"]["timeUntilAiring"] * 1000
+        time_str = t(time_val)
+        msg += f"\n**Episode**: `{response['nextAiringEpisode']['episode']}`\n**Airing In**: `{time_str}`"
+    else:
+        msg += f"\n**Episode**:{response['episodes']}\n**Status**: `N/A`"
+    await message.reply_text(msg)
+
+@pbot.on_message(filters.command("anime"))
+@DisableAbleCommandHandler("anime")
+async def anime(client: Client, message: Message):
+    search = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not search and message.reply_to_message:
+        search = message.reply_to_message.text
+
+    if not search:
+        await message.reply_text("Format : /anime < anime name >")
+        return
+
+    data = await get_response(anime_query, {"search": search})
+    if not data or "data" not in data or not data["data"]["Media"]:
+        await message.reply_text("Anime not found")
+        return
+
+    json_data = data["data"]["Media"]
+    msg = f"**{json_data['title']['romaji']}**(`{json_data['title']['native']}`)\n**Type**: {json_data['format']}\n**Status**: {json_data['status']}\n**Episodes**: {json_data.get('episodes', 'N/A')}\n**Duration**: {json_data.get('duration', 'N/A')} Per Ep.\n**Score**: {json_data['averageScore']}\n**Genres**: `"
+    msg += ", ".join(json_data["genres"]) + "`\n"
+    msg += "**Studios**: `"
+    msg += ", ".join([x['name'] for x in json_data["studios"]["nodes"]]) + "`\n"
+    
+    info = json_data.get("siteUrl")
+    trailer = json_data.get("trailer", None)
+    if trailer:
+        trailer_id = trailer.get("id", None)
+        site = trailer.get("site", None)
+        if site == "youtube":
+            trailer = "https://youtu.be/" + trailer_id
+    
+    description = json_data.get("description", "N/A").replace("<i>", "").replace("</i>", "").replace("<br>", "")
+    msg += train_shorten(description, info)
+    image = json_data.get("bannerImage", None)
+    
+    buttons = [
+        [
+            InlineKeyboardButton("ᴍᴏʀᴇ ɪɴғᴏ", url=info),
+        ]
+    ]
+    if trailer:
+        buttons[0].append(InlineKeyboardButton("ᴛʀᴀɪʟᴇʀ", url=str(trailer)))
+        
+    if image:
+        try:
+            await message.reply_photo(photo=image, caption=msg,保护_markup=InlineKeyboardMarkup(buttons))
+        except Exception:
+            msg += f" [〽️]({image})"
+            await message.reply_text(msg, reply_markup=InlineKeyboardMarkup(buttons))
+    else:
+        await message.reply_text(msg, reply_markup=InlineKeyboardMarkup(buttons))
+
+def train_shorten(description, info):
+    if len(description) > 700:
+        return f"\n**Description**: _{description[:500]}...._[Read More]({info})"
+    return f"\n**Description**: _{description}_"
+
+@pbot.on_message(filters.command("character"))
+@DisableAbleCommandHandler("character")
+async def character(client: Client, message: Message):
+    search = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not search and message.reply_to_message:
+        search = message.reply_to_message.text
+
+    if not search:
+        await message.reply_text("Format : /character < character name >")
+        return
+
+    data = await get_response(character_query, {"query": search})
+    if not data or "data" not in data or not data["data"]["Character"]:
+        await message.reply_text("Character not found")
+        return
+
+    json_data = data["data"]["Character"]
+    msg = f"**{json_data.get('name').get('full')}**(`{json_data.get('name').get('native')}`)\n"
+    description = f"{json_data['description']}"
+    site_url = json_data.get("siteUrl")
+    msg += train_shorten(description, site_url)
+    image = json_data.get("image", None)
+    
+    if image:
+        await message.reply_photo(photo=image["large"], caption=msg.replace("<b>", "").replace("</b>", ""))
+    else:
+        await message.reply_text(msg.replace("<b>", "").replace("</b>", ""))
+
+@pbot.on_message(filters.command("manga"))
+@DisableAbleCommandHandler("manga")
+async def manga(client: Client, message: Message):
+    search = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not search and message.reply_to_message:
+        search = message.reply_to_message.text
+
+    if not search:
+        await message.reply_text("Format : /manga < manga name >")
+        return
+
+    data = await get_response(manga_query, {"search": search})
+    if not data or "data" not in data or not data["data"]["Media"]:
+        await message.reply_text("Manga not found")
+        return
+
+    json_data = data["data"]["Media"]
+    msg = f"**{json_data['title']['romaji']}**(`{json_data['title']['native']}`)\n"
+    if json_data["startDate"].get("year"):
+        msg += f"**Start Date**: `{json_data['startDate']['year']}`\n"
+    if json_data.get("status"):
+        msg += f"**Status**: `{json_data['status']}`\n"
+    if json_data.get("averageScore"):
+        msg += f"**Score**: `{json_data['averageScore']}`\n"
+    
+    msg += "**Genres**: " + ", ".join(json_data.get("genres", [])) + "\n"
+    
+    info = json_data["siteUrl"]
+    description = json_data.get('description', 'N/A')
+    msg += train_shorten(description, info)
+    
+    image = json_data.get("bannerImage")
+    buttons = [[InlineKeyboardButton("More Info", url=info)]]
+    
+    if image:
+        try:
+            await message.reply_photo(photo=image, caption=msg, reply_markup=InlineKeyboardMarkup(buttons))
+        except Exception:
+            msg += f" [〽️]({image})"
+            await message.reply_text(msg, reply_markup=InlineKeyboardMarkup(buttons))
+    else:
+        await message.reply_text(msg, reply_markup=InlineKeyboardMarkup(buttons))
+
+@pbot.on_message(filters.command("user"))
+@DisableAbleCommandHandler("user")
+async def user_info(client: Client, message: Message):
+    search_query = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not search_query:
+        await message.reply_text("Format : /user <username>")
+        return
+
+    async with AioJikan() as jikan:
+        try:
+            us = await jikan.user(search_query)
+        except Exception:
+            await message.reply_text("Username not found.")
+            return
+
+    img = us.get("images", {}).get("jpg", {}).get("image_url", "https://cdn.myanimelist.net/images/questionmark_50.gif")
+    
+    birthday = us.get("birthday")
+    joined = us.get("joined")
+    
+    caption = f"**ᴜsᴇʀɴᴀᴍᴇ**: [{us['username']}]({us['url']})\n\n"
+    caption += f"**ɢᴇɴᴅᴇʀ**: `{us.get('gender', 'Unknown')}`\n"
+    caption += f"**ʙɪʀᴛʜᴅᴀʏ**: `{birthday[:10] if birthday else 'Unknown'}`\n"
+    caption += f"**ᴊᴏɪɴᴇᴅ**: `{joined[:10] if joined else 'Unknown'}`\n"
+    
+    anime_stats = us.get("statistics", {}).get("anime", {})
+    manga_stats = us.get("statistics", {}).get("manga", {})
+    
+    caption += f"**ᴅᴀʏs ᴡᴀsᴛᴇᴅ ᴡᴀᴛᴄʜɪɴɢ ᴀɴɪᴍᴇ**: `{anime_stats.get('days_watched', 0)}`\n"
+    caption += f"**ᴅᴀʏs ᴡᴀsᴛᴇᴅ ʀᴇᴀᴅɪɴɢ ᴍᴀɴɢᴀ**: `{manga_stats.get('days_read', 0)}`\n\n"
+    
+    about = us.get("about", "N/A")
+    if len(about) > 300:
+        about = about[:300] + "..."
+    caption += f"**ᴀʙᴏᴜᴛ**: {about}"
+
+    buttons = [
+        [InlineKeyboardButton(info_btn, url=us["url"])],
+        [InlineKeyboardButton(close_btn, callback_data=f"anime_close,{message.from_user.id}")]
+    ]
+
+    await message.reply_photo(photo=img, caption=caption, reply_markup=InlineKeyboardMarkup(buttons))
+
+@pbot.on_message(filters.command("upcoming"))
+@DisableAbleCommandHandler("upcoming")
+async def upcoming_anime(client: Client, message: Message):
+    async with AioJikan() as jikan:
+        upcomin = await jikan.top(type="anime", filter="upcoming")
+        
+    upcoming_message = "Upcoming Anime:\n"
+    for i, entry in enumerate(upcomin["data"][:10]):
+        upcoming_message += f"{i + 1}. {entry['title']}\n"
+
+    await message.reply_text(upcoming_message)
+
+async def search_site(message, query, site):
+    search_url = f"https://{site}.com/?s={query}"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(search_url) as resp:
+            html_text = await resp.text()
+            
+    soup = bs4.BeautifulSoup(html_text, "html.parser")
+    if site == "animekaizoku":
+        search_result = soup.find_all("h2", {"class": "post-title"})
+    else:
+        search_result = soup.find_all("h2", {"class": "title"})
+
+    if not search_result:
+        await message.reply_text(f"**No result found for** `{query}`")
+        return
+
+    result = f"**Search results for** `{query}`\n"
+    for entry in search_result:
+        if entry.text.strip() == "Nothing Found":
+            await message.reply_text(f"**No result found for** `{query}`")
+            return
+        
+        link = entry.a["href"]
+        if site == "animekaizoku" and not link.startswith("http"):
+            link = "https://animekaizoku.com/" + link
+        
+        name = html.escape(entry.text.strip())
+        result += f"• [{name}]({link})\n"
+
+    buttons = [[InlineKeyboardButton("See all results", url=search_url)]]
+    await message.reply_text(result, reply_markup=InlineKeyboardMarkup(buttons), disable_web_page_preview=True)
+
+@pbot.on_message(filters.command("kaizoku"))
+@DisableAbleCommandHandler("kaizoku")
+async def kaizoku_cmd(client: Client, message: Message):
+    query = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not query:
+        await message.reply_text("Give something to search")
+        return
+    await search_site(message, query, "animekaizoku")
+
+@pbot.on_message(filters.command("kayo"))
+@DisableAbleCommandHandler("kayo")
+async def kayo_cmd(client: Client, message: Message):
+    query = message.text.split(None, 1)[1] if len(message.command) > 1 else None
+    if not query:
+        await message.reply_text("Give something to search")
+        return
+    await search_site(message, query, "animekayo")
+
+__mod_name__ = "Aɴɪᴍᴇ"
+__help__ = """
+ɢᴇᴛ ɪɴғᴏʀᴍᴀᴛɪᴏɴ ᴀʙᴏᴜᴛ ᴀɴɪᴍᴇ, ᴍᴀɴɢᴀ ᴏʀ ᴄʜᴀʀᴀᴄᴛᴇʀs ғʀᴏᴍ [ᴀɴɪʟɪsᴛ](ᴀɴɪʟɪsᴛ.ᴄᴏ).
+
+**ᴀᴠᴀɪʟᴀʙʟᴇ ᴄᴏᴍᴍᴀɴᴅs:**
+• `/anime <anime>`: ʀᴇᴛᴜʀɴs ɪɴғᴏʀᴍᴀᴛɪᴏɴ ᴀʙᴏᴜᴛ ᴛʜᴇ ᴀɴɪᴍᴇ.
+• `/character <ᴄʜᴀʀᴀᴄᴛᴇʀ>`: ʀᴇᴛᴜʀɴs ɪɴғᴏʀᴍᴀᴛɪᴏɴ ᴀʙᴏᴜᴛ ᴛʜᴇ ᴄʜᴀʀᴀᴄᴛᴇʀ.
+• `/manga <ᴍᴀɴɢᴀ>`: ʀᴇᴛᴜʀɴs ɪɴғᴏʀᴍᴀᴛɪᴏɴ ᴀʙᴏᴜᴛ ᴛʜᴇ ᴍᴀɴɢᴀ.
+• `/user <ᴜsᴇʀ>`: ʀᴇᴛᴜʀɴs ɪɴғᴏʀᴍᴀᴛɪᴏɴ ᴀʙᴏᴜᴛ ᴀ ᴍʏᴀɴɪᴍᴇʟɪsᴛ ᴜsᴇʀ.
+• `/upcoming`: ʀᴇᴛᴜʀɴs ᴀ ʟɪsᴛ ᴏғ ɴᴇᴡ ᴀɴɪᴍᴇ ɪɴ ᴛʜᴇ ᴜᴘᴄᴏᴍɪɴɢ sᴇᴀsᴏɴs.
+• `/kaizoku <ᴀɴɪᴍᴇ>`: sᴇᴀʀᴄʜ ᴀɴ ᴀɴɪᴍᴇ ᴏɴ ᴀɴɪᴍᴇᴋᴀɪᴢᴏᴋᴜ.ᴄᴏᴍ
+• `/kayo <ᴀɴɪᴍᴇ>`: sᴇᴀʀ��ʜ ᴀɴ ᴀɴɪᴍᴇ ᴏɴ ᴀɴɪᴍᴇᴋᴀʏᴏ.ᴄᴏᴍ
+• `/airing <ᴀɴɪᴍᴇ>`: ʀᴇᴛᴜʀɴs ᴀɴɪᴍᴇ ᴀɪɪɴɢ ɪɴғᴏ.
+"""

QueenNoxi/modules/antiban.py

@@ -0,0 +1,54 @@
+from pyrogram import Client
+from pyrogram.raw import functions, types
+from pyrogram.raw.base import Update
+
+
+@Client.on_raw_update()
+async def channel_handler(client: Client, update: Update, _, chats: dict):
+    while True:
+        try:
+            # Check for message that are from channel
+            if not isinstance(update, types.UpdateNewChannelMessage) or not isinstance(
+                update.message.from_id, types.PeerChannel
+            ):
+                return
+            # Basic data
+            message = update.message
+            chat_id = int(f"-100{message.peer_id.channel_id}")
+            channel_id = int(f"-100{message.from_id.channel_id}")
+            # Check enable or not
+            # Check for linked or free channel
+            if (
+                message.fwd_from
+                and message.fwd_from.saved_from_peer
+                == message.fwd_from.from_id
+                == message.from_id
+            ) or channel_id == chat_id:
+                return
+            # Delete the message sent by channel and ban it
+            await client.send(
+                functions.channels.EditBanned(
+                    channel=await client.resolve_peer(chat_id),
+                    participant=await client.resolve_peer(channel_id),
+                    banned_rights=types.ChatBannedRights(
+                        until_date=0,
+                        view_messages=True,
+                        send_messages=True,
+                        send_media=True,
+                        send_stickers=True,
+                        send_gifs=True,
+                        send_games=True,
+                        send_polls=True,
+                    ),
+                )
+            )
+            await client.delete_messages(chat_id, message.id)
+            await client.send_message(
+                int(chat_id),
+                f"#𝙰𝙽𝚃𝙸𝙲𝙷𝙰𝙽𝙽𝙴𝙻\n\n᛭ 𝚂𝙴𝙽𝙳𝙴𝚁 𝙸𝙳: `{channel_id}`\n᛭ 𝚃𝙰𝙺𝙴𝙽 𝙰𝙲𝚃𝙸𝙾𝙽: `DELETE BAN`",
+                disable_web_page_preview=True,
+            )
+            break
+        except Exception as e:
+            print(e)
+            break

QueenNoxi/modules/approve.py

@@ -0,0 +1,166 @@
+import html
+from pyrogram import filters, Client, enums
+from pyrogram.types import (
+    Message,
+    InlineKeyboardMarkup,
+    InlineKeyboardButton,
+    CallbackQuery
+)
+from pyrogram.errors import RPCError
+
+import QueenNoxi.modules.sql.approve_sql as sql
+from QueenNoxi import DRAGONS, pbot
+from QueenNoxi.modules.disable import DisableAbleCommandHandler
+from QueenNoxi.modules.helper_funcs.chat_status import user_admin, is_user_admin
+from QueenNoxi.modules.helper_funcs.extraction import extract_user
+from QueenNoxi.modules.log_channel import loggable
+
+@pbot.on_message(filters.command("approve") & filters.group)
+@DisableAbleCommandHandler("approve")
+@user_admin
+@loggable
+async def approve(client: Client, message: Message) -> str:
+    chat = message.chat
+    user = message.from_user
+    user_id = await extract_user(message, message.command[1:])
+    if not user_id:
+        await message.reply_text("I don't know who you're talking about, you're going to need to specify a user!")
+        return ""
+    
+    try:
+        member = await chat.get_member(user_id)
+    except RPCError:
+        return ""
+        
+    if member.status in (enums.ChatMemberStatus.ADMINISTRATOR, enums.ChatMemberStatus.OWNER):
+        await message.reply_text("User is already admin - locks, blocklists, and antiflood already don't apply to them.")
+        return ""
+        
+    if sql.is_approved(chat.id, user_id):
+        await message.reply_text(f"{member.user.mention} is already approved in {chat.title}")
+        return ""
+        
+    sql.approve(chat.id, user_id)
+    await message.reply_text(f"{member.user.mention} has been approved in {chat.title}! They will now be ignored by automated admin actions like locks, blocklists, and antiflood.")
+    
+    return f"<b>{html.escape(chat.title)}:</b>\n#APPROVED\n<b>Admin:</b> {user.mention}\n<b>User:</b> {member.user.mention}"
+
+@pbot.on_message(filters.command("unapprove") & filters.group)
+@DisableAbleCommandHandler("unapprove")
+@user_admin
+@loggable
+async def disapprove(client: Client, message: Message) -> str:
+    chat = message.chat
+    user = message.from_user
+    user_id = await extract_user(message, message.command[1:])
+    if not user_id:
+        await message.reply_text("I don't know who you're talking about, you're going to need to specify a user!")
+        return ""
+        
+    try:
+        member = await chat.get_member(user_id)
+    except RPCError:
+        return ""
+        
+    if member.status in (enums.ChatMemberStatus.ADMINISTRATOR, enums.ChatMemberStatus.OWNER):
+        await message.reply_text("This user is an admin, they can't be unapproved.")
+        return ""
+        
+    if not sql.is_approved(chat.id, user_id):
+        await message.reply_text(f"{member.user.first_name} isn't approved yet!")
+        return ""
+        
+    sql.disapprove(chat.id, user_id)
+    await message.reply_text(f"{member.user.first_name} is no longer approved in {chat.title}.")
+    
+    return f"<b>{html.escape(chat.title)}:</b>\n#UNAPPROVED\n<b>Admin:</b> {user.mention}\n<b>User:</b> {member.user.mention}"
+
+@pbot.on_message(filters.command("approved") & filters.group)
+@DisableAbleCommandHandler("approved")
+@user_admin
+async def approved(client: Client, message: Message):
+    chat = message.chat
+    msg = "The following users are approved.\n"
+    approved_users = sql.list_approved(chat.id)
+    for i in approved_users:
+        try:
+            member = await chat.get_member(int(i.user_id))
+            msg += f"- `{i.user_id}`: {member.user.first_name}\n"
+        except:
+            msg += f"- `{i.user_id}`\n"
+            
+    if msg.endswith("approved.\n"):
+        await message.reply_text(f"No users are approved in {chat.title}.")
+    else:
+        await message.reply_text(msg)
+
+@pbot.on_message(filters.command("approval") & filters.group)
+@DisableAbleCommandHandler("approval")
+@user_admin
+async def approval(client: Client, message: Message):
+    chat = message.chat
+    user_id = await extract_user(message, message.command[1:])
+    if not user_id:
+        await message.reply_text("I don't know who you're talking about, you're going to need to specify a user!")
+        return ""
+        
+    member = await chat.get_member(int(user_id))
+    if sql.is_approved(chat.id, user_id):
+        await message.reply_text(f"{member.user.first_name} is an approved user. Locks, antiflood, and blocklists won't apply to them.")
+    else:
+        await message.reply_text(f"{member.user.first_name} is not an approved user. They are affected by normal commands.")
+
+@pbot.on_message(filters.command("unapproveall") & filters.group)
+@DisableAbleCommandHandler("unapproveall")
+async def unapproveall(client: Client, message: Message):
+    chat = message.chat
+    user = message.from_user
+    member = await chat.get_member(user.id)
+    if member.status != enums.ChatMemberStatus.OWNER and user.id not in DRAGONS:
+        await message.reply_text("Only the chat owner can unapprove all users at once.")
+        return
+
+    buttons = InlineKeyboardMarkup(
+        [
+            [InlineKeyboardButton(text="Unapprove all users", callback_data="unapproveall_user")],
+            [InlineKeyboardButton(text="Cancel", callback_data="unapproveall_cancel")],
+        ]
+    )
+    await message.reply_text(
+        f"Are you sure you would like to unapprove ALL users in {chat.title}? This action cannot be undone.",
+        reply_markup=buttons,
+    )
+
+@pbot.on_callback_query(filters.regex(r"unapproveall_.*"))
+async def unapproveall_btn(client: Client, query: CallbackQuery):
+    chat = query.message.chat
+    user_id = query.from_user.id
+    member = await chat.get_member(user_id)
+    
+    if query.data == "unapproveall_user":
+        if member.status == enums.ChatMemberStatus.OWNER or user_id in DRAGONS:
+            approved_users = sql.list_approved(chat.id)
+            for i in approved_users:
+                sql.disapprove(chat.id, int(i.user_id))
+            await query.message.edit_text("Successfully unapproved all users.")
+        else:
+            await query.answer("Only the owner of the chat can do this.", show_alert=True)
+            
+    elif query.data == "unapproveall_cancel":
+        if member.status == enums.ChatMemberStatus.OWNER or user_id in DRAGONS:
+            await query.message.edit_text("Removing of all approved users has been cancelled.")
+        else:
+            await query.answer("Only the owner of the chat can do this.", show_alert=True)
+
+__mod_name__ = "Approve"
+__help__ = """
+Some users might be trustworthy enough to be ignored by automated admin actions.
+Approval allows them to be bypassed by locks, blocklists, and antiflood.
+
+**Admin Commands:**
+• `/approval`: Check a user's approval status
+• `/approve`: Approve a user
+• `/unapprove`: Unapprove a user
+• `/approved`: List all approved users
+• `/unapproveall`: Unapprove ALL users (Owner only)
+"""