Fixed commands.en-US.yml

Replaced all usages of ConcurrentDictionary with NonBlocking.ConcurrentDictionary

See merge request Kwoth/nadekobot!256

.dockerignore

@@ -1,6 +1,8 @@
 # Ignore all files
 *
 
+# Use Nadeko.Medusa project
+!src/Nadeko.Medusa/**
 # Use NadekoBot project
 !src/NadekoBot/**
 # Use NadekoBot.Coordinator project

.gitignore

@@ -1,5 +1,11 @@
 #Manually added files
 
+# medusa stuff
+!src/NadekoBot/data/medusae/medusa.yml
+src/NadekoBot/data/medusae/**
+
+# other
+
 command_errors*.txt
 output/
 src/NadekoBot/output

.gitlab-ci.yml

@@ -7,6 +7,7 @@ stages:
   - release
   - publish-windows
   - upload-windows-updater-release
+  - publish-medusa-package
 
 variables:
   project: "NadekoBot"
@@ -18,41 +19,41 @@ variables:
   PACKAGE_REGISTRY_URL: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/NadekoBot-build/${CI_COMMIT_TAG}"
   INSTALLER_OUTPUT_DIR: "nadeko-installers/${CI_COMMIT_TAG}"
   INSTALLER_FILE_NAME: "nadeko-setup-${CI_COMMIT_TAG}.exe"
-  
+
 build:
   stage: build
   script:
-    - "dotnet publish -c Release -r linux-x64 -o $LINUX_X64_OUTPUT_DIR src/NadekoBot/NadekoBot.csproj"
-    - "dotnet publish -c Release -r win7-x64 -o $WIN_X64_OUTPUT_DIR src/NadekoBot/NadekoBot.csproj"
+    - "dotnet publish -c Release -r linux-x64 --self-contained -o $LINUX_X64_OUTPUT_DIR src/NadekoBot/NadekoBot.csproj"
+    - "dotnet publish -c Release -r win7-x64 --self-contained -o $WIN_X64_OUTPUT_DIR src/NadekoBot/NadekoBot.csproj"
   artifacts:
     paths:
       - "$LINUX_X64_OUTPUT_DIR/"
       - "$WIN_X64_OUTPUT_DIR/"
 
 upload-builds:
- stage: upload-builds
- image: alpine:latest
- rules:
-   - if: $CI_COMMIT_TAG
- script:    
-   - apk add --no-cache curl tar zip
-   - "tar cvf $LINUX_X64_RELEASE $LINUX_X64_OUTPUT_DIR/*"
-   - "zip -r $WIN_X64_RELEASE $WIN_X64_OUTPUT_DIR/*"
-   - |
-     curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $LINUX_X64_RELEASE $PACKAGE_REGISTRY_URL/$LINUX_X64_RELEASE
-   - |
-     curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $WIN_X64_RELEASE $PACKAGE_REGISTRY_URL/$WIN_X64_RELEASE
+  stage: upload-builds
+  image: alpine:latest
+  rules:
+    - if: $CI_COMMIT_TAG
+  script:
+    - apk add --no-cache curl tar zip
+    - "tar cvf $LINUX_X64_RELEASE $LINUX_X64_OUTPUT_DIR/*"
+    - "zip -r $WIN_X64_RELEASE $WIN_X64_OUTPUT_DIR/*"
+    - |
+      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $LINUX_X64_RELEASE $PACKAGE_REGISTRY_URL/$LINUX_X64_RELEASE
+    - |
+      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file $WIN_X64_RELEASE $PACKAGE_REGISTRY_URL/$WIN_X64_RELEASE
 
 release:
- stage: release
- image: registry.gitlab.com/gitlab-org/release-cli:latest
- rules:
-   - if: $CI_COMMIT_TAG
- script:
-   - |
-     release-cli create --name "NadekoBot v$CI_COMMIT_TAG" --description "## [Changelog](https://gitlab.com/Kwoth/nadekobot/-/blob/v4/CHANGELOG.md#$(echo "$CI_COMMIT_TAG" | sed "s/\.//g")-$(date +%d%m%Y))" --tag-name $CI_COMMIT_TAG \
-       --assets-link "{\"name\":\"${LINUX_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${LINUX_X64_RELEASE}\"}" \
-       --assets-link "{\"name\":\"${WIN_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${WIN_X64_RELEASE}\"}"
+  stage: release
+  image: registry.gitlab.com/gitlab-org/release-cli:latest
+  rules:
+    - if: $CI_COMMIT_TAG
+  script:
+    - |
+      release-cli create --name "NadekoBot v$CI_COMMIT_TAG" --description "## [Changelog](https://gitlab.com/Kwoth/nadekobot/-/blob/v4/CHANGELOG.md#$(echo "$CI_COMMIT_TAG" | sed "s/\.//g")-$(date +%d%m%Y))" --tag-name $CI_COMMIT_TAG \
+        --assets-link "{\"name\":\"${LINUX_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${LINUX_X64_RELEASE}\"}" \
+        --assets-link "{\"name\":\"${WIN_X64_RELEASE}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${WIN_X64_RELEASE}\"}"
 
 test:
   stage: test
@@ -63,63 +64,75 @@ test:
     - "dotnet test"
 
 publish-windows:
- stage: publish-windows 
- rules:
-   - if: '$CI_COMMIT_TAG'
- image: scottyhardy/docker-wine
- before_script:
-   - choco install dotnet-6.0-runtime -y
-   - choco install dotnet-6.0-sdk -y
-   - choco install innosetup -y
- artifacts:
-   paths:
-     - "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
- script:
-   - dotnet clean
-   - dotnet restore
-   - dotnet publish -c Release --runtime win7-x64 /p:Version=$CI_COMMIT_TAG src/NadekoBot
-   - $env:NADEKOBOT_INSTALL_VERSION = $CI_COMMIT_TAG
-   - iscc.exe "/O+" ".\exe_builder.iss"
- tags:
-   - windows
+  stage: publish-windows
+  rules:
+    - if: "$CI_COMMIT_TAG"
+  image: scottyhardy/docker-wine
+  before_script:
+    - choco install dotnet-6.0-runtime --version=6.0.4 -y
+    - choco install dotnet-6.0-sdk --version=6.0.202 -y
+    - choco install innosetup -y
+  artifacts:
+    paths:
+      - "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
+  script:
+    - dotnet clean
+    - dotnet restore -f --no-cache -v n
+    - dotnet publish -c Release --runtime win7-x64 /p:Version=$CI_COMMIT_TAG src/NadekoBot
+    - $env:NADEKOBOT_INSTALL_VERSION = $CI_COMMIT_TAG
+    - iscc.exe "/O+" ".\exe_builder.iss"
+  tags:
+    - windows
 
 upload-windows-updater-release:
- stage: upload-windows-updater-release
- rules:
-   - if: '$CI_COMMIT_TAG'
- image: 
-   name: amazon/aws-cli
-   entrypoint: [""]
- script:  
-   - sed -i "s/_INSTALLER_FILE_NAME_/$INSTALLER_FILE_NAME/g" releases-v3.json
-   - sed -i "s/_VERSION_/$CI_COMMIT_TAG/g" releases-v3.json
-   - aws --version
-   - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/$INSTALLER_FILE_NAME" --acl public-read --body "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
-   - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/releases-v3.json" --acl public-read --body "releases-v3.json"
+  stage: upload-windows-updater-release
+  rules:
+    - if: "$CI_COMMIT_TAG"
+  image:
+    name: amazon/aws-cli
+    entrypoint: [""]
+  script:
+    - sed -i "s/_INSTALLER_FILE_NAME_/$INSTALLER_FILE_NAME/g" releases-v3.json
+    - sed -i "s/_VERSION_/$CI_COMMIT_TAG/g" releases-v3.json
+    - aws --version
+    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/$INSTALLER_FILE_NAME" --acl public-read --body "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
+    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/releases-v3.json" --acl public-read --body "releases-v3.json"
 
-# docker-build:
-#  # Use the official docker image.
-#  image: docker:latest
-#  stage: build
-#  services:
-#    - docker:dind
-#  before_script:
-#    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
-#  # Default branch leaves tag empty (= latest tag)
-#  # All other branches are tagged with the escaped branch name (commit ref slug)
-#  script:
-#    - |
-#      if [[ "$CI_COMMIT_BRANCH" == "$CI_DEFAULT_BRANCH" ]]; then
-#        tag=""
-#        echo "Running on default branch '$CI_DEFAULT_BRANCH': tag = 'latest'"
-#      else
-#        tag=":$CI_COMMIT_REF_SLUG"
-#        echo "Running on branch '$CI_COMMIT_BRANCH': tag = $tag"
-#      fi
-#    - docker build --pull -t "$CI_REGISTRY_IMAGE${tag}" .
-#    - docker push "$CI_REGISTRY_IMAGE${tag}"
-#  # Run this job in a branch where a Dockerfile exists
-#  rules:
-#    - if: $CI_COMMIT_BRANCH
-#      exists:
-#        - Dockerfile
+publish-medusa-package:
+  stage: publish-medusa-package
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_COMMIT_TAG
+  script:
+    - LAST_TAG=$(git describe --tags --abbrev=0)
+    - if [ $CI_COMMIT_TAG ];then MEDUSA_VERSION="$CI_COMMIT_TAG"; else MEDUSA_VERSION="$LAST_TAG-$CI_COMMIT_SHA"; fi
+    - cd src/Nadeko.Medusa/
+    - dotnet pack -c Release /p:Version=$MEDUSA_VERSION -o bin/Release/packed
+    - dotnet nuget push bin/Release/packed/ --source https://www.myget.org/F/nadeko/api/v2/package --api-key "$MYGET_API_KEY"
+
+docker-build:
+  # Use the official docker image.
+  image: docker:latest
+  stage: build
+  allow_failure: true
+  services:
+    - docker:dind
+  before_script:
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
+  # Default branch leaves tag empty (= latest tag)
+  # All other branches are tagged with the escaped branch name (commit ref slug)
+  script:
+    - |
+      if [[ "$CI_COMMIT_BRANCH" == "$CI_DEFAULT_BRANCH" ]]; then
+        tag=""
+        echo "Running on default branch '$CI_DEFAULT_BRANCH': tag = 'latest'"
+      else
+        tag=":$CI_COMMIT_SHA"
+        echo "Running on branch '$CI_COMMIT_BRANCH': tag = $tag"
+      fi
+    - docker build --pull -t "$CI_REGISTRY_IMAGE${tag}" .
+    - docker push "$CI_REGISTRY_IMAGE${tag}"
+  # Run this job in a branch where a Dockerfile exists
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_COMMIT_TAG
+      exists:
+        - Dockerfile

CHANGELOG.md

@@ -1,14 +1,382 @@
 # Changelog
 
 Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.com/en/1.0.0/) except date format. a-c-f-r-o
-#todo .trans fix
 
-## Unreleased
+## [4.2.14] - 03.07.2022
 
-- More cool stuff coming soon
+### Added
+
+- Added `.log userwarned` (Logging user warnings)
+- Claiming `.timely` will now show a button which you can click to set a reminder
+- Added `%server.icon%` placeholder
+- Added `warn` punishment action for protection commands (it won't work with `.warnp`)
+
+### Changed
+
+- `.log userbanned` will now have a ban reason
+- When `.die` is used, bot will try to update it's status to `Invisible`
+
+### Fixed
+
+- Fixed elipsis character issue with aliases/quotes. You should now be able to set an elipsis to be an alias of `.quoteprint`
+
+## [4.2.13] - 30.06.2022
+
+### Fixed
+
+- Fixed `.cash` bank interaction not being ephemeral anymore
+
+## [4.2.12] - 30.06.2022
+
+### Fixed
+
+- Fixed `.trivia --pokemon` showing incorrect pokemons
+
+## [4.2.11] - 29.06.2022
+
+### Fixed
+
+- Fixed `.draw` command 
+
+## [4.2.10] - 29.06.2022
+
+- Fixed currency generation working only once
+
+## [4.2.9] - 25.06.2022
+  
+### Fixed
+
+- Fixed `creds_example.yml` misssing from output directory
+
+## [4.2.8] - 24.06.2022
+
+### Fixed
+
+- `.timely` should be fixed
+
+## [4.2.7] - 24.06.2022
+
+### Changed
+
+- New cache abstraction added
+  - 2 implemenations: redis and memory
+  - All current bots will stay on redis cache, all new bots will use **in-process memory cache by default**
+  - This change removes bot's hard dependency on redis
+  - Configurable in `creds.yml` (please read the comments)
+  - You **MUST** use 'redis' if your bot runs on more than 1 shard (2000+ servers)
+- [dev] Using new non-locking ConcurrentDictionary
+
+### Fixed
+
+- `.xp` will now show default user avatars too
+
+### Removed
+
+- Removed `.imagesreload` as images are now lazily loaded on request and then cached
+
+## [4.2.6] - 22.06.2022
+
+### Fixed
+
+- Patron system should now properly by disabled on selfhosts by default.
+
+## [4.2.5] - 18.06.2022
+
+### Fixed
+
+- Fixed `.crypto`, you will still need coinmarketcapApiKey in `creds.yml` in order to make it run consistently as the key is shared
+
+## [4.2.3] - 17.06.2022
+
+### Fixed
+
+- Fixed `.timely` nullref bug and made it nicer
+- Fixed `.streamrole` not updating in real time!
+- Disabling specific Global Expressions should now work with `.sc` (and other permission commands)
+
+## [4.2.2] - 15.06.2022
+
+### Fixed
+
+- Added missing Patron Tiers and fixed Patron pledge update bugs
+- Prevented creds_example.yml error in docker containers from crashing it
+
+### Changed
+
+- Rss feeds will now show error counter before deletion
+
+## [4.2.1] - 14.06.2022
+
+### Added
+
+- Localized strings updated
+
+### Fixed
+
+- Fixed `.exexport`, `.savechat`, and `.quoteexport`
+- Fixed plaintext-only embeds
+- Fixed greet message footer not showing origin server
+
+## [4.2.0] - 14.06.2022
+
+### Added
+
+- Added `data/searches.yml` file which configures some of the new search functionality
+  The file comments explaining what each property does.
+  Explained briefly here:
+  ```yml
+  # what will be used for .google command. Either google (official api) or searx
+  webSearchEngine: Google
+  # what will be used for .img command. Either google (official api) or searx
+  imgSearchEngine: Google
+  # how will yt results be retrieved: ytdataapi or ytdl or ytdlp
+  ytProvider: YtDataApiv3
+  # in case web or img search is set to searx, the following instances will be used:
+  searxInstances: []
+  # in case ytProvider is set to invidious, the following instances will be used
+  invidiousInstances: []
+  ```
+- Added new properties to `creds.yml`. google -> searchId and google -> searchImageId.
+- These properties are used as `cx` (google api query parameter) in case you've setup your `data/searches.yml` to use the official google api.
+  `searchId` is used for web search
+  `searchimageId` is used for image search
+  ```yml
+  google:
+      searchId: ""
+      searchImageId: ""
+  ```
+- Check `creds_example.yml` for comments explaining how to obtain them.
+
+#### Patronage system added
+- Added `data/patron.yml` for configuration
+- Implemented only for patreon so far
+- Patreon subscription code completely rewritten
+- Users who pledge on patreon get benefits based on the amount they pledged
+- Public nadeko only. But selfhosters can adapt it to their own patreon pages by configuring their patreon credentials in `creds.yml` and enabling the system in `data/patron.yml` file.
+  - Most of the patronage system strings are hardcoded atm, so if you wish to use this system on selfhosts, you will have to modify the source
+- Pledge amounts are split into tiers. This is not configurable atm.
+  - Tier I - 1$ - 4.99$ a month
+  - Tier V - 5$ - 9.99$ a month
+  - Tier X - 10$ - 19.99$ a month
+  - Tier XX - 20$ - 49.99$ a month
+  - Tier L - 50$ - 99.99$ a month
+  - Tier C - 100$+ a month
+- Rewards and command quotas for each of the tiers are configurable
+- Limitations to certain features are also configurable. ex:
+```yml
+quotas:
+    features:
+        "rero:max_count":
+            x: 50
+```
+- ^ this setting would set the maximum number of reaction roles to be 50 for a user who is in Patron Tier X
+- Read the comments in the .yml file for (much) more info
+- Quota system allows the owner to set up hourly, daily and monthly quota usage for each tier
+- Quota system applies to entire server owner by a patron
+  - Patron spends own quota by using the commands on any server
+  - Any user on *any* server owned by a patron spends that patron's quota
+- When users subscribe to patreon they will receive a welcome message
+  - If you're enabling patron system for a selfhost, you will want to edit it
+
+Added `.patron` and `.patronmessage` commands
+- `.patron` checks your patronage status, and quotas. Requires patron system to be enabled.
+- `.patronmessage` (owner only) sends message to all patrons with the specified tier or higher. Supports embeds
+
+- Added a fake `.cmdcd` command `cleverbot:response` which can be used to limit how often users can talk to the cleverbot.
+
+### Changed
+
+- CurrencyReward now support adding additional flowers to patrons.
+- `.donate` command completely reworked.
+  - Works only on public bot (OnlyPublicBotAttribute)
+  - Guides user on how to donate to support the project
+  - Added interaction explaining selfhosting
+
+- `.google` reimplemented. It now has 2 modes configurable in `data/searches.yml` under the `webSearchengine` property
+  - If set to `google`, official custom search api will be used. You will need to set googleapikey and google.searchId in `creds.yml`
+  - if set to `searx` one of the instances specified in the `searxInstances:` property will be randomly chosen for each request
+    - instances must have `format=json` allowed (public ones usually don't allow it)
+    - instances are specified as a fully qualified url, example: `https://my.cool.searx.instance.io`
+- `.image` reimplemented. Same as `.google` - it uses either `google` official api (in which case it uses `google.searchImageId` from `creds.yml`) or `searx`
+
+- `.youtube` reimplemented. It will use a `ytProvider:` property from `data/searches.yml` to determine how to retrieve results
+  - `ytdataapi` will use the official google api (requires `GoogleApiKey` specified in `creds.yml`) and YoutubeDataApi enabled in the dev console
+  - `ytdl` will use `youtube-dl` program from the host machine. It must be downloaded and it's location must be added to path env variable.
+  - `ytdlp` will use `yt-dlp` program from the host machine. Same as `youtube-dl` - must be in path env variable.
+  - `invidious` will use one of invidious instances specified in the `invidiousInstances` property. Very good. 
+
+- `.google`, `.youtube` and `.image` moved to the new Search group
+
+Note: Results of each `.youtube` query will be cached for 1 hour to improve perfomance
+- Removed 30 second `.ping` ratelimit on public nadeko
+
+- xp image generation changes
+  - In case you have default settings, your xp image will look slightly different
+  - If you've modified xp_template.json, your xp image might look broken. Your old template will be saved in xp_template.json.old
+  - Xp number outline is now slightly thicker
+  - Xp number will now have Center vertical and horizontal alignment
+  - LastLevelUp no longer supported
+
+- Some commands will now use timestamp tags for better user experience
+- `.prune` was slightly slowed down to avoid ratelimits
+- `.wof` moved from it's own group to the default Gambling group
+- `.feed` urls which error for more than 100 times will be automatically removed.
+- `.ve` is now enabled by default
+
+- [dev] nadeko interaction slightly improved to make it less nonsense (they still don't make sense)  
+- [dev] RewardedUsers table slightly changed to make it more general  
+- [dev] renamed `// todo`s which aren't planned soon to `// FUTURE`  
+- [dev] currency rewards have been reimplemented and moved to a separate service  
+
+### Fixed
+ 
+- `.rh` no longer needs quotes for multi word roles
+- `.deletexp` will now properly delete server xp too
+- Fixed `.crypto` sparklines
+- [dev] added support for configs to properly parse enums without case sensitivity (ConfigParsers.InsensitiveEnum)
+- [dev] Fixed a bug in .gencmdlist  
+- [dev] small fixes to creds provider  
+
+### Removed
+
+- `.ddg` removed.
+- [dev] removed some dead code and comments
+
+## [4.1.6] - 14.05.2022
+
+### Fixed
+
+- Fixed windows release and updated packages
+
+## [4.1.5] - 11.05.2022
+
+### Changed
+
+- `.clubdesc <msg>` will now have a nicer response
+
+### Fixed
+
+- `.give` DM will once again show an amount
+- Fixed an issue with filters not working and with custom reactions no longer being able to override commands.
+- Fixed `.stock` command
+
+## [4.1.4] - 06.05.2022
+
+### Fixed
+
+- Fixed `.yun`
+
+## [4.1.3] - 06.05.2022
+
+### Added 
+
+- Added support for embed arrays in commands such as .say, .greet, .bye, etc...
+  - Website to create them is live at eb.nadeko.bot (old one is moved to oldeb.nadeko.bot)
+  - Embed arrays don't have a plainText property (it's renamed to 'content')
+  - Embed arrays use color hex values instead of an integer
+  - Old embed format will still work
+  - There shouldn't be any breaking changes
+- Added `.stondel` command which, when toggled, will make the bot delete online stream messages on the server when the stream goes offline
+- Added a simple bank system.
+  - Users can deposit, withdraw and check the balance of their currency in the bank.
+  - Users can't check other user's bank balances.
+- Added a button on a .$ command which, when clicked, sends you a message with your bank balance that only you can see.
+- Added `.h <command group>`  
+  - Using this command will list all commands in the specified group
+  - Atm only .bank is a proper group (`.h bank`)
+- Added "Bank Accounts" entry to `.economy`
+
+### Changed
+
+- Reaction roles rewritten completely 
+  - Supports multiple exclusivity groups per message 
+  - Supports level requirements
+  - However they can only be added one by one
+  - Use the following commands for more information 
+    - `.h .reroa`
+    - `.h .reroli`
+    - `.h .rerot`
+    - `.h .rerorm`
+    - `.h .rerodela`
+- Pagination is now using buttons instead of reactions
+- Bot will now support much higher XP values for global and server levels
+- [dev] Small change and generation perf improvement for the localized response strings
+
+
+### Fixed
+
+- Fixed `.deletexp` command
+- `.give` command should send DMs again
+- `.modules` command now has a medusa module description
+
+## [4.1.2] - 16.04.2022
+
+### Fixed
+
+- Fixed an issue with missing `.dll` files in release versions
+
+## [4.1.0] - 16.04.2022
+
+### Added
+
+- NadekoBot now supports mysql, postgresql and sqlite
+  - To change the db nadeko will use, simply change the `db type` in `creds.yml`
+  - There is no migration code right now, which means that if you want to switch to another system you'll either have to manually export/import your database or start fresh
+- Medusa system
+  - A massive new feature which allows developers to create custom modules/plugins/cogs 
+  - They can be load/unloaded/updated at runtime without restarting the bot
+
+### Changed
+
+- Minor club rework
+  - Clubs names are now case sensitive (owo and OwO can be 2 different clubs)
+  - Removed discriminators
+    - Current discriminators which are greater than 1 are appended to clubnames to avoid duplicates, you can rename your club with `.clubrename` to remove it
+    - Most of the clubs with #1 discriminator no longer have it (For example MyClub#1 will now just be MyClub)
+- [dev] A lot of refactoring and slight functionality changes within Nadeko's behavior system and command handler which were required in order to support the medusa system
+
+### Removed
+
+  - Removed `.clublevelreq` command as it doesn't serve much purpose
+
+## [4.0.6] - 21.03.2022
+
+### Fixed
+
+- Fixed voice presence logging
+- Fixed .clubaccept, .clubban, .clubkick and .clubunban commands
+
+## [4.0.5] - 21.03.2022
+
+### Fixed
+
+- Fixed several bugs in the currency code
+- Fixed some potential memory leaks
+- Fixed some response strings
+
+## [4.0.4] - 04.03.2022
+
+### Fixed
+
+- Fixed the `id` which shows up when you add a new Expression
+- Fixed some strings which were still referring to "CustomReaction(s)" instead of "Expression(s)" 
+
+## [4.0.3] - 04.03.2022
+
+### Fixed
+
+- Console should no longer spam numbers when `.antispam` is enabled
+
+## [4.0.2] - 03.03.2022
+
+### Fixed
+
+- Fixed `.rero` not working due to a bug introduced in 4.0
 
 ## [4.0.1] - 03.03.2022
 
+### Added
+
 - Added `usePrivilegedIntents` to creds.yml if you don't have or don't want (?) to use them
 - Added a human-readable, detailed error message if logging in fails due to missing privileged intents
 
@@ -52,6 +420,7 @@ Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.
 - [dev] Moved FilterWordsChannelId to a separate table
 
 ### Fixed
+- Fixed twitch stream notifications (rewrote it to use the new api)
 - Fixed an extra whitespace in usage part of command help if the command has no arguments
 - Possible small fix for `.prune` ratelimiting
 - `.gvc` should now properly trigger when a user is already in a gvc and changes his activity
@@ -471,4 +840,4 @@ Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.
 ### Removed
 
 - Removed admin requirement on `.scrm` as it didn't make sense
-- Some Music commands are removed because of the complexity they bring in with little value (if you *really* want them back, you can open an issue and specify your *good* reason)
+- Some Music commands are removed because of the complexity they bring in with little value (if you *really* want them back, you can open an issue and specify your *good* reason)

Dockerfile

@@ -1,6 +1,7 @@
 FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
 WORKDIR /source
 
+COPY src/Nadeko.Medusa/*.csproj src/Nadeko.Medusa/
 COPY src/NadekoBot/*.csproj src/NadekoBot/
 COPY src/NadekoBot.Coordinator/*.csproj src/NadekoBot.Coordinator/
 COPY src/NadekoBot.Generators/*.csproj src/NadekoBot.Generators/
@@ -24,12 +25,14 @@ WORKDIR /app
 RUN set -xe; \
     useradd -m nadeko; \
     apt-get update; \
-    apt-get install -y libopus0 libsodium23 libsqlite3-0 curl ffmpeg python3 python3-pip sudo; \
-    update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1; \
+    apt-get install -y --no-install-recommends libopus0 libsodium23 libsqlite3-0 curl ffmpeg python3 python3-pip sudo; \
+    update-alternatives --install /usr/bin/python python /usr/bin/python3.9 1; \
     echo 'Defaults>nadeko env_keep+="ASPNETCORE_* DOTNET_* NadekoBot_* shard_id total_shards TZ"' > /etc/sudoers.d/nadeko; \
-    pip3 install --upgrade youtube-dl; \
-    apt-get remove -y python3-pip; \
-    chmod +x /usr/local/bin/youtube-dl
+    pip3 install --no-cache-dir --upgrade youtube-dl; \
+    apt-get purge -y python3-pip; \
+    chmod +x /usr/local/bin/youtube-dl; \
+    apt-get autoremove -y; \
+    apt-get autoclean -y
 
 COPY --from=build /app ./
 COPY docker-entrypoint.sh /usr/local/sbin
@@ -37,6 +40,6 @@ COPY docker-entrypoint.sh /usr/local/sbin
 ENV shard_id=0
 ENV total_shards=1
 
-VOLUME [ "app/data" ]
+VOLUME [ "/app/data" ]
 ENTRYPOINT [ "/usr/local/sbin/docker-entrypoint.sh" ]
-CMD dotnet NadekoBot.dll "$shard_id" "$total_shards"
+CMD dotnet NadekoBot.dll "$shard_id" "$total_shards"

NadekoBot.sln

@@ -11,6 +11,7 @@ ProjectSection(SolutionItems) = preProject
 	LICENSE.md = LICENSE.md
 	README.md = README.md
 	.gitlab-ci.yml = .gitlab-ci.yml
+	Dockerfile = Dockerfile
 EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NadekoBot", "src\NadekoBot\NadekoBot.csproj", "{45EC1473-C678-4857-A544-07DFE0D0B478}"
@@ -27,6 +28,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.Generators", "src
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.VotesApi", "src\NadekoBot.VotesApi\NadekoBot.VotesApi.csproj", "{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nadeko.Medusa", "src\Nadeko.Medusa\Nadeko.Medusa.csproj", "{E685977E-31A4-46F4-A5D7-4E3E39E82E43}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -70,6 +73,12 @@ Global
 		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.GlobalNadeko|Any CPU.Build.0 = Debug|Any CPU
 		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43}.GlobalNadeko|Any CPU.ActiveCfg = Debug|Any CPU
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43}.GlobalNadeko|Any CPU.Build.0 = Debug|Any CPU
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -82,6 +91,7 @@ Global
 		{AE9B7F8C-81D7-4401-83A3-643B38258374} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
+		{E685977E-31A4-46F4-A5D7-4E3E39E82E43} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {5F3F555C-855F-4BE8-B526-D062D3E8ACA4}

docs/custom-reactions.md

@@ -1,23 +1,23 @@
-## Custom Reactions / Expressions
+## Expressions
 
 ### Important
 
-- For modifying **global** custom reactions, the ones which will work across all the servers your bot is connected to, you **must** be a Bot Owner.  
-  You must also use the commands for adding, deleting and listing these reactions in a direct message with the bot.
-- For modifying **local** custom reactions, the ones which will only work on the server that they are added on, it is required to have the **Administrator** permission.  
-  You must also use the commands for adding, deleting and listing these reactions in the server you want the custom reactions to work on.
+- For modifying **global** expressions, the ones which will work across all the servers your bot is connected to, you **must** be a Bot Owner.  
+  You must also use the commands for adding, deleting and listing these expressions in a direct message with the bot.
+- For modifying **local** expressions, the ones which will only work on the server that they are added on, it is required to have the **Administrator** permission.  
+  You must also use the commands for adding, deleting and listing these expressions in the server you want the expressions to work on.
 
 ### Commands and Their Use
 
 | Command Name | Description                                                                                                                                                                                                                                                                                | Example                          |
 | :----------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- |
-|    `.acr`    | Add a custom reaction with a trigger and a response. Running this command in a server requries the Administrator permission. Running this command in DM is Bot Owner only, and adds a new global custom reaction. | `.acr "hello" Hi there, %user%!` |
-|    `.lcr`    | Lists a page of global or server custom reactions (15 reactions per page). Running this command in a DM will list the global custom reactions, while running it in a server will list that server's custom reactions.                                                                      | `.lcr 1`                         |
-|    `.dcr`    | Deletes a custom reaction based on the provided index. Running this command in a server requires the Administrator permission. Running this command in DM is Bot Owner only, and will delete a global custom reaction.                                                                     | `.dcr 5`                         |
+| `.exa`  | Add an expression with a trigger and a response. Running this command in a server requries the Administrator permission. Running this command in DM is Bot Owner only, and adds a new global expression.             | `.exadd "hello" Hi there, %user%!` |
+|   `exl`   | Lists a page of global or server expression(15 expressions per page). Running this command in a DM will list the global expression, while running it in a server will list that server's expression.   | `.exl 1`                           |
+|   `.exd`  | Deletes an expression based on the provided index. Running this command in a server requires the Administrator permission. Running this command in DM is Bot Owner only, and will delete a global expression.     | `.exd 5`                           |
 
-#### Now that we know the commands let's take a look at an example of adding a command with `.acr`,
+#### Now that we know the commands let's take a look at an example of adding a command with `.exa`,
 
-`.acr "Nice Weather" It sure is, %user%!`
+`.exadd "Nice Weather" It sure is, %user%!`
 
 This command can be split into two different arguments:
 
@@ -28,16 +28,16 @@ An important thing to note about the triger is that, to be more than one word, w
 
 There's no special requirement for the formatting of the response, so we could just write it in exactly the same way we want it to respond, albeit with a placeholder - which will be explained in this next section.
 
-Now, if that command was ran in a server, anyone on that server can make the bot mention them, saying `It sure is, @Username` anytime they say "Nice Weather". If the command is ran in a direct message with the bot, then the custom reaction can be used on every server the bot is connected to.
+Now, if that command was ran in a server, anyone on that server can make the bot mention them, saying `It sure is, @Username` anytime they say "Nice Weather". If the command is ran in a direct message with the bot, then the expression can be used on every server the bot is connected to.
 
-### Block global Custom Reactions
+### Block global Expressions
 
-If you want to disable a global custom reaction which you do not like, and you do not want to remove it, or you are not the bot owner, you can do so by adding a new Custom Reaction with the same trigger on your server, and set the response to `-`.
+If you want to disable a global expression which you do not like, and you do not want to remove it, or you are not the bot owner, you can do so by adding a new expression with the same trigger on your server, and set the response to `-`.
 
 For example:
-`.acr /o/ -`
+`.exa /o/ -`
 
-Now if you try to trigger `/o/`, it won't print anything even if there is a global custom reaction with the same name.
+Now if you try to trigger `/o/`, it won't print anything even if there is a global expression with the same name.
 
 ### Placeholders!
 

docs/donate.md

@@ -10,7 +10,7 @@ Donating to us also gives you the following benefits:
 - A hoisted **Donators role** in our [Discord server][discord-server]
 - Access to exclusive **#noticed** text and voice channels
 - **1000 flowers** on the public bot per dollar donated (after fees)
-- **Custom Reactions** on the public bot for [Patreon pledges][patreon] of $5 or higher
+- **Expressions** on the public bot for [Patreon pledges][patreon] of $5 or higher
 
 ## Patreon
 

docs/guides/docker-guide.md

@@ -1,18 +1,25 @@
 # Setting up NadekoBot with Docker
 
-# DO NOT USE YET - WORK IN PROGRESS
+# WORK IN PROGRESS
 
-### Docker Compose 
+### Installation
+
+1. Create a `/srv/nadeko` folder 
+  - `mkdir -p /srv/nadeko`
+2. Create a `docker-compose.yml`
+  - nano `docker-compose.yml`
+  - copy the following contents into it:
+##### docker-compose.yml 
 ```yml
 version: "3.7"
 services:
   nadeko:
-    image: registry.gitlab.com/veovis/nadekobot:v3-docker
+    image: registry.gitlab.com/kwoth/nadekobot:latest
     depends_on:
       - redis
     environment:
       TZ: Europe/Paris
-      #NadekoBot_RedisOptions: redis,name=nadeko
+      NadekoBot_RedisOptions: redis,name=nadeko
       #NadekoBot_ShardRunCommand: dotnet
       #NadekoBot_ShardRunArguments: /app/NadekoBot.dll {0} {1}
     volumes:
@@ -27,6 +34,12 @@ services:
     volumes:
       - /srv/nadeko/redis-data:/data
 ```
+3. Save your file and run docker compose
+  - `docker-compose up`  
+4. Edit creds in `/srv/nadeko/conf/creds.yml`
+5. Run it again with
+  - `docker-compose up`
+
 ### Updating
 - `cd /srv/nadeko`
 - `docker-compose pull`

docs/guides/linux-guide.md

@@ -17,7 +17,7 @@ It is recommended that you use **Ubuntu 20.04**, as there have been nearly no pr
 
 ##### Compatible operating systems:
 
-- Ubuntu: 16.04, 18.04, 20.04, 21.04, 21.10
+- Ubuntu: 16.04, 18.04, 20.04, 21.04, 21.10 22.04
 - Mint: 19, 20
 - Debian: 9, 10
 - CentOS: 7
@@ -26,14 +26,24 @@ It is recommended that you use **Ubuntu 20.04**, as there have been nearly no pr
 
 ## Linux From Source 
 
-Open Terminal (if you're on an installation with a window manager) and navigate to the location where you want to install the bot (for example `cd ~`) 
+##### Migration from v3 -> v4
+
+Follow the following few steps only if you're migrating from v3. If not, skip to installation instructions.
+
+Use the new installer script:  `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
+> - Install prerequisites (type `1` and press `enter`)
+> - Download (type `2` and press `enter`)
+> - Run (type `3` and press `enter`)
+> - Done
 
 ##### Installation Instructions
 
-1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+Open Terminal (if you're on an installation with a window manager) and navigate to the location where you want to install the bot (for example `cd ~`) 
+
+1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 2. Install prerequisites (type `1` and press enter)
 3. Download the bot (type `2` and press enter)
-4. Exit the installer (type `5` and press enter)
+4. Exit the installer (type `6` and press enter)
 5. Copy the creds.yml template `cp nadekobot/output/creds_example.yml nadekobot/output/creds.yml` 
 6. Open `nadekobot/output/creds.yml` with your favorite text editor. We will use nano here
     - `nano nadekobot/output/creds.yml`
@@ -42,19 +52,31 @@ Open Terminal (if you're on an installation with a window manager) and navigate
        - `CTRL` + `X`
        - `Y`
        - `Enter`
-8. Run the bot (type `3` and press enter)
+8. Run the installer script again `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
+9. Run the bot (type `3` and press enter)
 
 ##### Source Update Instructions
 
 1. ⚠ Stop the bot ⚠
-2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 3. Update the bot (type `2` and press enter)
 4. Run the bot (type `3` and press enter)
 5. 🎉 
 
+## **⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠** 
+
 ## Linux Release
 
-**⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠** 
+###### Prerequisites
+
+1. Nadeko requires redis to function
+    - ubuntu installation command: `sudo apt-get install redis-server`
+2. Playing music requires `ffmpeg`, `libopus`, `libsodium` and `youtube-dl` (which in turn requires python3)
+    - ubuntu installation command: `sudo apt-get install ffmpeg libopus0 opus-tools libopus-dev libsodium-dev -y`
+3. Make sure your python is version 3+ with `python --version`
+    - if it's not, you can install python 3 and make it the default with: `sudo apt-get install python3.8 python-is-python3`
+
+*You can use nadeko bash script [prerequisites installer](https://gitlab.com/Kwoth/nadeko-bash-installer/-/blob/v4/n-prereq.sh) as a reference*
 
 ##### Installation Instructions
 
@@ -130,10 +152,16 @@ While there are two run modes built into the installer, these options only run N
 
 Using `tmux` is the simplest method, and is therefore recommended for most users.
 
-1. Start a tmux session:
-    - `tmux`
+**Before proceeding, make sure your bot is not running by either running `.die` in your Discord server or exiting the process with `Ctrl+C`.**
+
+If you are presented with the installer main menu, exit it by choosing Option `8`.
+
+1. Create a new session: `tmux new -s nadeko`
+
+The above command will create a new session named **nadeko** *(you can replace “nadeko” with anything you prefer, it's your session name)*.
+
 2. Navigate to the project's root directory
-    - Project root directory location example: `/home/user/nadekobot/`
+    - Project root directory location example: `cd /home/user/nadekobot/`
 3. Enter the `output` directory:
     - `cd output`
 4. Run the bot using:
@@ -141,8 +169,10 @@ Using `tmux` is the simplest method, and is therefore recommended for most users
 5. Detatch the tmux session:
     - Press `Ctrl` + `B`
     - Then press `D`
+Now check your Discord server, the bot should be online. Nadeko should now be running in the background of your system. 
+
+To re-open the tmux session to either update, restart, or whatever, execute `tmux a -t nadeko`. *(Make sure to replace "nadeko" with your session name. If you didn't change it, leave it as it.)*
 
-Nadeko should now be running in the background of your system. To re-open the tmux session to either update, restart, or whatever, execute `tmux a`.
 
 ### Systemd
 

docs/guides/osx-guide.md

@@ -31,7 +31,7 @@ sudo ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/
 
 ##### Installation Instructions
 
-1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+1. Download and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 2. Install prerequisites (type `1` and press enter)
 3. Download the bot (type `2` and press enter)
 4. Exit the installer in order to set up your `creds.yml` 
@@ -49,7 +49,7 @@ sudo ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/
 ##### Update Instructions
 
 1. ⚠ Stop the bot
-2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/master/linuxAIO.sh && bash linuxAIO.sh`
+2. Update and run the **new** installer script `cd ~ && wget -N https://gitlab.com/Kwoth/nadeko-bash-installer/-/raw/v4/linuxAIO.sh && bash linuxAIO.sh`
 3. Update the bot (type `2` and press enter)
 4. Run the bot (type `3` and press enter)
 5. 🎉 

docs/guides/windows-guide.md

@@ -63,9 +63,9 @@ You can still install them manually:
 - [ffmpeg-32bit] | [ffmpeg-64bit] - Download the **appropriate version** for your system (32 bit if you're running a 32 bit OS, or 64 if you're running a 64bit OS). Unzip it, and move `ffmpeg.exe` to a path that's in your PATH environment variable. If you don't know what that is, then just move the `ffmpeg.exe` file to NadekoBot/system
 - [youtube-dl] - Click to download the file. Then put `youtube-dl.exe` in a path that's in your PATH environment variable. If you don't know what that is, then just move the `youtube-dl.exe` file to NadekoBot/system
 
-### Windows From Source
+## **⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠**
 
-⚠ IF YOU ARE FOLLOWING THE GUIDE ABOVE, IGNORE THIS SECTION ⚠ 
+### Windows From Source
 
 ##### Prerequisites
 

docs/index.md

@@ -17,8 +17,6 @@ To self-host your own Nadeko, use the guides below:
 - [:material-linux: Linux guide][linux-guide]
 - [:material-apple: Mac OS guide][macos-guide]
 
-Alternatively, you may also setup the bot [from source][from-source-guide] if you want to modify the code.
-
 In case you need any help, join our [Discord server][discord-server] where we may provide support.
 
 ---

docs/jsons-explained.md

@@ -24,7 +24,7 @@ This part is completely optional, **however it's necessary for music and a few o
         - Open up `creds.yml` and look for `GoogleAPIKey`, paste your API key after the `:`.
         - It should look like this:
         ```yml
-        GoogleApiKey: AIzaSyDSci1sdlWQOWNVj1vlXxxxxxbk0oWMEzM
+        GoogleApiKey: 'AIzaSyDSci1sdlWQOWNVj1vlXxxxxxbk0oWMEzM'
         ```
 - **MashapeKey**
     - Required for Hearthstone cards.
@@ -40,16 +40,19 @@ This part is completely optional, **however it's necessary for music and a few o
     - For Patreon creators only.
 - **PatreonCampaignId**
     - For Patreon creators only. Id of your campaign.
-- **TwitchClientId**
+- **TwitchClientId and TwitchClientSecret**
     - Mandatory for following twitch streams with `.twitch` (or `.stadd` with twitch link)
-    - Go to [apps page](https://dev.twitch.tv/console/apps/create) on twitch and register your application.
+    - Go to [apps page](https://dev.twitch.tv/console) on twitch and register your application.
     - You need 2FA enabled on twitch in order to create an application
     - You can set `http://localhost` as the OAuth Redirect URL (and press Add button)
     - Select `Chat Bot` from the Category dropdown
-    - Once created, clicking on your application will show a new Client ID field
-    - Copy it to your creds.yml as shown below
+    - Once created, `click Manage`
+    - Click `New Secret` and select `OK` in the popup
+      **Note: You will need to generate a new Client Secret everytime you exit the page**
+    - Copy both to your creds.yml as shown below
     ```yml
-        TwitchClientId: "516tr61tr1qweqwe86trg3g"
+        twitchClientId: 516tr61tr1qweqwe86trg3g
+        twitchClientSecret: 16tr61tr1q86tweqwe
     ```
 - **LocationIqApiKey**
     - Optional. Used only for the `.time` command. https://locationiq.com api key (register and you will receive the token in the email). 
@@ -94,7 +97,7 @@ RestartCommand:
 
 ```yml
 # DO NOT CHANGE
-version: 1
+version: 4
 # Bot token. Do not share with anyone ever -> https://discordapp.com/developers/applications/
 token: 'MTE5Nzc3MDIxMzE5NTc3NjEw.VlhNCw.BuqJFyzdIUAK1PRf1eK1Cu89Jew'
 # List of Ids of the users who have bot owner permissions
@@ -153,6 +156,13 @@ timezoneDbApiKey:
 coinmarketcapApiKey: 
 # Api key used for Osu related commands. Obtain this key at https://osu.ppy.sh/p/api
 osuApiKey: 4c8c8fdffdsfdsfsdfsfa33f3f3140a7d93320d6
+# Optional Trovo client id.
+# You should use this if Trovo stream notifications stopped working or you're getting ratelimit errors.
+trovoClientId: 
+# Obtain by creating an application at https://dev.twitch.tv/console/apps
+twitchClientId: jf2w6kkyrlzfl6mp1b4k25h4jr6b2o
+# Obtain by creating an application at https://dev.twitch.tv/console/apps
+twitchClientSecret: 16tr61tr1q86tweqwe
 # Command and args which will be used to restart the bot.
 # Only used if bot is executed directly (NOT through the coordinator)
 # placeholders: 

docs/medusa/creating-a-medusa.md

@@ -0,0 +1,251 @@
+# Creating A Medusa
+
+## Theory
+
+### Introduction
+
+Medusa system allows you to write independent medusae (known as "modules", "cogs" or "plugins" in other software) which you can then load, unload and update at will without restarting the bot.  
+  
+The system itself borrows some design from the current way Nadeko's Modules are written but mostly from never-released `Ayu.Commands` system which was designed to be used for a full Nadeko v3 rewrite. 
+
+The medusa base classes used for development are open source [here](https://gitlab.com/Kwoth/nadekobot/-/tree/v4/src/Nadeko.Medusa) in case you need reference, as there is no generated documentation at the moment.
+
+### Term list
+
+#### Medusa
+
+- The project itself which compiles to a single `.dll` (and some optional auxiliary files), it can contain multiple [Sneks](#snek), [Services](#service), and [ParamParsers](#param-parser)  
+
+#### Snek
+
+- A class which will be added as a single Module to NadekoBot on load. It also acts as a [lifecycle handler](snek-lifecycle.md) and as a singleton service with the support for initialize and cleanup.
+- It can contain a Snek (called SubSnek) but only 1 level of nesting is supported (you can only have a snek contain a subsnek, but a subsnek can't contain any other sneks)
+- Sneks can have their own prefix
+    - For example if you set this to 'test' then a command called 'cmd' will have to be invoked by using `.test cmd` instead of `.cmd` 
+
+#### Snek Command
+
+- Acts as a normal command
+- Has context injected as a first argument which controls where the command can be executed
+    - `AnyContext` the command can be executed in both DMs and Servers
+    - `GuildContext` the command can only be executed in Servers
+    - `DmContext` the command can only be executed in DMs
+- Support the usual features such as default values, leftover, params, etc.
+- It also supports dependency injection via `[inject]` attribute. These dependencies must come after the context and before any input parameters
+- Supports `ValueTask`, `Task`, `Task<T>` and `void` return types
+
+#### Param Parser
+
+- Allows custom parsing of command arguments into your own types.
+- Overriding existing parsers (for example for IGuildUser, etc...) can cause issues.
+
+#### Service
+
+- Usually not needed.
+- They are marked with a `[svc]` attribute, and offer a way to inject dependencies to different parts of your medusa. 
+- Transient and Singleton lifetimes are supported.
+
+### Localization
+
+Response and command strings can be kept in one of three different places based on whether you plan to allow support for localization
+
+option 1) `res.yml` and `cmds.yml`  
+
+If you don't plan on having your app localized, but you just *may* in the future, you should keep your strings in the `res.yml` and `cmds.yml` file the root folder of your project, and they will be automatically copied to the output whenever you build your medusa.
+
+##### Example project folder structure:
+    - uwu/
+        - uwu.csproj
+        - uwu.cs
+        - res.yml
+        - cmds.yml  
+
+##### Example output folder structure:
+    - medusae/uwu/  
+        - uwu.dll  
+        - res.yml  
+        - cmds.yml
+
+option 2) `strings` folder  
+
+If you plan on having your app localized (or want to allow your consumers to easily add languages themselves), you should keep your response strings in the `strings/res/en-us.yml` and your command strings in `strings/cmds/en-us.yml` file. This will be your base file, and from there you can make support for additional languages, for example `strings/res/ru-ru.yml` and `strings/cmds/ru-ru.yml`
+
+##### Example project folder structure:
+    - uwu/
+        - uwu.csproj
+        - uwu.cs
+        - strings/
+            - res/
+                - en-us.yml
+                - ru-ru.yml
+            - cmds/
+                - en-us.yml
+                - ru-ru.yml
+
+##### Example output folder structure:
+    - medusae/uwu/
+        - uwu.dll
+        - strings/
+            - res/
+                - en-us.yml
+                - ru-ru.yml
+            - cmds/
+                - en-us.yml
+                - ru-ru.yml
+
+option 3) In the code  
+
+If you don't want any auxiliary files, and you don't want to bother making new .yml files to keep your strings in, you can specify the command strings directly in the `[cmd]` attribute itself, and use non-localized methods for message sending in your commands.
+
+If you update your response strings .yml file(s) while the medusa is loaded and running, running `.stringsreload` will reload the responses without the need to reload the medusa or restart the bot.
+
+#### Config
+
+- Medusa config is kept in `medusae/medusa.yml` file
+- At the moment this config only keeps track of which medusae are currently loaded (they will also be always loaded at startup)
+- If a medusa is causing issues and you're unable to unload it, you can remove it from the `loaded:` list in this config file and restart the bot. It won't be loaded next time the bot is started up
+
+#### Unloadability issues  
+
+To make sure your medusa can be properly unloaded/reloaded you must:
+
+-  Make sure that none of your types and objects are referenced by the Bot or Bot's services after the DisposeAsync is called on your Snek instances. 
+
+- Make sure that all of your commands execute quickly and don't have any long running tasks, as they will hold a reference to a type from your assembly
+
+- If you are still having issues, you can always run `.meunload` followed by a bot restart, or if you want to find what is causing the medusa unloadability issues, you can check the [microsoft's assembly unloadability debugging guide](https://docs.microsoft.com/en-us/dotnet/standard/assembly/unloadability)
+
+## Practice
+
+This section will guide you through how to create a simple custom medusa. You can find the entirety of this code hosted [here](https://gitlab.com/nadeko/example_medusa)
+
+#### Prerequisite
+- [.net6 sdk](https://dotnet.microsoft.com/en-us/download) installed
+- Optional: use [vscode](https://code.visualstudio.com/download) to write code
+
+#### Guide
+
+
+- Open your favorite terminal and navigate to a folder where you will keep your project .
+
+- Create a new folder 
+    - `mkdir example_medusa`
+- Create a new .net class library
+    - `dotnet new classlib`
+- Open the current folder with your favorite editor/IDE. In this case we'll use VsCode
+    - `code .`
+- Remove the `Class1.cs` file
+- Replace the contents of the `.csproj` file with the following contents
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        
+        <!-- Reduces some boilerplate in your .cs files -->
+        <ImplicitUsings>enable</ImplicitUsings>
+        
+        <!-- Use latest .net features -->
+        <LangVersion>preview</LangVersion>
+        <EnablePreviewFeatures>true</EnablePreviewFeatures>
+        
+        <!-- tell .net that this library will be used as a plugin -->
+        <EnableDynamicLoading>true</EnableDynamicLoading>
+    </PropertyGroup>
+    
+    <ItemGroup>
+        <!-- Base medusa package. You MUST reference this in order to have a working medusa -->
+        <!-- Also, this package comes from MyGet, which requires you to have a NuGet.Config file next to your .csproj -->
+        <PackageReference Include="Nadeko.Medusa" Version="1.0.1">
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+
+        <!-- Note: If you want to use NadekoBot services etc... You will have to manually clone 
+          the gitlab.com/kwoth/nadekobot repo locally and reference the NadekoBot.csproj because there is no NadekoBot package atm.
+          It is strongly recommended that you checkout a specific tag which matches your version of nadeko,
+          as there could be breaking changes even between minor versions of NadekoBot.
+          For example if you're running NadekoBot 4.1.0 locally for which you want to create a medusa for,
+          you should do "git checkout 4.1.0" in your NadekoBot solution and then reference the NadekoBot.csproj
+        -->
+    </ItemGroup>
+    
+    <!-- Copy shortcut and full strings to output (if they exist) -->
+    <ItemGroup>
+        <None Update="res.yml;cmds.yml;strings/**">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
+    </ItemGroup>
+</Project>
+
+```
+- Create a `MySnek.cs` file and add the following contents
+```cs
+using Nadeko.Snake;
+using NadekoBot;
+using Discord;
+
+public sealed class MySnek : Snek
+{
+    [cmd]
+    public async Task Hello(AnyContext ctx)
+    {
+        await ctx.Channel.SendMessageAsync($"Hello everyone!");
+    }
+
+    [cmd]
+    public async Task Hello(AnyContext ctx, IUser target)
+    {
+        await ctx.ConfirmLocalizedAsync("hello", target);
+    }
+}
+```
+- Create `res.yml` and `cmds.yml` files with the following contents
+`res.yml`
+```yml
+medusa.description: "This is my medusa's description"
+hello: "Hello {0}, from res.yml!"
+```
+
+`cmds.yml`
+```yml
+hello: 
+  desc: "This is a basic hello command"
+  args:
+    - ""
+    - "@Someone"
+```
+
+- Add `NuGet.Config` file which will let you use the base Nadeko.Medusa package. This file should always look like this and you shouldn't change it
+
+```xml
+<configuration>
+    <packageSources>
+        <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+        <add key="nadeko.bot" value="https://www.myget.org/F/nadeko/api/v3/index.json" protocolVersion="3" />
+    </packageSources>
+</configuration>
+```
+
+### Build it
+
+- Build your Medusa into a dll that Nadeko can load. In your terminal, type:
+    - `dotnet publish -o bin/medusae/example_medusa /p:DebugType=embedded`
+
+- Done. You can now try it out in action.
+
+### Try it out
+
+- Copy the `bin/medusae/example_medusa` folder into your NadekoBot's `data/medusae/` folder. (Nadeko version 4.1.0+)
+
+- Load it with `.meload example_medusa`
+
+- In the channel your bot can see, run the following commands to try it out
+    - `.hello` and
+    - `.hello @<someone>`
+
+- Check its information with
+    - `.meinfo example_medusa`
+
+- Unload it
+    - `.meunload example_medusa`
+
+- Congrats! You've just made your first medusa!

docs/medusa/getting-started.md

@@ -0,0 +1,31 @@
+## Getting Started
+
+### What is the Medusa system?
+
+- It is a dynamic module/plugin/cog system for NadekoBot introduced in **NadekoBot 4.1.0**  
+
+- Allows developers to add custom functionality to Nadeko without modifying the original code  
+
+- Allows for those custom features to be updated during bot runtime (if properly written), without the need for bot restart.
+
+- They are added to `data/medusae` folder and are loaded, unloaded and handled through discord commands.  
+    - `.meload` Loads the specified medusa (see `.h .meload`)
+    - `.meunload` Unloads the specified medusa (see `.h .meunload`)
+    - `.meinfo` Checks medusae information (see `.h .meinfo`)
+    - `.melist` Lists the available medusae (see `.h .melist`)
+
+### How to make one?
+
+Medusae are written in [C#](https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/) programming language, so you will need at least low-intermediate knowledge of it in order to make a useful Medusa.
+
+Follow the [creating a medusa guide](creating-a-medusa.md)
+
+### Where to get medusae other people made?
+
+⚠ *It is EXTREMELY, and I repeat **EXTREMELY** dangerous to run medusae of strangers or people you don't FULLY trust.* ⚠  
+⚠ *It can not only lead to your bot being stolen, but it also puts your entire computer and personal files in jeopardy.* ⚠
+
+**It is strongly recommended to run only the medusae you yourself wrote, and only on a hosted VPS or dedicated server which ONLY hosts your bot, to minimize the potential damage caused by bad actors.**
+
+No easy way at the moment, except asking in the `#dev-and-modding` chat in [#NadekoLog server](https://discord.nadeko.bot)
+

docs/medusa/snek-lifecycle.md

@@ -0,0 +1,19 @@
+# Snek Lifecycle  
+
+*You can override several methods to hook into command handler's lifecycle.  
+These methods start with `Exec*`*
+
+
+- `ExecOnMessageAsync` runs first right after any message was received  
+- `ExecInputTransformAsync` runs after ExecOnMessageAsync and allows you to transform the message content before the bot looks for the matching command  
+- `ExecPreCommandAsync` runs after a command was found but not executed, allowing you to potentially prevent command execution  
+- `ExecPostCommandAsync` runs if the command was successfully executed  
+- `ExecOnNoCommandAsync` runs instead of ExecPostCommandAsync if no command was found for a message  
+
+
+*Besides that, sneks have 2 methods with which you can initialize and cleanup your snek*  
+
+
+- `InitializeAsync` Runs when the medusa which contains this snek is being loaded  
+- `DisposeAsync` Runs when the medusa which contains this snek is being unloaded  
+

docs/permissions-system.md

@@ -73,14 +73,14 @@ Say you want to only enable NSFW commands for a specific role, just do the follo
 2. `.rm NSFW enable Lewd`
     - Enables usage of the NSFW module for the Lewd role
 
-#### How do I disable custom reactions from triggering?
+#### How do I disable Expressions from triggering?
 
-If you don't want server or global custom reactions, just block the module that controls their usage:
+If you don't want server or global Expressions, just block the module that controls their usage:
 
-1. `.sm ActualCustomReactions disable`
-    - Disables the ActualCustomReactions module from being used
+1. `.sm ActualExpressions disable`
+    - Disables the ActualExpression module from being used
 
-**Note**: The `ActualCustomReactions` module controls the usage of custom reactions. The `CustomReactions` module controls commands related to custom reactions (such as `.acr`, `.lcr`, `.crca`, etc).
+**Note**: The `Expressions` module controls the usage of Expressions. The `Expressions` module controls commands related to Expressions (such as `.acr`, `.lcr`, `.crca`, etc).
 
 #### I've broken permissions and am stuck, can I reset permissions?
 

docs/placeholders.md

@@ -1,6 +1,6 @@
 # Placeholders
 
-Placeholders are used in Quotes, Custom Reactions, Greet/Bye messages, playing statuses, and a few other places.
+Placeholders are used in Quotes, Expressions, Greet/Bye messages, playing statuses, and a few other places.
 
 They can be used to make the message more user friendly, generate random numbers or pictures, etc.
 
@@ -28,6 +28,8 @@ Some features have their own specific placeholders which are noted in that featu
 - `%server.id%` - Server ID
 - `%server.name%` - Server name
 - `%server.members%` - Member count
+- `%server.boosters%` - Number of users boosting the server
+- `%server.boost_level%` - Server Boost level
 - `%server.time%` - Server time (requires `.timezone` to be set)
 
 ### Channel placeholders
@@ -79,16 +81,14 @@ Some features have their own specific placeholders which are noted in that featu
 
 ### Music placeholders
 
-!!! Note
-    These placeholders will only work in rotating playing statuses.
-
-- `%music.queued%` - Amount of songs currently queued
-- `%music.playing%` - Current song name
+- `%music.queued%` - Number of songs currently queued
+- `%music.playing%` - Current song name (random playing song if bot is playing on multiple servers)
+- `%music.servers%` - Number of servers currently listening to music
 
 ### Miscellaneous placeholders
 
 - `%rngX-Y%` - Returns a random number between X and Y
-- `%target%` - Returns anything the user has written after the trigger (only works on custom reactions)
-- `%img:stuff%` - Returns an `imgur.com` search for "stuff" (only works on custom reactions)
+- `%target%` - Returns anything the user has written after the trigger (only works on Expressions)
+- `%img:stuff%` - Returns an `imgur.com` search for "stuff" (only works on Expressions)
 
 ![img](https://puu.sh/B7mgI.png)

mkdocs.yml

@@ -86,7 +86,9 @@ nav:
         - Custom Reactions: custom-reactions.md
         - Placeholders: placeholders.md
         - Config: config-guide.md
-        - Bot Config: bce-guide.md
+        - Medusa System:
+            - medusa/getting-started.md
+            - medusa/creating-a-medusa.md
+            - medusa/snek-lifecycle.md
     - Contribution Guide: contribution-guide.md
     - Donate: donate.md
-    - License: license.md

src/Nadeko.Medusa/Attributes/FilterAttribute.cs

@@ -0,0 +1,10 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Overridden to implement custom checks which commands have to pass in order to be executed.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true)]
+public abstract class FilterAttribute : Attribute
+{
+    public abstract ValueTask<bool> CheckAsync(AnyContext ctx);
+}

src/Nadeko.Medusa/Attributes/cmdAttribute.cs

@@ -0,0 +1,37 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Marks a method as a snek command
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public class cmdAttribute : Attribute
+{
+    /// <summary>
+    /// Command description. Avoid using, as cmds.yml is preferred
+    /// </summary>
+    public string? desc { get; set; }
+    
+    /// <summary>
+    /// Command args examples. Avoid using, as cmds.yml is preferred
+    /// </summary>
+    public string[]? args { get; set; }
+    
+    /// <summary>
+    /// Command aliases
+    /// </summary>
+    public string[] Aliases { get; }
+
+    public cmdAttribute()
+    {
+        desc = null;
+        args = null;
+        Aliases = Array.Empty<string>();
+    }
+    
+    public cmdAttribute(params string[] aliases)
+    {
+        Aliases = aliases;
+        desc = null;
+        args = null;
+    }
+}

src/Nadeko.Medusa/Attributes/injectAttribute.cs

@@ -0,0 +1,10 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Marks services in command arguments for injection.
+/// The injected services must come after the context and before any input parameters.
+/// </summary>
+public class injectAttribute : Attribute
+{
+    
+}

src/Nadeko.Medusa/Attributes/leftoverAttribute.cs

@@ -0,0 +1,10 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Marks the parameter to take 
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter)]
+public class leftoverAttribute : Attribute
+{
+    
+}

src/Nadeko.Medusa/Attributes/prioAttribute.cs

@@ -0,0 +1,20 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Sets the priority of a command in case there are multiple commands with the same name but different parameters.
+/// Higher value means higher priority.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public class prioAttribute : Attribute
+{
+    public int Priority { get; }
+
+    /// <summary>
+    /// Snek command priority
+    /// </summary>
+    /// <param name="priority">Priority value. The higher the value, the higher the priority</param>
+    public prioAttribute(int priority)
+    {
+        Priority = priority;
+    }
+}

src/Nadeko.Medusa/Attributes/svcAttribute.cs

@@ -0,0 +1,23 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Marks the class as a service which can be used within the same Medusa
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class svcAttribute : Attribute
+{
+    public Lifetime Lifetime { get; }
+    public svcAttribute(Lifetime lifetime)
+    {
+        Lifetime = lifetime;
+    }
+}
+
+/// <summary>
+/// Lifetime for <see cref="svcAttribute"/>
+/// </summary>
+public enum Lifetime
+{
+    Singleton,
+    Transient
+}

src/Nadeko.Medusa/Context/AnyContext.cs

@@ -0,0 +1,47 @@
+using Discord;
+using NadekoBot;
+
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Commands which take this class as a first parameter can be executed in both DMs and Servers 
+/// </summary>
+public abstract class AnyContext
+{
+    /// <summary>
+    /// Channel from the which the command is invoked
+    /// </summary>
+    public abstract IMessageChannel Channel { get; }
+    
+    /// <summary>
+    /// Message which triggered the command
+    /// </summary>
+    public abstract IUserMessage Message { get; }
+    
+    /// <summary>
+    /// The user who invoked the command
+    /// </summary>
+    public abstract IUser User { get; }
+
+    /// <summary>
+    /// Provides access to strings used by this medusa
+    /// </summary>
+    public abstract IMedusaStrings Strings { get; } 
+    
+    /// <summary>
+    /// Gets a formatted localized string using a key and arguments which should be formatted in
+    /// </summary>
+    /// <param name="key">The key of the string as specified in localization files</param>
+    /// <param name="args">Arguments (if any) to format in</param>
+    /// <returns>A formatted localized string</returns>
+    public abstract string GetText(string key, object[]? args = null);
+    
+    /// <summary>
+    /// Creates a context-aware <see cref="IEmbedBuilder"/> instance
+    /// (future feature for guild-based embed colors)
+    /// Any code dealing with embeds should use it for future-proofness
+    /// instead of manually creating embedbuilder instances
+    /// </summary>
+    /// <returns>A context-aware <see cref="IEmbedBuilder"/> instance </returns>
+    public abstract IEmbedBuilder Embed();
+}

src/Nadeko.Medusa/Context/DmContext.cs

@@ -0,0 +1,11 @@
+using Discord;
+
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Commands which take this type as the first parameter can only be executed in DMs
+/// </summary>
+public abstract class DmContext : AnyContext
+{
+    public abstract override IDMChannel Channel { get; }
+}

src/Nadeko.Medusa/Context/GuildContext.cs

@@ -0,0 +1,12 @@
+using Discord;
+
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Commands which take this type as a first parameter can only be executed in a server
+/// </summary>
+public abstract class GuildContext : AnyContext
+{
+   public abstract override ITextChannel Channel { get; }
+   public abstract IGuild Guild { get; }
+}

src/Nadeko.Medusa/EmbedColor.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot;
+
+public enum EmbedColor
+{
+    Ok,
+    Pending,
+    Error
+}

src/Nadeko.Medusa/Extensions/EmbedBuilderExtensions.cs

@@ -0,0 +1,14 @@
+namespace NadekoBot;
+
+public static class EmbedBuilderExtensions
+{
+    public static IEmbedBuilder WithOkColor(this IEmbedBuilder eb)
+        => eb.WithColor(EmbedColor.Ok);
+    
+    public static IEmbedBuilder WithPendingColor(this IEmbedBuilder eb)
+        => eb.WithColor(EmbedColor.Pending);
+    
+    public static IEmbedBuilder WithErrorColor(this IEmbedBuilder eb)
+        => eb.WithColor(EmbedColor.Error);
+    
+}

src/Nadeko.Medusa/Extensions/MedusaExtensions.cs

@@ -0,0 +1,66 @@
+using Discord;
+using Nadeko.Snake;
+
+namespace NadekoBot;
+
+public static class MedusaExtensions
+{
+    public static Task<IUserMessage> EmbedAsync(this IMessageChannel ch, IEmbedBuilder embed, string msg = "")
+        => ch.SendMessageAsync(msg,
+            embed: embed.Build(),
+            options: new()
+            {
+                RetryMode = RetryMode.AlwaysRetry
+            });
+
+    // unlocalized
+    public static Task<IUserMessage> SendConfirmAsync(this IMessageChannel ch, AnyContext ctx, string msg)
+        => ch.EmbedAsync(ctx.Embed().WithOkColor().WithDescription(msg));
+
+    public static Task<IUserMessage> SendPendingAsync(this IMessageChannel ch, AnyContext ctx, string msg)
+        => ch.EmbedAsync(ctx.Embed().WithPendingColor().WithDescription(msg));
+
+    public static Task<IUserMessage> SendErrorAsync(this IMessageChannel ch, AnyContext ctx, string msg)
+        => ch.EmbedAsync(ctx.Embed().WithErrorColor().WithDescription(msg));
+
+    // unlocalized
+    public static Task<IUserMessage> SendConfirmAsync(this AnyContext ctx, string msg)
+        => ctx.Channel.SendConfirmAsync(ctx, msg);
+
+    public static Task<IUserMessage> SendPendingAsync(this AnyContext ctx, string msg)
+        => ctx.Channel.SendPendingAsync(ctx, msg);
+
+    public static Task<IUserMessage> SendErrorAsync(this AnyContext ctx, string msg)
+        => ctx.Channel.SendErrorAsync(ctx, msg);
+
+    // localized
+    public static Task ConfirmAsync(this AnyContext ctx)
+        => ctx.Message.AddReactionAsync(new Emoji("✅"));
+
+    public static Task ErrorAsync(this AnyContext ctx)
+        => ctx.Message.AddReactionAsync(new Emoji("❌"));
+
+    public static Task WarningAsync(this AnyContext ctx)
+        => ctx.Message.AddReactionAsync(new Emoji("⚠️"));
+
+    public static Task WaitAsync(this AnyContext ctx)
+        => ctx.Message.AddReactionAsync(new Emoji("🤔"));
+
+    public static Task<IUserMessage> ErrorLocalizedAsync(this AnyContext ctx, string key, params object[]? args)
+        => ctx.SendErrorAsync(ctx.GetText(key));
+
+    public static Task<IUserMessage> PendingLocalizedAsync(this AnyContext ctx, string key, params object[]? args)
+        => ctx.SendPendingAsync(ctx.GetText(key, args));
+
+    public static Task<IUserMessage> ConfirmLocalizedAsync(this AnyContext ctx, string key, params object[]? args)
+        => ctx.SendConfirmAsync(ctx.GetText(key, args));
+
+    public static Task<IUserMessage> ReplyErrorLocalizedAsync(this AnyContext ctx, string key, params object[]? args)
+        => ctx.SendErrorAsync($"{Format.Bold(ctx.User.ToString())} {ctx.GetText(key)}");
+
+    public static Task<IUserMessage> ReplyPendingLocalizedAsync(this AnyContext ctx, string key, params object[]? args)
+        => ctx.SendPendingAsync($"{Format.Bold(ctx.User.ToString())} {ctx.GetText(key)}");
+
+    public static Task<IUserMessage> ReplyConfirmLocalizedAsync(this AnyContext ctx, string key, params object[]? args)
+        => ctx.SendConfirmAsync($"{Format.Bold(ctx.User.ToString())} {ctx.GetText(key)}");
+}

src/Nadeko.Medusa/IEmbedBuilder.cs

@@ -1,23 +1,17 @@
-#nullable disable
+using Discord;
+
 namespace NadekoBot;
 
 public interface IEmbedBuilder
 {
-    IEmbedBuilder WithDescription(string desc);
-    IEmbedBuilder WithTitle(string title);
+    IEmbedBuilder WithDescription(string? desc);
+    IEmbedBuilder WithTitle(string? title);
     IEmbedBuilder AddField(string title, object value, bool isInline = false);
-    IEmbedBuilder WithFooter(string text, string iconUrl = null);
-    IEmbedBuilder WithAuthor(string name, string iconUrl = null, string url = null);
+    IEmbedBuilder WithFooter(string text, string? iconUrl = null);
+    IEmbedBuilder WithAuthor(string name, string? iconUrl = null, string? url = null);
     IEmbedBuilder WithColor(EmbedColor color);
     Embed Build();
     IEmbedBuilder WithUrl(string url);
     IEmbedBuilder WithImageUrl(string url);
     IEmbedBuilder WithThumbnailUrl(string url);
-}
-
-public enum EmbedColor
-{
-    Ok,
-    Pending,
-    Error
 }

src/Nadeko.Medusa/Nadeko.Medusa.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <LangVersion>preview</LangVersion>
+        <EnablePreviewFeatures>true</EnablePreviewFeatures>
+        <RootNamespace>Nadeko.Snake</RootNamespace>
+        
+        <Authors>The NadekoBot Team</Authors>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Discord.Net.Core" Version="3.6.1" />
+      <PackageReference Include="Serilog" Version="2.11.0" />
+      <PackageReference Include="YamlDotNet" Version="11.2.1" />
+    </ItemGroup>
+
+</Project>

src/Nadeko.Medusa/ParamParser/ParamParser.cs

@@ -0,0 +1,16 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+/// Overridden to implement parsers for custom types 
+/// </summary>
+/// <typeparam name="T">Type into which to parse the input</typeparam>
+public abstract class ParamParser<T>
+{
+    /// <summary>
+    /// Overridden to implement parsing logic
+    /// </summary>
+    /// <param name="ctx">Context</param>
+    /// <param name="input">Input to parse</param>
+    /// <returns>A <see cref="ParseResult{T}"/> with successful or failed status</returns>
+    public abstract ValueTask<ParseResult<T>> TryParseAsync(AnyContext ctx, string input);
+}

src/Nadeko.Medusa/ParamParser/ParseResult.cs

@@ -0,0 +1,48 @@
+namespace Nadeko.Snake;
+
+public readonly struct ParseResult<T>
+{
+    /// <summary>
+    /// Whether the parsing was successful
+    /// </summary>
+    public bool IsSuccess { get; private init; }
+    
+    /// <summary>
+    /// Parsed value. It should only have value if <see cref="IsSuccess"/> is set to true
+    /// </summary>
+    public T? Data { get; private init;  }
+
+    /// <summary>
+    /// Instantiate a **successful** parse result
+    /// </summary>
+    /// <param name="data">Parsed value</param>
+    public ParseResult(T data)
+    {
+        Data = data;
+        IsSuccess = true;
+    }
+    
+
+    /// <summary>
+    /// Create a new <see cref="ParseResult{T}"/> with IsSuccess = false
+    /// </summary>
+    /// <returns>A new <see cref="ParseResult{T}"/></returns>
+    public static ParseResult<T> Fail()
+        => new ParseResult<T>
+        {
+            IsSuccess = false,
+            Data = default,
+        };
+
+    /// <summary>
+    /// Create a new <see cref="ParseResult{T}"/> with IsSuccess = true
+    /// </summary>
+    /// <param name="obj">Value of the parsed object</param>
+    /// <returns>A new <see cref="ParseResult{T}"/></returns>
+    public static ParseResult<T> Success(T obj)
+        => new ParseResult<T>
+        {
+            IsSuccess = true,
+            Data = obj,
+        };
+}

src/Nadeko.Medusa/README.md

@@ -0,0 +1 @@
+This is the library which is the base of any medusa.

src/Nadeko.Medusa/Snek.cs

@@ -0,0 +1,143 @@
+using Discord;
+
+namespace Nadeko.Snake;
+
+/// <summary>
+/// The base class which will be loaded as a module into NadekoBot
+/// Any user-defined snek has to inherit from this class.
+/// Sneks get instantiated ONLY ONCE during the loading,
+/// and any snek commands will be executed on the same instance.
+/// </summary>
+public abstract class Snek : IAsyncDisposable
+{
+    /// <summary>
+    /// Name of the snek. Defaults to the lowercase class name
+    /// </summary>
+    public virtual string Name
+        => GetType().Name.ToLowerInvariant();
+
+    /// <summary>
+    /// The prefix required before the command name. For example
+    /// if you set this to 'test' then a command called 'cmd' will have to be invoked by using
+    /// '.test cmd' instead of `.cmd` 
+    /// </summary>
+    public virtual string Prefix
+        => string.Empty;
+
+    /// <summary>
+    /// Executed once this snek has been instantiated and before any command is executed.
+    /// </summary>
+    /// <returns>A <see cref="ValueTask"/> representing completion</returns>
+    public virtual ValueTask InitializeAsync()
+        => default;
+
+    /// <summary>
+    /// Override to cleanup any resources or references which might hold this snek in memory
+    /// </summary>
+    /// <returns></returns>
+    public virtual ValueTask DisposeAsync()
+        => default;
+
+    /// <summary>
+    /// This method is called right after the message was received by the bot.
+    /// You can use this method to make the bot conditionally ignore some messages and prevent further processing.
+    /// <para>Execution order:</para>
+    /// <para>
+    /// *<see cref="ExecOnMessageAsync"/>* →
+    /// <see cref="ExecInputTransformAsync"/> →
+    /// <see cref="ExecPreCommandAsync"/> →
+    /// <see cref="ExecPostCommandAsync"/> OR <see cref="ExecOnNoCommandAsync"/>
+    /// </para>
+    /// </summary>
+    /// <param name="guild">Guild in which the message was sent</param>
+    /// <param name="msg">Message received by the bot</param>
+    /// <returns>A <see cref="ValueTask"/> representing whether the message should be ignored and not processed further</returns>
+    public virtual ValueTask<bool> ExecOnMessageAsync(IGuild? guild, IUserMessage msg)
+        => default;
+
+    /// <summary>
+    /// Override this method to modify input before the bot searches for any commands matching the input
+    /// Executed after <see cref="ExecOnMessageAsync"/>
+    /// This is useful if you want to reinterpret the message under some conditions
+    /// <para>Execution order:</para>
+    /// <para>
+    /// <see cref="ExecOnMessageAsync"/> →
+    /// *<see cref="ExecInputTransformAsync"/>* →
+    /// <see cref="ExecPreCommandAsync"/> →
+    /// <see cref="ExecPostCommandAsync"/> OR <see cref="ExecOnNoCommandAsync"/>
+    /// </para> 
+    /// </summary>
+    /// <param name="guild">Guild in which the message was sent</param>
+    /// <param name="channel">Channel in which the message was sent</param>
+    /// <param name="user">User who sent the message</param>
+    /// <param name="input">Content of the message</param>
+    /// <returns>A <see cref="ValueTask"/> representing new, potentially modified content</returns>
+    public virtual ValueTask<string?> ExecInputTransformAsync(
+        IGuild? guild,
+        IMessageChannel channel,
+        IUser user,
+        string input
+    )
+        => default;
+
+    /// <summary>
+    /// This method is called after the command was found but not executed,
+    /// and can be used to prevent the command's execution.
+    /// The command information doesn't have to be from this snek as this method
+    /// will be called when *any* command from any module or snek was found.
+    /// You can choose to prevent the execution of the command by returning "true" value.
+    /// <para>Execution order:</para>
+    /// <para>
+    /// <see cref="ExecOnMessageAsync"/> →
+    /// <see cref="ExecInputTransformAsync"/> →
+    /// *<see cref="ExecPreCommandAsync"/>* →
+    /// <see cref="ExecPostCommandAsync"/> OR <see cref="ExecOnNoCommandAsync"/>
+    /// </para>
+    /// </summary>
+    /// <param name="context">Command context</param>
+    /// <param name="moduleName">Name of the snek or module from which the command originates</param>
+    /// <param name="commandName">Name of the command which is about to be executed</param>
+    /// <returns>A <see cref="ValueTask"/> representing whether the execution should be blocked</returns>
+    public virtual ValueTask<bool> ExecPreCommandAsync(
+        AnyContext context,
+        string moduleName,
+        string commandName
+    )
+        => default;
+
+    /// <summary>
+    /// This method is called after the command was succesfully executed.
+    /// If this method was called, then <see cref="ExecOnNoCommandAsync"/> will not be executed
+    /// <para>Execution order:</para>
+    /// <para>
+    /// <see cref="ExecOnMessageAsync"/> →
+    /// <see cref="ExecInputTransformAsync"/> →
+    /// <see cref="ExecPreCommandAsync"/> →
+    /// *<see cref="ExecPostCommandAsync"/>* OR <see cref="ExecOnNoCommandAsync"/>
+    /// </para>
+    /// </summary>
+    /// <returns>A <see cref="ValueTask"/> representing completion</returns>
+    public virtual ValueTask ExecPostCommandAsync(AnyContext ctx, string moduleName, string commandName)
+        => default;
+
+    /// <summary>
+    /// This method is called if no command was found for the input.
+    /// Useful if you want to have games or features which take arbitrary input
+    /// but ignore any messages which were blocked or caused a command execution
+    /// If this method was called, then <see cref="ExecPostCommandAsync"/> will not be executed
+    /// <para>Execution order:</para>
+    /// <para>
+    /// <see cref="ExecOnMessageAsync"/> →
+    /// <see cref="ExecInputTransformAsync"/> →
+    /// <see cref="ExecPreCommandAsync"/> →
+    /// <see cref="ExecPostCommandAsync"/> OR *<see cref="ExecOnNoCommandAsync"/>*
+    /// </para>
+    /// </summary>
+    /// <returns>A <see cref="ValueTask"/> representing completion</returns>
+    public virtual ValueTask ExecOnNoCommandAsync(IGuild? guild, IUserMessage msg)
+        => default;
+}
+
+public readonly struct ExecResponse
+{
+}

src/Nadeko.Medusa/Strings/CommandStrings.cs

@@ -0,0 +1,24 @@
+using YamlDotNet.Serialization;
+
+namespace Nadeko.Snake;
+
+public readonly struct CommandStrings
+{
+    public CommandStrings(string? desc, string[]? args)
+    {
+        Desc = desc;
+        Args = args;
+    }
+
+    [YamlMember(Alias = "desc")]
+    public string? Desc { get; init; }
+    
+    [YamlMember(Alias = "args")]
+    public string[]? Args { get; init; }
+
+    public void Deconstruct(out string? desc, out string[]? args)
+    {
+        desc = Desc;
+        args = Args;
+    }
+}

src/Nadeko.Medusa/Strings/IMedusaStrings.cs

@@ -0,0 +1,15 @@
+using System.Globalization;
+
+namespace Nadeko.Snake;
+
+/// <summary>
+///     Defines methods to retrieve and reload medusa strings
+/// </summary>
+public interface IMedusaStrings
+{
+    // string GetText(string key, ulong? guildId = null, params object[] data);
+    string? GetText(string key, CultureInfo locale, params object[] data);
+    void Reload();
+    CommandStrings GetCommandStrings(string commandName, CultureInfo cultureInfo);
+    string? GetDescription(CultureInfo? locale);
+}

src/Nadeko.Medusa/Strings/IMedusaStringsProvider.cs

@@ -0,0 +1,28 @@
+namespace Nadeko.Snake;
+
+/// <summary>
+///     Implemented by classes which provide localized strings in their own ways
+/// </summary>
+public interface IMedusaStringsProvider
+{
+    /// <summary>
+    ///     Gets localized string
+    /// </summary>
+    /// <param name="localeName">Language name</param>
+    /// <param name="key">String key</param>
+    /// <returns>Localized string</returns>
+    string? GetText(string localeName, string key);
+
+    /// <summary>
+    ///     Reloads string cache
+    /// </summary>
+    void Reload();
+
+    // /// <summary>
+    // ///     Gets command arg examples and description
+    // /// </summary>
+    // /// <param name="localeName">Language name</param>
+    // /// <param name="commandName">Command name</param>
+    // CommandStrings GetCommandStrings(string localeName, string commandName);
+    CommandStrings? GetCommandStrings(string localeName, string commandName);
+}

src/Nadeko.Medusa/Strings/LocalMedusaStringsProvider.cs

@@ -0,0 +1,40 @@
+namespace Nadeko.Snake;
+
+public class LocalMedusaStringsProvider : IMedusaStringsProvider
+{
+    private readonly StringsLoader _source;
+    private IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>> _responseStrings;
+    private IReadOnlyDictionary<string, IReadOnlyDictionary<string, CommandStrings>> _commandStrings;
+
+    public LocalMedusaStringsProvider(StringsLoader source)
+    {
+        _source = source;
+        _responseStrings = _source.GetResponseStrings();
+        _commandStrings = _source.GetCommandStrings();
+    }
+
+    public void Reload()
+    {
+        _responseStrings = _source.GetResponseStrings();
+        _commandStrings = _source.GetCommandStrings();
+    }
+    
+
+    public string? GetText(string localeName, string key)
+    {
+        if (_responseStrings.TryGetValue(localeName.ToLowerInvariant(), out var langStrings)
+            && langStrings.TryGetValue(key.ToLowerInvariant(), out var text))
+            return text;
+
+        return null;
+    }
+
+    public CommandStrings? GetCommandStrings(string localeName, string commandName)
+    {
+        if (_commandStrings.TryGetValue(localeName.ToLowerInvariant(), out var langStrings)
+            && langStrings.TryGetValue(commandName.ToLowerInvariant(), out var strings))
+            return strings;
+    
+        return null;
+    }
+} 

src/Nadeko.Medusa/Strings/MedusaStrings.cs

@@ -0,0 +1,79 @@
+using System.Globalization;
+using Serilog;
+
+namespace Nadeko.Snake;
+
+public class MedusaStrings : IMedusaStrings
+{
+    /// <summary>
+    ///     Used as failsafe in case response key doesn't exist in the selected or default language.
+    /// </summary>
+    private readonly CultureInfo _usCultureInfo = new("en-US");
+    
+    private readonly IMedusaStringsProvider _stringsProvider;
+
+    public MedusaStrings(IMedusaStringsProvider stringsProvider)
+    {
+        _stringsProvider = stringsProvider;
+    }
+
+    private string? GetString(string key, CultureInfo cultureInfo)
+        => _stringsProvider.GetText(cultureInfo.Name, key);
+
+    public string? GetText(string key, CultureInfo cultureInfo)
+        => GetString(key, cultureInfo)
+           ?? GetString(key, _usCultureInfo);
+
+    public string? GetText(string key, CultureInfo cultureInfo, params object[] data)
+    {
+        var text = GetText(key, cultureInfo);
+
+        if (string.IsNullOrWhiteSpace(text))
+            return null;
+        
+        try
+        {
+            return string.Format(text, data);
+        }
+        catch (FormatException)
+        {
+            Log.Warning(" Key '{Key}' is not properly formatted in '{LanguageName}' response strings",
+                key,
+                cultureInfo.Name);
+            
+            return $"⚠️ Response string key '{key}' is not properly formatted. Please report this.\n\n{text}";
+        }
+    }
+    
+    public CommandStrings GetCommandStrings(string commandName, CultureInfo cultureInfo)
+    {
+        var cmdStrings = _stringsProvider.GetCommandStrings(cultureInfo.Name, commandName);
+        if (cmdStrings is null)
+        {
+            if (cultureInfo.Name == _usCultureInfo.Name)
+            {
+                Log.Warning("'{CommandName}' doesn't exist in 'en-US' command strings for one of the medusae",
+                    commandName);
+
+                return new(null, null);
+            }
+
+            Log.Information("Missing '{CommandName}' command strings for the '{LocaleName}' locale",
+                commandName,
+                cultureInfo.Name);
+            
+            return GetCommandStrings(commandName, _usCultureInfo);
+        }
+
+        return cmdStrings.Value;
+    }
+
+    public string? GetDescription(CultureInfo? locale = null)
+        => GetText("medusa.description", locale ?? _usCultureInfo);
+
+    public static MedusaStrings CreateDefault(string basePath)
+        => new MedusaStrings(new LocalMedusaStringsProvider(new(basePath)));
+    
+    public void Reload()
+        => _stringsProvider.Reload();
+}

src/Nadeko.Medusa/Strings/StringsLoader.cs

@@ -0,0 +1,137 @@
+using System.Diagnostics.CodeAnalysis;
+using Serilog;
+using YamlDotNet.Serialization;
+
+namespace Nadeko.Snake;
+
+/// <summary>
+///     Loads strings from the shortcut or localizable path
+/// </summary>
+public class StringsLoader
+{
+    private readonly string _localizableResponsesPath;
+    private readonly string _shortcutResponsesFile;
+    
+    private readonly string _localizableCommandsPath;
+    private readonly string _shortcutCommandsFile;
+
+    public StringsLoader(string basePath)
+    {
+        _localizableResponsesPath = Path.Join(basePath, "strings/res");
+        _shortcutResponsesFile = Path.Join(basePath, "res.yml");
+        
+        _localizableCommandsPath = Path.Join(basePath, "strings/cmds");
+        _shortcutCommandsFile = Path.Join(basePath, "cmds.yml");
+    }
+
+    public IReadOnlyDictionary<string, IReadOnlyDictionary<string, CommandStrings>> GetCommandStrings()
+    {
+        var outputDict = new Dictionary<string, IReadOnlyDictionary<string, CommandStrings>>();
+
+        if (File.Exists(_shortcutCommandsFile))
+        {
+            if (TryLoadCommandsFromFile(_shortcutCommandsFile, out var dict, out _))
+            {
+                outputDict["en-us"] = dict;
+            }
+
+            return outputDict;
+        }
+
+        if (Directory.Exists(_localizableCommandsPath))
+        {
+            foreach (var cmdsFile in Directory.EnumerateFiles(_localizableCommandsPath))
+            {
+                if (TryLoadCommandsFromFile(cmdsFile, out var dict, out var locale) && locale is not null)
+                {
+                    outputDict[locale.ToLowerInvariant()] = dict;
+                }
+            }
+        }
+
+        return outputDict;
+    }
+
+    
+    private static readonly IDeserializer _deserializer = new DeserializerBuilder().Build();
+    private static bool TryLoadCommandsFromFile(string file,
+        [NotNullWhen(true)] out IReadOnlyDictionary<string, CommandStrings>? strings,
+        out string? localeName)
+    {
+        try
+        {
+            var text = File.ReadAllText(file);
+            strings = _deserializer.Deserialize<Dictionary<string, CommandStrings>?>(text)
+                      ?? new();
+            localeName = GetLocaleName(file);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Error loading {FileName} command strings: {ErrorMessage}", file, ex.Message);
+        }
+
+        strings = null;
+        localeName = null;
+        return false;
+    }
+
+
+    public IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>> GetResponseStrings()
+    {
+        var outputDict = new Dictionary<string, IReadOnlyDictionary<string, string>>();
+
+        // try to load a shortcut file
+        if (File.Exists(_shortcutResponsesFile))
+        {
+            if (TryLoadResponsesFromFile(_shortcutResponsesFile, out var dict, out _))
+            {
+                outputDict["en-us"] = dict;
+            }
+
+            return outputDict;
+        }
+
+        if (!Directory.Exists(_localizableResponsesPath))
+            return outputDict;
+        
+        // if shortcut file doesn't exist, try to load localizable files
+        foreach (var file in Directory.GetFiles(_localizableResponsesPath))
+        {
+            if (TryLoadResponsesFromFile(file, out var strings, out var localeName) && localeName is not null)
+            {
+                outputDict[localeName.ToLowerInvariant()] = strings;
+            }
+        }
+
+        return outputDict;
+    }
+
+    private static bool TryLoadResponsesFromFile(string file,
+        [NotNullWhen(true)] out IReadOnlyDictionary<string, string>? strings,
+        out string? localeName)
+    {
+        try
+        {
+            strings = _deserializer.Deserialize<Dictionary<string, string>?>(File.ReadAllText(file));
+            if (strings is null)
+            {
+                localeName = null;
+                return false;
+            }
+
+            localeName = GetLocaleName(file).ToLowerInvariant();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Error loading {FileName} response strings: {ErrorMessage}", file, ex.Message);
+            strings = null;
+            localeName = null;
+            return false;
+        }
+    }
+
+    private static string GetLocaleName(string fileName)
+        => Path.GetFileNameWithoutExtension(fileName);
+}

src/Nadeko.Medusa/pack-and-push.ps1

@@ -0,0 +1,2 @@
+dotnet pack -o bin/Release/packed
+dotnet nuget push bin/Release/packed/ --api-key $env:nadeko_myget_api_key --source https://www.myget.org/F/nadeko/api/v2/package

src/NadekoBot.Coordinator/LogSetup.cs

@@ -15,6 +15,9 @@ namespace NadekoBot.Services
                 .MinimumLevel.Override("System", LogEventLevel.Information)
                 .MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning)
                 .Enrich.FromLogContext()
+                .WriteTo.File("coord.log", LogEventLevel.Information, 
+                    rollOnFileSizeLimit: true,
+                    fileSizeLimitBytes: 10_000_000)
                 .WriteTo.Console(LogEventLevel.Information,
                     theme: GetTheme(),
                     outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] | #{LogSource} | {Message:lj}{NewLine}{Exception}")

src/NadekoBot.Coordinator/NadekoBot.Coordinator.csproj

@@ -9,9 +9,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore" Version="2.42.0" />
-    <PackageReference Include="Serilog" Version="2.10.0" />
+    <PackageReference Include="Grpc.AspNetCore" Version="2.45.0" />
+    <PackageReference Include="Serilog" Version="2.11.0" />
     <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
+    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
     <PackageReference Include="YamlDotNet" Version="11.2.1" />
   </ItemGroup>
   

src/NadekoBot.Coordinator/Services/CoordinatorRunner.cs

@@ -114,14 +114,6 @@ namespace NadekoBot.Coordinator
                                 StartShard(shardId);
                                 break;
                             }
-
-                            if (status.Process is null or {HasExited: true})
-                            {
-                                Log.Warning("Shard {ShardId} is starting (process)...", shardId);
-                                hadAction = true;
-                                StartShard(shardId);
-                                break;
-                            }
                             
                             if (DateTime.UtcNow - status.LastUpdate >
                                 TimeSpan.FromSeconds(_config.UnresponsiveSec))
@@ -139,6 +131,24 @@ namespace NadekoBot.Coordinator
                                 StartShard(shardId);
                                 break;
                             }
+
+                            try
+                            {
+                                if (status.Process is null or { HasExited: true })
+                                {
+                                    Log.Warning("Shard {ShardId} is starting (process)...", shardId);
+                                    hadAction = true;
+                                    StartShard(shardId);
+                                    break;
+                                }
+                            }
+                            catch (InvalidOperationException)
+                            {
+                                Log.Warning("Process for shard {ShardId} is bugged... ", shardId);
+                                hadAction = true;
+                                StartShard(shardId);
+                                break;
+                            }
                         }
                     }
 
@@ -161,17 +171,13 @@ namespace NadekoBot.Coordinator
             var status = _shardStatuses[shardId];
             try
             {
-                if (status.Process is { HasExited: false } p)
-                {
-                    try
-                    {
-                        p.Kill(true);
-                    }
-                    catch
-                    {
-                    }
-                }
-
+                status.Process?.Kill(true);
+            }
+            catch
+            {
+            }
+            try
+            {
                 status.Process?.Dispose();
             }
             catch
@@ -280,10 +286,10 @@ namespace NadekoBot.Coordinator
                 for (var shardId = 0; shardId < _shardStatuses.Length; shardId++)
                 {
                     var status = _shardStatuses[shardId];
-                    if (status.Process is { } p)
+                    if (status.Process is Process p)
                     {
-                        p.Kill();
-                        p.Dispose();
+                        try{p.Kill();} catch {}
+                        try{p.Dispose();} catch {}
                         _shardStatuses[shardId] = status with
                         {
                             Process = null,

src/NadekoBot.Generators/Command/CommandAttributesGenerator.cs

@@ -64,7 +64,9 @@ public class CmdAttribute : System.Attribute
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
 // #if DEBUG
-//         SpinWait.SpinUntil(() => Debugger.IsAttached);
+//         if (!Debugger.IsAttached)
+//             Debugger.Launch();
+//         // SpinWait.SpinUntil(() => Debugger.IsAttached);
 // #endif
         context.RegisterPostInitializationOutput(static ctx => ctx.AddSource(
             "CmdAttribute.g.cs",
@@ -97,13 +99,12 @@ public class CmdAttribute : System.Attribute
             var name = $"{model.Namespace}.{string.Join(".", model.ClassHierarchy)}.g.cs";
             try
             {
-                Debug.WriteLine($"Writing {name}");
                 var source = GetSourceText(model);
                 ctx.AddSource(name, SourceText.From(source, Encoding.UTF8));
             }
             catch (Exception ex)
             {
-                Debug.WriteLine($"Error writing source file {name}\n" + ex);
+                Console.WriteLine($"Error writing source file {name}\n" + ex);
             }
         }
     }
@@ -158,7 +159,9 @@ public class CmdAttribute : System.Attribute
             .Distinct();
         
         var methodModels = methods
-            .Select(x => MethodDeclarationToMethodModel(compilation, x!));
+            .Select(x => MethodDeclarationToMethodModel(compilation, x!))
+            .Where(static x => x is not null)
+            .Cast<MethodModel>();
 
         var groups = methodModels
             .GroupBy(static x => $"{x.Namespace}.{string.Join(".", x.Classes)}");
@@ -178,7 +181,7 @@ public class CmdAttribute : System.Attribute
             var model = new FileModel(
                 methods: elems,
                 ns: elems[0].Namespace,
-                classHierarchy: elems[0].Classes
+                classHierarchy: elems![0].Classes
             );
             
             models.Add(model);
@@ -188,11 +191,21 @@ public class CmdAttribute : System.Attribute
         return models;
     }
 
-    private static MethodModel MethodDeclarationToMethodModel(Compilation comp, MethodDeclarationSyntax decl)
+    private static MethodModel? MethodDeclarationToMethodModel(Compilation comp, MethodDeclarationSyntax decl)
     {
         // SpinWait.SpinUntil(static () => Debugger.IsAttached);
 
-        var semanticModel = comp.GetSemanticModel(decl.SyntaxTree);
+        SemanticModel semanticModel;
+        try
+        {
+            semanticModel = comp.GetSemanticModel(decl.SyntaxTree);
+        }
+        catch
+        {
+            // for some reason this method can throw "Not part of this compilation" argument exception
+            return null;
+        }
+
         var methodModel = new MethodModel(
             @params: decl.ParameterList.Parameters
                 .Where(p => p.Type is not null)

src/NadekoBot.Generators/LocalizedStringsGenerator.cs

@@ -62,6 +62,7 @@ namespace NadekoBot.Generators
                 sw.WriteLine("{");
                 sw.Indent++;
 
+                var typedParamStrings = new List<string>(10);
                 foreach (var field in fields)
                 {
                     var matches = Regex.Matches(field.Value, @"{(?<num>\d)[}:]");
@@ -71,20 +72,30 @@ namespace NadekoBot.Generators
                         max = Math.Max(max, int.Parse(match.Groups["num"].Value) + 1);
                     }
 
-                    List<string> typedParamStrings = new List<string>();
-                    var paramStrings = string.Empty;
+                    typedParamStrings.Clear();
+                    var typeParams = new string[max];
+                    var passedParamString = string.Empty;
                     for (var i = 0; i < max; i++)
                     {
-                        typedParamStrings.Add($"object p{i}");
-                        paramStrings += $", p{i}";
+                        typedParamStrings.Add($"in T{i} p{i}");
+                        passedParamString += $", p{i}";
+                        typeParams[i] = $"T{i}";
                     }
 
-
                     var sig = string.Empty;
-                    if(max > 0)
+                    var typeParamStr = string.Empty;
+                    if (max > 0)
+                    {
                         sig = $"({string.Join(", ", typedParamStrings)})";
-                    
-                    sw.WriteLine($"public static LocStr {field.Name}{sig} => new LocStr(\"{field.Name}\"{paramStrings});");
+                        typeParamStr = $"<{string.Join(", ", typeParams)}>";
+                    }
+
+                    sw.WriteLine("public static LocStr {0}{1}{2} => new LocStr(\"{3}\"{4});",
+                        field.Name,
+                        typeParamStr,
+                        sig,
+                        field.Name,
+                        passedParamString);
                 }
 
                 sw.Indent--;

src/NadekoBot.Tests/BotStringsTests.cs

@@ -21,7 +21,7 @@ namespace NadekoBot.Tests
             var stringsSource = new LocalFileStringsSource(
                 responsesPath,
                 commandsPath);
-            var strings = new LocalBotStringsProvider(stringsSource);
+            var strings = new MemoryBotStringsProvider(stringsSource);
 
             var culture = new CultureInfo("en-US");
 

src/NadekoBot.Tests/ConcurrentHashSetTests.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace NadekoBot.Tests;
+
+public class ConcurrentHashSetTests
+{
+    private ConcurrentHashSet<(int?, int?)> _set;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _set = new();
+    }
+
+    [Test]
+    public void AddTest()
+    {
+        var result = _set.Add((1, 2));
+        
+        Assert.AreEqual(true, result);
+        
+        result = _set.Add((1, 2));
+        
+        Assert.AreEqual(false, result);
+    }
+
+    [Test]
+    public void TryRemoveTest()
+    {
+        _set.Add((1, 2));
+        var result = _set.TryRemove((1, 2));
+        
+        Assert.AreEqual(true, result);
+        
+        result = _set.TryRemove((1, 2));
+        Assert.AreEqual(false, result);
+    }
+
+    [Test]
+    public void CountTest()
+    {
+        _set.Add((1, 2)); // 1
+        _set.Add((1, 2)); // 1
+        
+        _set.Add((2, 2)); // 2
+        
+        _set.Add((3, 2)); // 3
+        _set.Add((3, 2)); // 3
+        
+        Assert.AreEqual(3, _set.Count);
+    }
+
+    [Test]
+    public void ClearTest()
+    {
+        _set.Add((1, 2));
+        _set.Add((1, 3));
+        _set.Add((1, 4));
+        
+        _set.Clear();
+        
+        Assert.AreEqual(0, _set.Count);
+    }
+
+    [Test]
+    public void ContainsTest()
+    {
+        _set.Add((1, 2));
+        _set.Add((3, 2));
+        
+        Assert.AreEqual(true, _set.Contains((1, 2)));
+        Assert.AreEqual(true, _set.Contains((3, 2)));
+        Assert.AreEqual(false, _set.Contains((2, 1)));
+        Assert.AreEqual(false, _set.Contains((2, 3)));
+    }
+
+    [Test]
+    public void RemoveWhereTest()
+    {
+        _set.Add((1, 2));
+        _set.Add((1, 3));
+        _set.Add((1, 4));
+        _set.Add((2, 5));
+        
+        // remove tuples which have even second item
+        _set.RemoveWhere(static x => x.Item2 % 2 == 0);
+        
+        Assert.AreEqual(2, _set.Count);
+        Assert.AreEqual(true, _set.Contains((1, 3)));
+        Assert.AreEqual(true, _set.Contains((2, 5)));
+    }
+}

src/NadekoBot.Tests/NadekoBot.Tests.csproj

@@ -8,9 +8,9 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="NUnit" Version="3.13.2" />
+        <PackageReference Include="NUnit" Version="3.13.3" />
         <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
     </ItemGroup>
 
     <ItemGroup>

src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj

@@ -7,7 +7,7 @@
 
     <ItemGroup>
         <PackageReference Include="MorseCode.ITask" Version="2.0.3" />
-        <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="6.3.1" />
     </ItemGroup>
 
 </Project>

src/NadekoBot/Bot.cs

@@ -4,9 +4,11 @@ using NadekoBot.Common.Configs;
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Db;
 using NadekoBot.Modules.Administration;
+using NadekoBot.Modules.Utility;
 using NadekoBot.Services.Database.Models;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Net;
 using System.Reflection;
 using RunMode = Discord.Commands.RunMode;
 
@@ -41,10 +43,7 @@ public sealed class Bot
         _credsProvider = new BotCredsProvider(totalShards);
         _creds = _credsProvider.GetCreds();
 
-        _db = new(_creds);
-
-        if (shardId == 0)
-            _db.Setup();
+        _db = new(_credsProvider);
 
         var messageCacheSize =
 #if GLOBAL_NADEKO
@@ -70,12 +69,14 @@ public sealed class Bot
                 ? GatewayIntents.All
                 : GatewayIntents.AllUnprivileged,
             LogGatewayIntentWarnings = false,
+            FormatUsersInBidirectionalUnicode = false,
+            DefaultRetryMode = RetryMode.AlwaysRetry ^ RetryMode.RetryRatelimit
         });
 
         _commandService = new(new()
         {
             CaseSensitiveCommands = false,
-            DefaultRunMode = RunMode.Sync
+            DefaultRunMode = RunMode.Sync,
         });
 
         // _interactionService = new(Client.Rest);
@@ -102,25 +103,23 @@ public sealed class Bot
         var svcs = new ServiceCollection().AddTransient(_ => _credsProvider.GetCreds()) // bot creds
                                           .AddSingleton(_credsProvider)
                                           .AddSingleton(_db) // database
-                                          .AddRedis(_creds.RedisOptions) // redis
                                           .AddSingleton(Client) // discord socket client
                                           .AddSingleton(_commandService)
                                           // .AddSingleton(_interactionService)
                                           .AddSingleton(this)
                                           .AddSingleton<ISeria, JsonSeria>()
-                                          .AddSingleton<IPubSub, RedisPubSub>()
                                           .AddSingleton<IConfigSeria, YamlSeria>()
-                                          .AddBotStringsServices(_creds.TotalShards)
                                           .AddConfigServices()
                                           .AddConfigMigrators()
                                           .AddMemoryCache()
                                           // music
-                                          .AddMusic();
+                                          .AddMusic()
+                                          // cache
+                                          .AddCache(_creds);
+        
         // admin
 #if GLOBAL_NADEKO
         svcs.AddSingleton<ILogCommandService, DummyLogCommandService>();
-#else
-        svcs.AddSingleton<ILogCommandService, LogCommandService>();
 #endif
 
         svcs.AddHttpClient();
@@ -129,6 +128,12 @@ public sealed class Bot
             {
                 AllowAutoRedirect = false
             });
+        
+        svcs.AddHttpClient("google:search")
+            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler()
+            {
+                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
+            });
 
         if (Environment.GetEnvironmentVariable("NADEKOBOT_IS_COORDINATED") != "1")
             svcs.AddSingleton<ICoordinator, SingleProcessCoordinator>();
@@ -139,25 +144,20 @@ public sealed class Bot
                 .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RemoteGrpcCoordinator>());
         }
 
-        svcs.AddSingleton<RedisLocalDataCache>()
-            .AddSingleton<ILocalDataCache>(x => x.GetRequiredService<RedisLocalDataCache>())
-            .AddSingleton<RedisImagesCache>()
-            .AddSingleton<IImageCache>(x => x.GetRequiredService<RedisImagesCache>())
-            .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RedisImagesCache>())
-            .AddSingleton<IDataCache, RedisCache>();
-
         svcs.Scan(scan => scan.FromAssemblyOf<IReadyExecutor>()
                               .AddClasses(classes => classes.AssignableToAny(
                                       // services
                                       typeof(INService),
 
                                       // behaviours
-                                      typeof(IEarlyBehavior),
-                                      typeof(ILateBlocker),
+                                      typeof(IExecOnMessage),
                                       typeof(IInputTransformer),
-                                      typeof(ILateExecutor))
+                                      typeof(IExecPreCommand),
+                                      typeof(IExecPostCommand),
+                                      typeof(IExecNoCommand))
+                                                .WithoutAttribute<DontAddToIocContainerAttribute>()
 #if GLOBAL_NADEKO
-                    .WithoutAttribute<NoPublicBotAttribute>()
+                                                .WithoutAttribute<NoPublicBotAttribute>()
 #endif
                               )
                               .AsSelfWithInterfaces()
@@ -165,8 +165,8 @@ public sealed class Bot
 
         //initialize Services
         Services = svcs.BuildServiceProvider();
-        var exec = Services.GetRequiredService<IBehaviourExecutor>();
-        exec.Initialize();
+        Services.GetRequiredService<IBehaviorHandler>().Initialize();
+        Services.GetRequiredService<CurrencyRewardService>();
 
         if (Client.ShardId == 0)
             ApplyConfigMigrations();
@@ -261,6 +261,7 @@ public sealed class Bot
         Client.JoinedGuild += Client_JoinedGuild;
         Client.LeftGuild += Client_LeftGuild;
 
+        // _ = Client.SetStatusAsync(UserStatus.Online);
         Log.Information("Shard {ShardId} logged in", Client.ShardId);
     }
 
@@ -288,6 +289,9 @@ public sealed class Bot
 
     public async Task RunAsync()
     {
+        if (ShardId == 0)
+            await _db.SetupAsync();
+        
         var sw = Stopwatch.StartNew();
 
         await LoginAsync(_creds.Token);
@@ -358,7 +362,7 @@ How to enable privileged intents:
 1. Head over to the Discord Developer Portal https://discord.com/developers/applications/
 2. Select your Application.
 3. Click on `Bot` in the left side navigation panel, and scroll down to the intents section.
-4. Enable both intents.
+4. Enable all intents.
 5. Restart your bot.
 
 Read this only if your bot is in 100 or more servers:
@@ -366,12 +370,15 @@ Read this only if your bot is in 100 or more servers:
 You'll need to apply to use the intents with Discord, but for small selfhosts, all that is required is enabling the intents in the developer portal.
 Yes, this is a new thing from Discord, as of October 2020. No, there's nothing we can do about it. Yes, we're aware it worked before.
 While waiting for your bot to be accepted, you can change the 'usePrivilegedIntents' inside your creds.yml to 'false', although this will break many of the nadeko's features");
+            return Task.CompletedTask;
         }
-        else if (arg.Exception is not null)
+        
+#if GLOBAL_NADEKO || DEBUG
+        if (arg.Exception is not null)
             Log.Warning(arg.Exception, "{ErrorSource} | {ErrorMessage}", arg.Source, arg.Message);
         else
             Log.Warning("{ErrorSource} | {ErrorMessage}", arg.Source, arg.Message);
-
+#endif
         return Task.CompletedTask;
     }
 

src/NadekoBot/Common/Attributes/DontAddToIocContainerAttribute.cs

@@ -0,0 +1,11 @@
+#nullable disable
+namespace NadekoBot.Common;
+
+/// <summary>
+/// Classed marked with this attribute will not be added to the service provider 
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class DontAddToIocContainerAttribute : Attribute
+{
+    
+}

src/NadekoBot/Common/Attributes/NoPublicBotPrecondition.cs

@@ -18,4 +18,21 @@ public sealed class NoPublicBotAttribute : PreconditionAttribute
         return Task.FromResult(PreconditionResult.FromSuccess());
 #endif
     }
+}
+
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
+[SuppressMessage("Style", "IDE0022:Use expression body for methods")]
+public sealed class OnlyPublicBotAttribute : PreconditionAttribute
+{
+    public override Task<PreconditionResult> CheckPermissionsAsync(
+        ICommandContext context,
+        CommandInfo command,
+        IServiceProvider services)
+    {
+#if GLOBAL_NADEKO || DEBUG
+        return Task.FromResult(PreconditionResult.FromSuccess());
+#else
+        return Task.FromResult(PreconditionResult.FromError("Only available on the public bot."));
+#endif
+    }
 }

src/NadekoBot/Common/Attributes/Ratelimit.cs

@@ -15,22 +15,24 @@ public sealed class RatelimitAttribute : PreconditionAttribute
         Seconds = seconds;
     }
 
-    public override Task<PreconditionResult> CheckPermissionsAsync(
+    public override async Task<PreconditionResult> CheckPermissionsAsync(
         ICommandContext context,
         CommandInfo command,
         IServiceProvider services)
     {
         if (Seconds == 0)
-            return Task.FromResult(PreconditionResult.FromSuccess());
+            return PreconditionResult.FromSuccess();
 
-        var cache = services.GetRequiredService<IDataCache>();
-        var rem = cache.TryAddRatelimit(context.User.Id, command.Name, Seconds);
+        var cache = services.GetRequiredService<IBotCache>();
+        var rem = await cache.GetRatelimitAsync(
+            new($"precondition:{context.User.Id}:{command.Name}"),
+            Seconds.Seconds());
 
         if (rem is null)
-            return Task.FromResult(PreconditionResult.FromSuccess());
+            return PreconditionResult.FromSuccess();
 
         var msgContent = $"You can use this command again in {rem.Value.TotalSeconds:F1}s.";
 
-        return Task.FromResult(PreconditionResult.FromError(msgContent));
+        return PreconditionResult.FromError(msgContent);
     }
 }

src/NadekoBot/Common/Cache/BotCacheExtensions.cs

@@ -0,0 +1,46 @@
+using OneOf;
+using OneOf.Types;
+
+namespace NadekoBot.Common;
+
+public static class BotCacheExtensions
+{
+    public static async ValueTask<T?> GetOrDefaultAsync<T>(this IBotCache cache, TypedKey<T> key)
+    {
+        var result = await cache.GetAsync(key);
+        if (result.TryGetValue(out var val))
+            return val;
+
+        return default;
+    }
+    
+    private static TypedKey<byte[]> GetImgKey(Uri uri)
+        => new($"image:{uri}");
+
+    public static ValueTask SetImageDataAsync(this IBotCache c, string key, byte[] data)
+        => c.SetImageDataAsync(new Uri(key), data);
+    public static async ValueTask SetImageDataAsync(this IBotCache c, Uri key, byte[] data)
+        => await c.AddAsync(GetImgKey(key), data, expiry: TimeSpan.FromHours(48));
+
+    public static async ValueTask<OneOf<byte[], None>> GetImageDataAsync(this IBotCache c, Uri key)
+        => await c.GetAsync(GetImgKey(key));
+
+    public static async Task<TimeSpan?> GetRatelimitAsync(
+        this IBotCache c,
+        TypedKey<long> key,
+        TimeSpan length)
+    {
+        var now = DateTime.UtcNow;
+        var nowB = now.ToBinary();
+
+        var cachedValue = await c.GetOrAddAsync(key,
+            () => Task.FromResult(now.ToBinary()),
+            expiry: length);
+
+        if (cachedValue == nowB)
+            return null;
+
+        var diff = now - DateTime.FromBinary(cachedValue);
+        return length - diff;
+    }
+}

src/NadekoBot/Common/Cache/IBotCache.cs

@@ -0,0 +1,47 @@
+using OneOf;
+using OneOf.Types;
+
+namespace NadekoBot.Common;
+
+public interface IBotCache
+{
+    /// <summary>
+    /// Adds an item to the cache
+    /// </summary>
+    /// <param name="key">Key to add</param>
+    /// <param name="value">Value to add to the cache</param>
+    /// <param name="expiry">Optional expiry</param>
+    /// <param name="overwrite">Whether old value should be overwritten</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>Returns whether add was sucessful. Always true unless ovewrite = false</returns>
+    ValueTask<bool> AddAsync<T>(TypedKey<T> key, T value, TimeSpan? expiry = null, bool overwrite = true);
+    
+    /// <summary>
+    /// Get an element from the cache
+    /// </summary>
+    /// <param name="key">Key</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>Either a value or <see cref="None"/></returns>
+    ValueTask<OneOf<T, None>> GetAsync<T>(TypedKey<T> key);
+    
+    /// <summary>
+    /// Remove a key from the cache
+    /// </summary>
+    /// <param name="key">Key to remove</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>Whether there was item</returns>
+    ValueTask<bool> RemoveAsync<T>(TypedKey<T> key);
+
+    /// <summary>
+    /// Get the key if it exists or add a new one
+    /// </summary>
+    /// <param name="key">Key to get and potentially add</param>
+    /// <param name="createFactory">Value creation factory</param>
+    /// <param name="expiry">Optional expiry</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>The retrieved or newly added value</returns>
+    ValueTask<T?> GetOrAddAsync<T>(
+        TypedKey<T> key,
+        Func<Task<T?>> createFactory,
+        TimeSpan? expiry = null);
+}

src/NadekoBot/Common/Cache/MemoryBotCache.cs

@@ -0,0 +1,71 @@
+using Microsoft.Extensions.Caching.Memory;
+using OneOf;
+using OneOf.Types;
+
+// ReSharper disable InconsistentlySynchronizedField
+
+namespace NadekoBot.Common;
+
+public sealed class MemoryBotCache : IBotCache
+{
+    // needed for overwrites and Delete return value
+    private readonly object _cacheLock = new object();
+    private readonly MemoryCache _cache;
+
+    public MemoryBotCache()
+    {
+        _cache = new MemoryCache(new MemoryCacheOptions());
+    }
+
+    public ValueTask<bool> AddAsync<T>(TypedKey<T> key, T value, TimeSpan? expiry = null, bool overwrite = true)
+    {
+        if (overwrite)
+        {
+            using var item = _cache.CreateEntry(key.Key);
+            item.Value = value;
+            item.AbsoluteExpirationRelativeToNow = expiry;
+            return new(true);
+        }
+        
+        lock (_cacheLock)
+        {
+            if (_cache.TryGetValue(key.Key, out var old) && old is not null)
+                return new(false);
+            
+            using var item = _cache.CreateEntry(key.Key);
+            item.Value = value;
+            item.AbsoluteExpirationRelativeToNow = expiry;
+            return new(true);
+        }
+    }
+
+    public async ValueTask<T?> GetOrAddAsync<T>(
+        TypedKey<T> key,
+        Func<Task<T?>> createFactory,
+        TimeSpan? expiry = null)
+        => await _cache.GetOrCreateAsync(key.Key,
+            async ce =>
+            {
+                ce.AbsoluteExpirationRelativeToNow = expiry;
+                var val = await createFactory();
+                return val;
+            });
+
+    public ValueTask<OneOf<T, None>> GetAsync<T>(TypedKey<T> key)
+    {
+        if (!_cache.TryGetValue(key.Key, out var val) || val is null)
+            return new(new None());
+
+        return new((T)val);
+    }
+
+    public ValueTask<bool> RemoveAsync<T>(TypedKey<T> key)
+    {
+        lock (_cacheLock)
+        {
+            var toReturn = _cache.TryGetValue(key.Key, out var old ) && old is not null;
+            _cache.Remove(key.Key);
+            return new(toReturn);
+        }
+    }
+}

src/NadekoBot/Common/Cache/RedisBotCache.cs

@@ -0,0 +1,119 @@
+using OneOf;
+using OneOf.Types;
+using StackExchange.Redis;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NadekoBot.Common;
+
+public sealed class RedisBotCache : IBotCache
+{
+    private static readonly Type[] _supportedTypes = new []
+    {
+        typeof(bool), typeof(int), typeof(uint), typeof(long),
+        typeof(ulong), typeof(float), typeof(double),
+        typeof(string), typeof(byte[]), typeof(ReadOnlyMemory<byte>), typeof(Memory<byte>),
+        typeof(RedisValue),
+    };
+
+    private static readonly JsonSerializerOptions _opts = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        NumberHandling = JsonNumberHandling.AllowReadingFromString,
+        AllowTrailingCommas = true,
+        IgnoreReadOnlyProperties = false,
+    };
+    private readonly ConnectionMultiplexer _conn;
+
+    public RedisBotCache(ConnectionMultiplexer conn)
+    {
+        _conn = conn;
+    }
+
+    public async ValueTask<bool> AddAsync<T>(TypedKey<T> key, T value, TimeSpan? expiry = null, bool overwrite = true)
+    {
+        // if a null value is passed, remove the key
+        if (value is null)
+        {
+            await RemoveAsync(key);
+            return false;
+        }
+        
+        var db = _conn.GetDatabase();
+        RedisValue val = IsSupportedType(typeof(T)) 
+            ? RedisValue.Unbox(value)
+            : JsonSerializer.Serialize(value, _opts);
+
+        var success = await db.StringSetAsync(key.Key,
+            val,
+            expiry: expiry,
+            when: overwrite ? When.Always : When.NotExists);
+
+        return success;
+    }
+
+    public bool IsSupportedType(Type type)
+    {
+        if (type.IsGenericType)
+        {
+            var typeDef = type.GetGenericTypeDefinition();
+            if (typeDef == typeof(Nullable<>))
+                return IsSupportedType(type.GenericTypeArguments[0]);
+        }
+
+        foreach (var t in _supportedTypes)
+        {
+            if (type == t)
+                return true;
+        }
+
+        return false;
+    }
+    
+    public async ValueTask<OneOf<T, None>> GetAsync<T>(TypedKey<T> key)
+    {
+        var db = _conn.GetDatabase();
+        var val = await db.StringGetAsync(key.Key);
+        if (val == default)
+            return new None();
+
+        if (IsSupportedType(typeof(T)))
+            return (T)((IConvertible)val).ToType(typeof(T), null);
+
+        return JsonSerializer.Deserialize<T>(val.ToString(), _opts)!;
+    }
+
+    public async ValueTask<bool> RemoveAsync<T>(TypedKey<T> key)
+    {
+        var db = _conn.GetDatabase();
+
+        return await db.KeyDeleteAsync(key.Key);
+    }
+
+    public async ValueTask<T?> GetOrAddAsync<T>(TypedKey<T> key, Func<Task<T?>> createFactory, TimeSpan? expiry = null)
+    {
+        var result = await GetAsync(key);
+
+        return await result.Match<Task<T?>>(
+            v => Task.FromResult<T?>(v),
+            async _ =>
+            {
+                var factoryValue = await createFactory();
+
+                if (factoryValue is null)
+                    return default;
+                
+                await AddAsync(key, factoryValue, expiry);
+                
+                // get again to make sure it's the cached value
+                // and not the late factory value, in case there's a race condition
+                
+                var newResult = await GetAsync(key);
+
+                // it's fine to do this, it should blow up if something went wrong.
+                return newResult.Match<T?>(
+                    v => v,
+                    _ => default);
+            });
+    }
+}

src/NadekoBot/Common/Collections/ConcurrentHashSet.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable enable
 #pragma warning disable
 // License MIT
 // Source: https://github.com/i3arnon/ConcurrentHashSet
@@ -7,433 +7,23 @@ using System.Diagnostics;
 
 namespace System.Collections.Generic;
 
-/// <summary>
-///     Represents a thread-safe hash-based unique collection.
-/// </summary>
-/// <typeparam name="T">The type of the items in the collection.</typeparam>
-/// <remarks>
-///     All public members of <see cref="ConcurrentHashSet{T}" /> are thread-safe and may be used
-///     concurrently from multiple threads.
-/// </remarks>
-[DebuggerDisplay("Count = {Count}")]
+[DebuggerDisplay("{_backingStore.Count}")]
 public sealed class ConcurrentHashSet<T> : IReadOnlyCollection<T>, ICollection<T>
 {
-    private const int DEFAULT_CAPACITY = 31;
-    private const int MAX_LOCK_NUMBER = 1024;
-
-    private static int DefaultConcurrencyLevel
-        => PlatformHelper.ProcessorCount;
-
-    /// <summary>
-    ///     Gets a value that indicates whether the <see cref="ConcurrentHashSet{T}" /> is empty.
-    /// </summary>
-    /// <value>
-    ///     true if the <see cref="ConcurrentHashSet{T}" /> is empty; otherwise,
-    ///     false.
-    /// </value>
-    public bool IsEmpty
-    {
-        get
-        {
-            var acquiredLocks = 0;
-            try
-            {
-                AcquireAllLocks(ref acquiredLocks);
-
-                for (var i = 0; i < tables.CountPerLock.Length; i++)
-                {
-                    if (tables.CountPerLock[i] != 0)
-                        return false;
-                }
-            }
-            finally
-            {
-                ReleaseLocks(0, acquiredLocks);
-            }
-
-            return true;
-        }
-    }
-
-    bool ICollection<T>.IsReadOnly
-        => false;
-
-    /// <summary>
-    ///     Gets the number of items contained in the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     .
-    /// </summary>
-    /// <value>
-    ///     The number of items contained in the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     .
-    /// </value>
-    /// <remarks>
-    ///     Count has snapshot semantics and represents the number of items in the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     at the moment when Count was accessed.
-    /// </remarks>
-    public int Count
-    {
-        get
-        {
-            var count = 0;
-            var acquiredLocks = 0;
-            try
-            {
-                AcquireAllLocks(ref acquiredLocks);
-
-                for (var i = 0; i < tables.CountPerLock.Length; i++)
-                    count += tables.CountPerLock[i];
-            }
-            finally
-            {
-                ReleaseLocks(0, acquiredLocks);
-            }
-
-            return count;
-        }
-    }
-
-    private readonly IEqualityComparer<T> _comparer;
-    private readonly bool _growLockArray;
-
-    private int budget;
-    private volatile Tables tables;
-
-    /// <summary>
-    ///     Initializes a new instance of the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the default concurrency level, has the default initial capacity, and
-    ///     uses the default comparer for the item type.
-    /// </summary>
+    private readonly ConcurrentDictionary<T, bool> _backingStore;
+    
     public ConcurrentHashSet()
-        : this(DefaultConcurrencyLevel, DEFAULT_CAPACITY, true, EqualityComparer<T>.Default)
-    {
-    }
+        => _backingStore = new();
 
-    /// <summary>
-    ///     Initializes a new instance of the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the specified concurrency level and capacity, and uses the default
-    ///     comparer for the item type.
-    /// </summary>
-    /// <param name="concurrencyLevel">
-    ///     The estimated number of threads that will update the
-    ///     <see cref="ConcurrentHashSet{T}" /> concurrently.
-    /// </param>
-    /// <param name="capacity">
-    ///     The initial number of elements that the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     can contain.
-    /// </param>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="concurrencyLevel" /> is
-    ///     less than 1.
-    /// </exception>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="capacity" /> is less than
-    ///     0.
-    /// </exception>
-    public ConcurrentHashSet(int concurrencyLevel, int capacity)
-        : this(concurrencyLevel, capacity, false, EqualityComparer<T>.Default)
-    {
-    }
+    public ConcurrentHashSet(IEnumerable<T> values, IEqualityComparer<T>? comparer = null)
+        => _backingStore = new(values.Select(x => new KeyValuePair<T, bool>(x, true)), comparer);
 
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that contains elements copied from the specified
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable{T}" />
-    ///     , has the default concurrency
-    ///     level, has the default initial capacity, and uses the default comparer for the item type.
-    /// </summary>
-    /// <param name="collection">
-    ///     The
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable{T}" />
-    ///     whose elements are copied to
-    ///     the new
-    ///     <see cref="ConcurrentHashSet{T}" />.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException"><paramref name="collection" /> is a null reference.</exception>
-    public ConcurrentHashSet(IEnumerable<T> collection)
-        : this(collection, EqualityComparer<T>.Default)
-    {
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the specified concurrency level and capacity, and uses the specified
-    ///     <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />
-    ///     implementation to use when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException"><paramref name="comparer" /> is a null reference.</exception>
-    public ConcurrentHashSet(IEqualityComparer<T> comparer)
-        : this(DefaultConcurrencyLevel, DEFAULT_CAPACITY, true, comparer)
-    {
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that contains elements copied from the specified
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable" />
-    ///     , has the default concurrency level, has the default
-    ///     initial capacity, and uses the specified
-    ///     <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="collection">
-    ///     The
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable{T}" />
-    ///     whose elements are copied to
-    ///     the new
-    ///     <see cref="ConcurrentHashSet{T}" />.
-    /// </param>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />
-    ///     implementation to use when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException">
-    ///     <paramref name="collection" /> is a null reference
-    ///     (Nothing in Visual Basic). -or-
-    ///     <paramref name="comparer" /> is a null reference (Nothing in Visual Basic).
-    /// </exception>
-    public ConcurrentHashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
-        : this(comparer)
-    {
-        if (collection is null)
-            throw new ArgumentNullException(nameof(collection));
-
-        InitializeFromCollection(collection);
-    }
-
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that contains elements copied from the specified <see cref="T:System.Collections.IEnumerable" />,
-    ///     has the specified concurrency level, has the specified initial capacity, and uses the specified
-    ///     <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="concurrencyLevel">
-    ///     The estimated number of threads that will update the
-    ///     <see cref="ConcurrentHashSet{T}" /> concurrently.
-    /// </param>
-    /// <param name="collection">
-    ///     The <see cref="T:System.Collections.IEnumerable{T}" /> whose elements are copied to the new
-    ///     <see cref="ConcurrentHashSet{T}" />.
-    /// </param>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" /> implementation to use
-    ///     when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException">
-    ///     <paramref name="collection" /> is a null reference.
-    ///     -or-
-    ///     <paramref name="comparer" /> is a null reference.
-    /// </exception>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="concurrencyLevel" /> is less than 1.
-    /// </exception>
-    public ConcurrentHashSet(int concurrencyLevel, IEnumerable<T> collection, IEqualityComparer<T> comparer)
-        : this(concurrencyLevel, DEFAULT_CAPACITY, false, comparer)
-    {
-        if (collection is null)
-            throw new ArgumentNullException(nameof(collection));
-        if (comparer is null)
-            throw new ArgumentNullException(nameof(comparer));
-
-        InitializeFromCollection(collection);
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the specified concurrency level, has the specified initial capacity, and
-    ///     uses the specified <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="concurrencyLevel">
-    ///     The estimated number of threads that will update the
-    ///     <see cref="ConcurrentHashSet{T}" /> concurrently.
-    /// </param>
-    /// <param name="capacity">
-    ///     The initial number of elements that the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     can contain.
-    /// </param>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />
-    ///     implementation to use when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="concurrencyLevel" /> is less than 1. -or-
-    ///     <paramref name="capacity" /> is less than 0.
-    /// </exception>
-    /// <exception cref="T:System.ArgumentNullException"><paramref name="comparer" /> is a null reference.</exception>
-    public ConcurrentHashSet(int concurrencyLevel, int capacity, IEqualityComparer<T> comparer)
-        : this(concurrencyLevel, capacity, false, comparer)
-    {
-    }
-
-    private ConcurrentHashSet(
-        int concurrencyLevel,
-        int capacity,
-        bool growLockArray,
-        IEqualityComparer<T> comparer)
-    {
-        if (concurrencyLevel < 1)
-            throw new ArgumentOutOfRangeException(nameof(concurrencyLevel));
-        if (capacity < 0)
-            throw new ArgumentOutOfRangeException(nameof(capacity));
-
-        // The capacity should be at least as large as the concurrency level. Otherwise, we would have locks that don't guard
-        // any buckets.
-        if (capacity < concurrencyLevel)
-            capacity = concurrencyLevel;
-
-        var locks = new object[concurrencyLevel];
-        for (var i = 0; i < locks.Length; i++)
-            locks[i] = new();
-
-        var countPerLock = new int[locks.Length];
-        var buckets = new Node[capacity];
-        tables = new(buckets, locks, countPerLock);
-
-        _growLockArray = growLockArray;
-        budget = buckets.Length / locks.Length;
-        _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
-    }
-
-    /// <summary>
-    ///     Removes all items from the <see cref="ConcurrentHashSet{T}" />.
-    /// </summary>
-    public void Clear()
-    {
-        var locksAcquired = 0;
-        try
-        {
-            AcquireAllLocks(ref locksAcquired);
-
-            var newTables = new Tables(new Node[DEFAULT_CAPACITY], tables.Locks, new int[tables.CountPerLock.Length]);
-            tables = newTables;
-            budget = Math.Max(1, newTables.Buckets.Length / newTables.Locks.Length);
-        }
-        finally
-        {
-            ReleaseLocks(0, locksAcquired);
-        }
-    }
-
-    /// <summary>
-    ///     Determines whether the <see cref="ConcurrentHashSet{T}" /> contains the specified
-    ///     item.
-    /// </summary>
-    /// <param name="item">The item to locate in the <see cref="ConcurrentHashSet{T}" />.</param>
-    /// <returns>true if the <see cref="ConcurrentHashSet{T}" /> contains the item; otherwise, false.</returns>
-    public bool Contains(T item)
-    {
-        var hashcode = _comparer.GetHashCode(item!);
-
-        // We must capture the _buckets field in a local variable. It is set to a new table on each table resize.
-        var localTables = tables;
-
-        var bucketNo = GetBucket(hashcode, localTables.Buckets.Length);
-
-        // We can get away w/out a lock here.
-        // The Volatile.Read ensures that the load of the fields of 'n' doesn't move before the load from buckets[i].
-        var current = Volatile.Read(ref localTables.Buckets[bucketNo]);
-
-        while (current is not null)
-        {
-            if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
-                return true;
-
-            current = current.Next;
-        }
-
-        return false;
-    }
-
-    void ICollection<T>.Add(T item)
-        => Add(item);
-
-    void ICollection<T>.CopyTo(T[] array, int arrayIndex)
-    {
-        if (array is null)
-            throw new ArgumentNullException(nameof(array));
-        if (arrayIndex < 0)
-            throw new ArgumentOutOfRangeException(nameof(arrayIndex));
-
-        var locksAcquired = 0;
-        try
-        {
-            AcquireAllLocks(ref locksAcquired);
-
-            var count = 0;
-
-            for (var i = 0; i < tables.Locks.Length && count >= 0; i++)
-                count += tables.CountPerLock[i];
-
-            if (array.Length - count < arrayIndex || count < 0) //"count" itself or "count + arrayIndex" can overflow
-            {
-                throw new ArgumentException(
-                    "The index is equal to or greater than the length of the array, or the number of elements in the set is greater than the available space from index to the end of the destination array.");
-            }
-
-            CopyToItems(array, arrayIndex);
-        }
-        finally
-        {
-            ReleaseLocks(0, locksAcquired);
-        }
-    }
-
-    bool ICollection<T>.Remove(T item)
-        => TryRemove(item);
+    public IEnumerator<T> GetEnumerator()
+        => _backingStore.Keys.GetEnumerator();
 
     IEnumerator IEnumerable.GetEnumerator()
         => GetEnumerator();
 
-    /// <summary>
-    ///     Returns an enumerator that iterates through the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     .
-    /// </summary>
-    /// <returns>An enumerator for the <see cref="ConcurrentHashSet{T}" />.</returns>
-    /// <remarks>
-    ///     The enumerator returned from the collection is safe to use concurrently with
-    ///     reads and writes to the collection, however it does not represent a moment-in-time snapshot
-    ///     of the collection.  The contents exposed through the enumerator may contain modifications
-    ///     made to the collection after <see cref="GetEnumerator" /> was called.
-    /// </remarks>
-    public IEnumerator<T> GetEnumerator()
-    {
-        var buckets = tables.Buckets;
-
-        for (var i = 0; i < buckets.Length; i++)
-        {
-            // The Volatile.Read ensures that the load of the fields of 'current' doesn't move before the load from buckets[i].
-            var current = Volatile.Read(ref buckets[i]);
-
-            while (current is not null)
-            {
-                yield return current.Item;
-                current = current.Next;
-            }
-        }
-    }
-
     /// <summary>
     ///     Adds the specified item to the <see cref="ConcurrentHashSet{T}" />.
     /// </summary>
@@ -447,375 +37,57 @@ public sealed class ConcurrentHashSet<T> : IReadOnlyCollection<T>, ICollection<T
     ///     contains too many items.
     /// </exception>
     public bool Add(T item)
-        => AddInternal(item, _comparer.GetHashCode(item), true);
+        => _backingStore.TryAdd(item, true);
+
+    void ICollection<T>.Add(T item)
+        => Add(item);
+
+    public void Clear()
+        => _backingStore.Clear();
+
+    public bool Contains(T item)
+        => _backingStore.ContainsKey(item);
+
+    public void CopyTo(T[] array, int arrayIndex)
+    {
+        ArgumentNullException.ThrowIfNull(array);
+        
+        if (arrayIndex < 0)
+            throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+        
+        if (arrayIndex >= array.Length)
+            throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+
+        CopyToInternal(array, arrayIndex);
+    }
+
+    private void CopyToInternal(T[] array, int arrayIndex)
+    {
+        var len = array.Length;
+        foreach (var (k, _) in _backingStore)
+        {
+            if (arrayIndex >= len)
+                throw new IndexOutOfRangeException(nameof(arrayIndex));
+            
+            array[arrayIndex++] = k;
+        }
+    }
+
+    bool ICollection<T>.Remove(T item)
+        => TryRemove(item);
 
-    /// <summary>
-    ///     Attempts to remove the item from the <see cref="ConcurrentHashSet{T}" />.
-    /// </summary>
-    /// <param name="item">The item to remove.</param>
-    /// <returns>true if an item was removed successfully; otherwise, false.</returns>
     public bool TryRemove(T item)
+        => _backingStore.TryRemove(item, out _);
+
+    public void RemoveWhere(Func<T, bool> predicate)
     {
-        var hashcode = _comparer.GetHashCode(item);
-        while (true)
-        {
-            var localTables = tables;
-
-            GetBucketAndLockNo(hashcode,
-                out var bucketNo,
-                out var lockNo,
-                localTables.Buckets.Length,
-                localTables.Locks.Length);
-
-            lock (localTables.Locks[lockNo])
-            {
-                // If the table just got resized, we may not be holding the right lock, and must retry.
-                // This should be a rare occurrence.
-                if (localTables != tables)
-                    continue;
-
-                Node previous = null;
-                for (var current = localTables.Buckets[bucketNo]; current is not null; current = current.Next)
-                {
-                    Debug.Assert((previous is null && current == localTables.Buckets[bucketNo])
-                                 || previous!.Next == current);
-
-                    if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
-                    {
-                        if (previous is null)
-                            Volatile.Write(ref localTables.Buckets[bucketNo], current.Next);
-                        else
-                            previous.Next = current.Next;
-
-                        localTables.CountPerLock[lockNo]--;
-                        return true;
-                    }
-
-                    previous = current;
-                }
-            }
-
-            return false;
-        }
+        foreach (var elem in this.Where(predicate))
+            TryRemove(elem);
     }
 
-    private void InitializeFromCollection(IEnumerable<T> collection)
-    {
-        foreach (var item in collection)
-            AddInternal(item, _comparer.GetHashCode(item), false);
+    public int Count
+        => _backingStore.Count;
 
-        if (budget == 0)
-            budget = tables.Buckets.Length / tables.Locks.Length;
-    }
-
-    private bool AddInternal(T item, int hashcode, bool acquireLock)
-    {
-        while (true)
-        {
-            var localTables = tables;
-            GetBucketAndLockNo(hashcode,
-                out var bucketNo,
-                out var lockNo,
-                localTables.Buckets.Length,
-                localTables.Locks.Length);
-
-            var resizeDesired = false;
-            var lockTaken = false;
-            try
-            {
-                if (acquireLock)
-                    Monitor.Enter(localTables.Locks[lockNo], ref lockTaken);
-
-                // If the table just got resized, we may not be holding the right lock, and must retry.
-                // This should be a rare occurrence.
-                if (localTables != tables)
-                    continue;
-
-                // Try to find this item in the bucket
-                Node previous = null;
-                for (var current = localTables.Buckets[bucketNo]; current is not null; current = current.Next)
-                {
-                    Debug.Assert((previous is null && current == localTables.Buckets[bucketNo])
-                                 || previous!.Next == current);
-                    if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
-                        return false;
-
-                    previous = current;
-                }
-
-                // The item was not found in the bucket. Insert the new item.
-                Volatile.Write(ref localTables.Buckets[bucketNo], new(item, hashcode, localTables.Buckets[bucketNo]));
-                checked
-                {
-                    localTables.CountPerLock[lockNo]++;
-                }
-
-                //
-                // If the number of elements guarded by this lock has exceeded the budget, resize the bucket table.
-                // It is also possible that GrowTable will increase the budget but won't resize the bucket table.
-                // That happens if the bucket table is found to be poorly utilized due to a bad hash function.
-                //
-                if (localTables.CountPerLock[lockNo] > budget)
-                    resizeDesired = true;
-            }
-            finally
-            {
-                if (lockTaken)
-                    Monitor.Exit(localTables.Locks[lockNo]);
-            }
-
-            //
-            // The fact that we got here means that we just performed an insertion. If necessary, we will grow the table.
-            //
-            // Concurrency notes:
-            // - Notice that we are not holding any locks at when calling GrowTable. This is necessary to prevent deadlocks.
-            // - As a result, it is possible that GrowTable will be called unnecessarily. But, GrowTable will obtain lock 0
-            //   and then verify that the table we passed to it as the argument is still the current table.
-            //
-            if (resizeDesired)
-                GrowTable(localTables);
-
-            return true;
-        }
-    }
-
-    private static int GetBucket(int hashcode, int bucketCount)
-    {
-        var bucketNo = (hashcode & 0x7fffffff) % bucketCount;
-        Debug.Assert(bucketNo >= 0 && bucketNo < bucketCount);
-        return bucketNo;
-    }
-
-    private static void GetBucketAndLockNo(
-        int hashcode,
-        out int bucketNo,
-        out int lockNo,
-        int bucketCount,
-        int lockCount)
-    {
-        bucketNo = (hashcode & 0x7fffffff) % bucketCount;
-        lockNo = bucketNo % lockCount;
-
-        Debug.Assert(bucketNo >= 0 && bucketNo < bucketCount);
-        Debug.Assert(lockNo >= 0 && lockNo < lockCount);
-    }
-
-    private void GrowTable(Tables localTables)
-    {
-        const int maxArrayLength = 0X7FEFFFFF;
-        var locksAcquired = 0;
-        try
-        {
-            // The thread that first obtains _locks[0] will be the one doing the resize operation
-            AcquireLocks(0, 1, ref locksAcquired);
-
-            // Make sure nobody resized the table while we were waiting for lock 0:
-            if (localTables != tables)
-                // We assume that since the table reference is different, it was already resized (or the budget
-                // was adjusted). If we ever decide to do table shrinking, or replace the table for other reasons,
-                // we will have to revisit this logic.
-                return;
-
-            // Compute the (approx.) total size. Use an Int64 accumulation variable to avoid an overflow.
-            long approxCount = 0;
-            for (var i = 0; i < localTables.CountPerLock.Length; i++)
-                approxCount += localTables.CountPerLock[i];
-
-            //
-            // If the bucket array is too empty, double the budget instead of resizing the table
-            //
-            if (approxCount < localTables.Buckets.Length / 4)
-            {
-                budget = 2 * budget;
-                if (budget < 0)
-                    budget = int.MaxValue;
-
-                return;
-            }
-
-            // Compute the new table size. We find the smallest integer larger than twice the previous table size, and not divisible by
-            // 2,3,5 or 7. We can consider a different table-sizing policy in the future.
-            var newLength = 0;
-            var maximizeTableSize = false;
-            try
-            {
-                checked
-                {
-                    // Double the size of the buckets table and add one, so that we have an odd integer.
-                    newLength = (localTables.Buckets.Length * 2) + 1;
-
-                    // Now, we only need to check odd integers, and find the first that is not divisible
-                    // by 3, 5 or 7.
-                    while (newLength % 3 == 0 || newLength % 5 == 0 || newLength % 7 == 0)
-                        newLength += 2;
-
-                    Debug.Assert(newLength % 2 != 0);
-
-                    if (newLength > maxArrayLength)
-                        maximizeTableSize = true;
-                }
-            }
-            catch (OverflowException)
-            {
-                maximizeTableSize = true;
-            }
-
-            if (maximizeTableSize)
-            {
-                newLength = maxArrayLength;
-
-                // We want to make sure that GrowTable will not be called again, since table is at the maximum size.
-                // To achieve that, we set the budget to int.MaxValue.
-                //
-                // (There is one special case that would allow GrowTable() to be called in the future: 
-                // calling Clear() on the ConcurrentHashSet will shrink the table and lower the budget.)
-                budget = int.MaxValue;
-            }
-
-            // Now acquire all other locks for the table
-            AcquireLocks(1, localTables.Locks.Length, ref locksAcquired);
-
-            var newLocks = localTables.Locks;
-
-            // Add more locks
-            if (_growLockArray && localTables.Locks.Length < MAX_LOCK_NUMBER)
-            {
-                newLocks = new object[localTables.Locks.Length * 2];
-                Array.Copy(localTables.Locks, 0, newLocks, 0, localTables.Locks.Length);
-                for (var i = localTables.Locks.Length; i < newLocks.Length; i++)
-                    newLocks[i] = new();
-            }
-
-            var newBuckets = new Node[newLength];
-            var newCountPerLock = new int[newLocks.Length];
-
-            // Copy all data into a new table, creating new nodes for all elements
-            for (var i = 0; i < localTables.Buckets.Length; i++)
-            {
-                var current = localTables.Buckets[i];
-                while (current is not null)
-                {
-                    var next = current.Next;
-                    GetBucketAndLockNo(current.Hashcode,
-                        out var newBucketNo,
-                        out var newLockNo,
-                        newBuckets.Length,
-                        newLocks.Length);
-
-                    newBuckets[newBucketNo] = new(current.Item, current.Hashcode, newBuckets[newBucketNo]);
-
-                    checked
-                    {
-                        newCountPerLock[newLockNo]++;
-                    }
-
-                    current = next;
-                }
-            }
-
-            // Adjust the budget
-            budget = Math.Max(1, newBuckets.Length / newLocks.Length);
-
-            // Replace tables with the new versions
-            tables = new(newBuckets, newLocks, newCountPerLock);
-        }
-        finally
-        {
-            // Release all locks that we took earlier
-            ReleaseLocks(0, locksAcquired);
-        }
-    }
-
-    public int RemoveWhere(Func<T, bool> predicate)
-    {
-        var elems = this.Where(predicate);
-        var removed = 0;
-        foreach (var elem in elems)
-        {
-            if (TryRemove(elem))
-                removed++;
-        }
-
-        return removed;
-    }
-
-    private void AcquireAllLocks(ref int locksAcquired)
-    {
-        // First, acquire lock 0
-        AcquireLocks(0, 1, ref locksAcquired);
-
-        // Now that we have lock 0, the _locks array will not change (i.e., grow),
-        // and so we can safely read _locks.Length.
-        AcquireLocks(1, tables.Locks.Length, ref locksAcquired);
-        Debug.Assert(locksAcquired == tables.Locks.Length);
-    }
-
-    private void AcquireLocks(int fromInclusive, int toExclusive, ref int locksAcquired)
-    {
-        Debug.Assert(fromInclusive <= toExclusive);
-        var locks = tables.Locks;
-
-        for (var i = fromInclusive; i < toExclusive; i++)
-        {
-            var lockTaken = false;
-            try
-            {
-                Monitor.Enter(locks[i], ref lockTaken);
-            }
-            finally
-            {
-                if (lockTaken)
-                    locksAcquired++;
-            }
-        }
-    }
-
-    private void ReleaseLocks(int fromInclusive, int toExclusive)
-    {
-        Debug.Assert(fromInclusive <= toExclusive);
-
-        for (var i = fromInclusive; i < toExclusive; i++)
-            Monitor.Exit(tables.Locks[i]);
-    }
-
-    private void CopyToItems(T[] array, int index)
-    {
-        var buckets = tables.Buckets;
-        for (var i = 0; i < buckets.Length; i++)
-        for (var current = buckets[i]; current is not null; current = current.Next)
-        {
-            array[index] = current.Item;
-            index++; //this should never flow, CopyToItems is only called when there's no overflow risk
-        }
-    }
-
-    private sealed class Tables
-    {
-        public readonly Node[] Buckets;
-        public readonly object[] Locks;
-
-        public volatile int[] CountPerLock;
-
-        public Tables(Node[] buckets, object[] locks, int[] countPerLock)
-        {
-            Buckets = buckets;
-            Locks = locks;
-            CountPerLock = countPerLock;
-        }
-    }
-
-    private sealed class Node
-    {
-        public readonly int Hashcode;
-        public readonly T Item;
-
-        public volatile Node Next;
-
-        public Node(T item, int hashcode, Node next)
-        {
-            Item = item;
-            Hashcode = hashcode;
-            Next = next;
-        }
-    }
+    public bool IsReadOnly
+        => false;
 }

src/NadekoBot/Common/Configs/BotConfig.cs

@@ -12,7 +12,7 @@ namespace NadekoBot.Common.Configs;
 public sealed partial class BotConfig : ICloneable<BotConfig>
 {
     [Comment(@"DO NOT CHANGE")]
-    public int Version { get; set; } = 2;
+    public int Version { get; set; } = 3;
 
     [Comment(@"Most commands, when executed, have a small colored line
 next to the response. The color depends whether the command
@@ -182,4 +182,4 @@ public enum ConsoleOutputType
     Normal = 0,
     Simple = 1,
     None = 2
-}
+}

src/NadekoBot/Common/Creds.cs

@@ -18,8 +18,11 @@ public sealed class Creds : IBotCredentials
     [Comment("Keep this on 'true' unless you're sure your bot shouldn't use privileged intents or you're waiting to be accepted")]
     public bool UsePrivilegedIntents { get; set; }
 
-    [Comment(@"The number of shards that the bot will running on.
-Leave at 1 if you don't know what you're doing.")]
+    [Comment(@"The number of shards that the bot will be running on.
+Leave at 1 if you don't know what you're doing.
+
+note: If you are planning to have more than one shard, then you must change botCache to 'redis'.
+      Also, in that case you should be using NadekoBot.Coordinator to start the bot, and it will correctly override this value.")]
     public int TotalShards { get; set; }
 
     [Comment(   
@@ -27,6 +30,16 @@ Leave at 1 if you don't know what you're doing.")]
 Then, go to APIs and Services -> Credentials and click Create credentials -> API key.
 Used only for Youtube Data Api (at the moment).")]
     public string GoogleApiKey { get; set; }
+    
+    [Comment(   
+        @"Create a new custom search here https://programmablesearchengine.google.com/cse/create/new
+Enable SafeSearch
+Remove all Sites to Search
+Enable Search the entire web
+Copy the 'Search Engine ID' to the SearchId field
+
+Do all steps again but enable image search for the ImageSearchId")]
+    public GoogleApiConfig Google { get; set; }
 
     [Comment(@"Settings for voting system for discordbots. Meant for use on global Nadeko.")]
     public VotesSettings Votes { get; set; }
@@ -40,8 +53,14 @@ go to https://www.patreon.com/portal -> my clients -> create client")]
 
     [Comment(@"Official cleverbot api key.")]
     public string CleverbotApiKey { get; set; }
-
-    [Comment(@"Redis connection string. Don't change if you don't know what you're doing.")]
+    
+    [Comment(@"Which cache implementation should bot use.
+'memory' - Cache will be in memory of the bot's process itself. Only use this on bots with a single shard. When the bot is restarted the cache is reset. 
+'redis' - Uses redis (which needs to be separately downloaded and installed). The cache will persist through bot restarts. You can configure connection string in creds.yml")]
+    public BotCacheImplemenation BotCache { get; set; }
+    
+    [Comment(@"Redis connection string. Don't change if you don't know what you're doing.
+Only used if botCache is set to 'redis'")]
     public string RedisOptions { get; set; }
 
     [Comment(@"Database options. Don't change if you don't know what you're doing. Leave null for default values")]
@@ -94,12 +113,12 @@ Linux default
     args: ""NadekoBot.dll -- {0}""
 Windows default
     cmd: NadekoBot.exe
-    args: {0}")]
+    args: ""{0}""")]
     public RestartConfig RestartCommand { get; set; }
 
     public Creds()
     {
-        Version = 4;
+        Version = 6;
         Token = string.Empty;
         UsePrivilegedIntents = true;
         OwnerIds = new List<ulong>();
@@ -109,6 +128,7 @@ Windows default
         Patreon = new(string.Empty, string.Empty, string.Empty, string.Empty);
         BotListToken = string.Empty;
         CleverbotApiKey = string.Empty;
+        BotCache = BotCacheImplemenation.Memory;
         RedisOptions = "localhost:6379,syncTimeout=30000,responseTimeout=30000,allowAdmin=true,password=";
         Db = new()
         {
@@ -119,15 +139,21 @@ Windows default
         CoordinatorUrl = "http://localhost:3442";
 
         RestartCommand = new();
+        Google = new();
     }
 
 
     public class DbOptions
     {
-        [Comment(@"Database type. Only sqlite supported atm")]
+        [Comment(@"Database type. ""sqlite"", ""mysql"" and ""postgresql"" are supported.
+Default is ""sqlite""")]
         public string Type { get; set; }
 
-        [Comment(@"Connection string. Will default to ""Data Source=data/NadekoBot.db""")]
+        [Comment(@"Database connection string.
+You MUST change this if you're not using ""sqlite"" type.
+Default is ""Data Source=data/NadekoBot.db""
+Example for mysql: ""Server=localhost;Port=3306;Uid=root;Pwd=my_super_secret_mysql_password;Database=nadeko""
+Example for postgresql: ""Server=localhost;Port=5432;User Id=postgres;Password=my_super_secret_postgres_password;Database=nadeko;""")]
         public string ConnectionString { get; set; }
     }
 
@@ -195,4 +221,16 @@ This should be equivalent to the DiscordsKey in your NadekoBot.Votes api appsett
             DiscordsKey = discordsKey;
         }
     }
+}
+
+public class GoogleApiConfig
+{
+    public string SearchId { get; init; }
+    public string ImageSearchId { get; init; }
+}
+
+public enum BotCacheImplemenation
+{
+    Memory,
+    Redis
 }

src/NadekoBot/Common/IBotCredentials.cs

@@ -25,6 +25,8 @@ public interface IBotCredentials
     string CoordinatorUrl { get; set; }
     string TwitchClientId { get; set; }
     string TwitchClientSecret { get; set; }
+    GoogleApiConfig Google { get; set; }
+    BotCacheImplemenation BotCache { get; set; }
 }
 
 public class RestartConfig

src/NadekoBot/Common/ILogCommandService.cs

@@ -27,5 +27,6 @@ public enum LogType
     UserPresence,
     VoicePresence,
     VoicePresenceTts,
-    UserMuted
+    UserMuted,
+    UserWarned,
 }

src/NadekoBot/Common/ImageUrls.cs

@@ -1,9 +1,11 @@
 #nullable disable
 using NadekoBot.Common.Yml;
+using Cloneable;
 
 namespace NadekoBot.Common;
 
-public class ImageUrls
+[Cloneable]
+public partial class ImageUrls : ICloneable<ImageUrls> 
 {
     [Comment("DO NOT CHANGE")]
     public int Version { get; set; } = 3;

src/NadekoBot/Common/Interaction/NadekoActionInteraction.cs

@@ -0,0 +1,29 @@
+namespace NadekoBot;
+
+public sealed class NadekoButtonActionInteraction : NadekoButtonOwnInteraction
+{
+    private readonly NadekoInteractionData _data;
+    private readonly Func<SocketMessageComponent, Task> _action;
+
+    public NadekoButtonActionInteraction(
+        DiscordSocketClient client,
+        ulong authorId,
+        NadekoInteractionData data,
+        Func<SocketMessageComponent, Task> action
+    )
+        : base(client, authorId)
+    {
+        _data = data;
+        _action = action;
+    }
+
+    protected override string Name
+        => _data.CustomId;
+    protected override IEmote Emote
+        => _data.Emote;
+    protected override string? Text
+        => _data.Text;
+
+    public override Task ExecuteOnActionAsync(SocketMessageComponent smc)
+        => _action(smc);
+}

src/NadekoBot/Common/Interaction/NadekoInteraction.cs

@@ -0,0 +1,83 @@
+namespace NadekoBot;
+
+public abstract class NadekoButtonInteraction
+{
+    // improvements:
+    //  - state in OnAction
+    //  - configurable delay
+    //  - 
+    protected abstract string Name { get; }
+    protected abstract IEmote Emote { get; }
+    protected virtual string? Text { get; } = null;
+
+    public DiscordSocketClient Client { get; }
+
+    protected readonly TaskCompletionSource<bool> _interactionCompletedSource;
+
+    protected IUserMessage message = null!;
+
+    protected NadekoButtonInteraction(DiscordSocketClient client)
+    {
+        Client = client;
+        _interactionCompletedSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    }
+
+    public async Task RunAsync(IUserMessage msg)
+    {
+        message = msg;
+
+        Client.InteractionCreated += OnInteraction;
+        await Task.WhenAny(Task.Delay(10_000), _interactionCompletedSource.Task);
+        Client.InteractionCreated -= OnInteraction;
+
+        await msg.ModifyAsync(m => m.Components = new ComponentBuilder().Build());
+    }
+
+    protected abstract ValueTask<bool> Validate(SocketMessageComponent smc);
+    private async Task OnInteraction(SocketInteraction arg)
+    {
+        if (arg is not SocketMessageComponent smc)
+            return;
+
+        if (smc.Message.Id != message.Id)
+            return;
+
+        if (smc.Data.CustomId != Name)
+            return;
+
+        if (!await Validate(smc))
+        {
+            await smc.DeferAsync();
+            return;
+        }
+
+        _ = Task.Run(async () =>
+        {
+            await ExecuteOnActionAsync(smc);
+            
+            // this should only be a thing on single-response buttons
+            _interactionCompletedSource.TrySetResult(true);
+
+            if (!smc.HasResponded)
+            {
+                await smc.DeferAsync();
+            }
+        });
+    }
+
+
+    public virtual MessageComponent CreateComponent()
+    {
+        var comp = new ComponentBuilder()
+            .WithButton(GetButtonBuilder());
+
+        return comp.Build();
+    }
+
+    public ButtonBuilder GetButtonBuilder()
+        => new ButtonBuilder(style: ButtonStyle.Secondary, emote: Emote, customId: Name, label: Text);
+
+    public abstract Task ExecuteOnActionAsync(SocketMessageComponent smc);
+}
+
+// this is all so wrong ...

src/NadekoBot/Common/Interaction/NadekoInteractionArray.cs

@@ -0,0 +1,43 @@
+// namespace NadekoBot;
+//
+// public class NadekoButtonInteractionArray : NadekoButtonInteraction
+// {
+//     private readonly ButtonBuilder[] _bbs;
+//     private readonly NadekoButtonInteraction[] _inters;
+//
+//     public NadekoButtonInteractionArray(params NadekoButtonInteraction[] inters)
+//         : base(inters[0].Client)
+//     {
+//         _inters = inters;
+//         _bbs = inters.Map(x => x.GetButtonBuilder());
+//     }
+//
+//     protected override string Name
+//         => throw new NotSupportedException();
+//     protected override IEmote Emote
+//         => throw new NotSupportedException();
+//
+//     protected override ValueTask<bool> Validate(SocketMessageComponent smc)
+//         => new(true);
+//
+//     public override Task ExecuteOnActionAsync(SocketMessageComponent smc)
+//     {
+//         for (var i = 0; i < _bbs.Length; i++)
+//         {
+//             if (_bbs[i].CustomId == smc.Data.CustomId)
+//                 return _inters[i].ExecuteOnActionAsync(smc);
+//         }
+//
+//         return Task.CompletedTask;
+//     }
+//
+//     public override MessageComponent CreateComponent()
+//     {
+//         var comp = new ComponentBuilder();
+//
+//         foreach (var bb in _bbs)
+//             comp.WithButton(bb);
+//         
+//         return comp.Build();
+//     }
+// }

src/NadekoBot/Common/Interaction/NadekoInteractionBuilder.cs

@@ -0,0 +1,42 @@
+namespace NadekoBot;
+
+/// <summary>
+/// Builder class for NadekoInteractions
+/// </summary>
+public class NadekoInteractionBuilder
+{
+    private NadekoInteractionData? iData;
+    private Func<SocketMessageComponent, Task>? action;
+    // private bool isOwn;
+
+    public NadekoInteractionBuilder WithData<T>(in T data)
+        where T : NadekoInteractionData
+    {
+        iData = data;
+        return this;
+    }
+
+    // public NadekoOwnInteractionBuiler WithIsOwn(bool isOwn = true)
+    // {
+    //     this.isOwn = isOwn;
+    //     return this;
+    
+    // }
+    
+    public NadekoInteractionBuilder WithAction(in Func<SocketMessageComponent, Task> fn)
+    {
+        this.action = fn;
+        return this;
+    }
+
+    public NadekoButtonActionInteraction Build(DiscordSocketClient client, ulong userId)
+    {
+        if (iData is null)
+            throw new InvalidOperationException("You have to specify the data before building the interaction");
+
+        if (action is null)
+            throw new InvalidOperationException("You have to specify the action before building the interaction");
+
+        return new(client, userId, iData, action);
+    }
+}

src/NadekoBot/Common/Interaction/NadekoInteractionData.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot;
+
+/// <summary>
+/// Represents essential interacation data
+/// </summary>
+/// <param name="Emote">Emote which will show on a button</param>
+/// <param name="CustomId">Custom interaction id</param>
+public record NadekoInteractionData(IEmote Emote, string CustomId, string? Text = null);

src/NadekoBot/Common/Interaction/NadekoOwnInteraction.cs

@@ -0,0 +1,15 @@
+namespace NadekoBot;
+
+/// <summary>
+/// Interaction which only the author can use
+/// </summary>
+public abstract class NadekoButtonOwnInteraction : NadekoButtonInteraction
+{
+    protected readonly ulong _authorId;
+
+    protected NadekoButtonOwnInteraction(DiscordSocketClient client, ulong authorId) : base(client)
+        => _authorId = authorId;
+
+    protected override ValueTask<bool> Validate(SocketMessageComponent smc)
+        => new(smc.User.Id == _authorId);
+}

src/NadekoBot/Common/Linq2DbExpressions.cs

@@ -0,0 +1,16 @@
+#nullable disable
+using LinqToDB;
+using System.Linq.Expressions;
+
+namespace NadekoBot.Common;
+
+public static class Linq2DbExpressions
+{
+    [ExpressionMethod(nameof(GuildOnShardExpression))]
+    public static bool GuildOnShard(ulong guildId, int totalShards, int shardId)
+        => throw new NotSupportedException();
+    
+    private static Expression<Func<ulong, int, int, bool>> GuildOnShardExpression()
+        => (guildId, totalShards, shardId)
+            => guildId / 4194304 % (ulong)totalShards == (ulong)shardId;
+}

src/NadekoBot/Common/Medusa/Adapters/BehaviorAdapter.cs

@@ -0,0 +1,76 @@
+#nullable enable
+
+[DontAddToIocContainer]
+public sealed class BehaviorAdapter : ICustomBehavior
+{
+    private readonly WeakReference<Snek> _snekWr;
+    private readonly IMedusaStrings _strings;
+    private readonly IServiceProvider _services;
+    private readonly string _name;
+
+    // unused
+    public int Priority
+        => 0;
+
+    public BehaviorAdapter(WeakReference<Snek> snekWr, IMedusaStrings strings, IServiceProvider services)
+    {
+        _snekWr = snekWr;
+        _strings = strings;
+        _services = services;
+
+        _name = snekWr.TryGetTarget(out var snek)
+            ? $"snek/{snek.GetType().Name}"
+            : "unknown";
+    }
+
+    public async Task<bool> ExecPreCommandAsync(ICommandContext context, string moduleName, CommandInfo command)
+    {
+        if (!_snekWr.TryGetTarget(out var snek))
+            return false;
+
+        return await snek.ExecPreCommandAsync(ContextAdapterFactory.CreateNew(context, _strings, _services),
+            moduleName,
+            command.Name);
+    }
+
+    public async Task<bool> ExecOnMessageAsync(IGuild? guild, IUserMessage msg)
+    {
+        if (!_snekWr.TryGetTarget(out var snek))
+            return false;
+
+        return await snek.ExecOnMessageAsync(guild, msg);
+    }
+
+    public async Task<string?> TransformInput(
+        IGuild guild,
+        IMessageChannel channel,
+        IUser user,
+        string input)
+    {
+        if (!_snekWr.TryGetTarget(out var snek))
+            return null;
+        
+        return await snek.ExecInputTransformAsync(guild, channel, user, input);
+    }
+
+    public async Task ExecOnNoCommandAsync(IGuild? guild, IUserMessage msg)
+    {
+        if (!_snekWr.TryGetTarget(out var snek))
+            return;
+
+        await snek.ExecOnNoCommandAsync(guild, msg);
+    }
+
+    public async ValueTask ExecPostCommandAsync(ICommandContext context, string moduleName, string commandName)
+    {
+        if (!_snekWr.TryGetTarget(out var snek))
+            return;
+        
+        await snek.ExecPostCommandAsync(ContextAdapterFactory.CreateNew(context, _strings, _services),
+            moduleName,
+            commandName);
+    }
+
+    public override string ToString()
+        => _name;
+}

src/NadekoBot/Common/Medusa/Adapters/ContextAdapterFactory.cs

@@ -0,0 +1,7 @@
+internal class ContextAdapterFactory
+{
+    public static AnyContext CreateNew(ICommandContext context, IMedusaStrings strings, IServiceProvider services)
+        => context.Guild is null
+            ? new DmContextAdapter(context, strings, services)
+            : new GuildContextAdapter(context, strings, services);
+}

src/NadekoBot/Common/Medusa/Adapters/DmContextAdapter.cs

@@ -0,0 +1,48 @@
+using Microsoft.Extensions.DependencyInjection;
+
+public sealed class DmContextAdapter : DmContext
+{
+    public override IMedusaStrings Strings { get; }
+    public override IDMChannel Channel { get; }
+    public override IUserMessage Message { get; }
+    public override IUser User
+        => Message.Author;
+    
+    private readonly IServiceProvider _services;
+    private readonly Lazy<IEmbedBuilderService> _ebs;
+    private readonly Lazy<IBotStrings> _botStrings;
+    private readonly Lazy<ILocalization> _localization;
+
+    public DmContextAdapter(ICommandContext ctx, IMedusaStrings strings, IServiceProvider services)
+    {
+        if (ctx is not { Channel: IDMChannel ch })
+        {
+            throw new ArgumentException("Can't use non-dm context to create DmContextAdapter", nameof(ctx));
+        }
+
+        Strings = strings;
+
+        _services = services;
+
+        Channel = ch;
+        Message = ctx.Message;
+        
+        
+        _ebs = new(_services.GetRequiredService<IEmbedBuilderService>());
+        _botStrings = new(_services.GetRequiredService<IBotStrings>);
+        _localization = new(_services.GetRequiredService<ILocalization>());
+    }
+
+    public override IEmbedBuilder Embed()
+        => _ebs.Value.Create();
+
+    public override string GetText(string key, object[]? args = null)
+    {
+        var cultureInfo = _localization.Value.GetCultureInfo(default(ulong?));
+        var output = Strings.GetText(key, cultureInfo, args ?? Array.Empty<object>());
+        if (!string.IsNullOrWhiteSpace(output))
+            return output;
+        
+        return _botStrings.Value.GetText(key, cultureInfo, args);
+    }
+}

src/NadekoBot/Common/Medusa/Adapters/GuildContextAdapter.cs

@@ -0,0 +1,51 @@
+using Microsoft.Extensions.DependencyInjection;
+
+public sealed class GuildContextAdapter : GuildContext
+{
+    private readonly IServiceProvider _services;
+    private readonly ICommandContext _ctx;
+    private readonly Lazy<IEmbedBuilderService> _ebs;
+    private readonly Lazy<IBotStrings> _botStrings;
+    private readonly Lazy<ILocalization> _localization;
+    
+    public override IMedusaStrings Strings { get; }
+    public override IGuild Guild { get; }
+    public override ITextChannel Channel { get; }
+    public override IUserMessage Message
+        => _ctx.Message;
+
+    public override IGuildUser User { get; } 
+
+    public override IEmbedBuilder Embed()
+        => _ebs.Value.Create();
+
+    public GuildContextAdapter(ICommandContext ctx, IMedusaStrings strings, IServiceProvider services)
+    {
+        if (ctx.Guild is not IGuild guild || ctx.Channel is not ITextChannel channel)
+        {
+            throw new ArgumentException("Can't use non-guild context to create GuildContextAdapter", nameof(ctx));
+        }
+
+        Strings = strings;
+        User = (IGuildUser)ctx.User;
+
+        _services = services;
+        _ebs = new(_services.GetRequiredService<IEmbedBuilderService>());
+        _botStrings = new(_services.GetRequiredService<IBotStrings>);
+        _localization = new(_services.GetRequiredService<ILocalization>());
+
+        (_ctx, Guild, Channel) = (ctx, guild, channel);
+    }
+
+    public override string GetText(string key, object[]? args = null)
+    {
+        args ??= Array.Empty<object>();
+        
+        var cultureInfo = _localization.Value.GetCultureInfo(_ctx.Guild.Id);
+        var output = Strings.GetText(key, cultureInfo, args);
+        if (!string.IsNullOrWhiteSpace(output))
+            return output;
+        
+        return _botStrings.Value.GetText(key, cultureInfo, args);
+    }
+}

src/NadekoBot/Common/Medusa/Adapters/ParamParserAdapter.cs

@@ -0,0 +1,32 @@
+public sealed class ParamParserAdapter<T> : TypeReader
+{
+    private readonly ParamParser<T> _parser;
+    private readonly IMedusaStrings _strings;
+    private readonly IServiceProvider _services;
+
+    public ParamParserAdapter(ParamParser<T> parser,
+        IMedusaStrings strings,
+        IServiceProvider services)
+    {
+        _parser = parser;
+        _strings = strings;
+        _services = services;
+    }
+
+    public override async Task<Discord.Commands.TypeReaderResult> ReadAsync(
+        ICommandContext context,
+        string input,
+        IServiceProvider services)
+    {
+        var medusaContext = ContextAdapterFactory.CreateNew(context,
+            _strings,
+            _services);
+        
+        var result = await _parser.TryParseAsync(medusaContext, input);
+        
+        if(result.IsSuccess)
+            return Discord.Commands.TypeReaderResult.FromSuccess(result.Data);
+        
+        return Discord.Commands.TypeReaderResult.FromError(CommandError.Unsuccessful, "Invalid input");
+    }
+}

src/NadekoBot/Common/Medusa/CommandContextType.cs

@@ -0,0 +1,27 @@
+namespace Nadeko.Medusa;
+
+/// <summary>
+/// Enum specifying in which context the command can be executed
+/// </summary>
+public enum CommandContextType
+{
+    /// <summary>
+    /// Command can only be executed in a guild
+    /// </summary>
+    Guild,
+    
+    /// <summary>
+    /// Command can only be executed in DMs
+    /// </summary>
+    Dm,
+    
+    /// <summary>
+    /// Command can be executed anywhere
+    /// </summary>
+    Any,
+    
+    /// <summary>
+    /// Command can be executed anywhere, and it doesn't require context to be passed to it
+    /// </summary>
+    Unspecified
+}

src/NadekoBot/Common/Medusa/Config/IMedusaConfigService.cs

@@ -0,0 +1,8 @@
+namespace Nadeko.Medusa;
+
+public interface IMedusaConfigService
+{
+    IReadOnlyCollection<string> GetLoadedMedusae();
+    void AddLoadedMedusa(string name);
+    void RemoveLoadedMedusa(string name);
+}

src/NadekoBot/Common/Medusa/Config/MedusaConfig.cs

@@ -0,0 +1,20 @@
+#nullable enable
+using Cloneable;
+using NadekoBot.Common.Yml;
+
+namespace Nadeko.Medusa;
+
+[Cloneable]
+public sealed partial class MedusaConfig : ICloneable<MedusaConfig>
+{
+    [Comment(@"DO NOT CHANGE")]
+    public int Version { get; set; } = 1;
+    
+    [Comment("List of medusae automatically loaded at startup")]
+    public List<string>? Loaded { get; set; }
+
+    public MedusaConfig()
+    {
+        Loaded = new();
+    }
+}

src/NadekoBot/Common/Medusa/Config/MedusaConfigService.cs

@@ -0,0 +1,49 @@
+using NadekoBot.Common.Configs;
+
+namespace Nadeko.Medusa;
+
+public sealed class MedusaConfigService : ConfigServiceBase<MedusaConfig>, IMedusaConfigService
+{
+    private const string FILE_PATH = "data/medusae/medusa.yml";
+    private static readonly TypedKey<MedusaConfig> _changeKey = new("config.medusa.updated");
+
+    public override string Name
+        => "medusa";
+
+    public MedusaConfigService(
+        IConfigSeria serializer,
+        IPubSub pubSub)
+        : base(FILE_PATH, serializer, pubSub, _changeKey)
+    {   
+    }
+
+    public IReadOnlyCollection<string> GetLoadedMedusae()
+        => Data.Loaded?.ToList() ?? new List<string>();
+
+    public void AddLoadedMedusa(string name)
+    {
+        name = name.Trim().ToLowerInvariant();
+        
+        ModifyConfig(conf =>
+        {
+            if (conf.Loaded is null)
+                conf.Loaded = new();
+            
+            if(!conf.Loaded.Contains(name))
+                conf.Loaded.Add(name);
+        });
+    }
+    
+    public void RemoveLoadedMedusa(string name)
+    {
+        name = name.Trim().ToLowerInvariant();
+        
+        ModifyConfig(conf =>
+        {
+            if (conf.Loaded is null)
+                conf.Loaded = new();
+            
+            conf.Loaded.Remove(name);
+        });
+    }
+}

src/NadekoBot/Common/Medusa/IMedusaLoaderService.cs

@@ -0,0 +1,23 @@
+using System.Globalization;
+
+namespace Nadeko.Medusa;
+
+public interface IMedusaLoaderService
+{
+    Task<MedusaLoadResult> LoadMedusaAsync(string medusaName);
+    Task<MedusaUnloadResult> UnloadMedusaAsync(string medusaName);
+    string GetCommandDescription(string medusaName, string commandName, CultureInfo culture);
+    string[] GetCommandExampleArgs(string medusaName, string commandName, CultureInfo culture);
+    Task ReloadStrings();
+    IReadOnlyCollection<string> GetAllMedusae();
+    IReadOnlyCollection<MedusaStats> GetLoadedMedusae(CultureInfo? cultureInfo = null);
+}
+
+public sealed record MedusaStats(string Name,
+    string? Description,
+    IReadOnlyCollection<SnekStats> Sneks);
+    
+public sealed record SnekStats(string Name, 
+    IReadOnlyCollection<SnekCommandStats> Commands);
+
+public sealed record SnekCommandStats(string Name);

src/NadekoBot/Common/Medusa/MedusaAssemblyLoadContext.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace Nadeko.Medusa;
+
+public sealed class MedusaAssemblyLoadContext : AssemblyLoadContext
+{
+    private readonly AssemblyDependencyResolver _depResolver;
+
+    public MedusaAssemblyLoadContext(string pluginPath) : base(isCollectible: true)
+    {
+        _depResolver = new(pluginPath);
+    }
+
+    protected override Assembly? Load(AssemblyName assemblyName)
+    {
+        var assemblyPath = _depResolver.ResolveAssemblyToPath(assemblyName);
+        if (assemblyPath != null)
+        {
+            return LoadFromAssemblyPath(assemblyPath);
+        }
+
+        return null;
+    }
+
+    protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
+    {
+        var libraryPath = _depResolver.ResolveUnmanagedDllToPath(unmanagedDllName);
+        if (libraryPath != null)
+        {
+            return LoadUnmanagedDllFromPath(libraryPath);
+        }
+
+        return IntPtr.Zero;
+    }
+}

src/NadekoBot/Common/Medusa/MedusaLoaderService.cs

@@ -0,0 +1,877 @@
+using Discord.Commands.Builders;
+using Microsoft.Extensions.DependencyInjection;
+using NadekoBot.Common.ModuleBehaviors;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Nadeko.Medusa;
+
+// ReSharper disable RedundantAssignment
+public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor, INService
+{
+    private readonly CommandService _cmdService;
+    private readonly IServiceProvider _botServices;
+    private readonly IBehaviorHandler _behHandler;
+    private readonly IPubSub _pubSub;
+    private readonly IMedusaConfigService _medusaConfig;
+    
+    private readonly ConcurrentDictionary<string, ResolvedMedusa> _resolved = new();
+    private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
+
+    private readonly TypedKey<string> _loadKey = new("medusa:load");
+    private readonly TypedKey<string> _unloadKey = new("medusa:unload");
+    
+    private readonly TypedKey<bool> _stringsReload = new("medusa:reload_strings");
+
+    private const string BASE_DIR = "data/medusae";
+
+    public MedusaLoaderService(CommandService cmdService,
+        IServiceProvider botServices,
+        IBehaviorHandler behHandler,
+        IPubSub pubSub,
+        IMedusaConfigService medusaConfig)
+    {
+        _cmdService = cmdService;
+        _botServices = botServices;
+        _behHandler = behHandler;
+        _pubSub = pubSub;
+        _medusaConfig = medusaConfig;
+        
+        // has to be done this way to support this feature on sharded bots
+        _pubSub.Sub(_loadKey, async name => await InternalLoadAsync(name));
+        _pubSub.Sub(_unloadKey, async name => await InternalUnloadAsync(name));
+
+        _pubSub.Sub(_stringsReload, async _ => await ReloadStringsInternal());
+    }
+
+    public IReadOnlyCollection<string> GetAllMedusae()
+    {
+        if (!Directory.Exists(BASE_DIR))
+            return Array.Empty<string>();
+
+        return Directory.GetDirectories(BASE_DIR)
+                        .Select(x => Path.GetRelativePath(BASE_DIR, x))
+                        .ToArray();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public IReadOnlyCollection<MedusaStats> GetLoadedMedusae(CultureInfo? culture)
+    {
+        var toReturn = new List<MedusaStats>(_resolved.Count);
+        foreach (var (name, resolvedData) in _resolved)
+        {
+            var sneks = new List<SnekStats>(resolvedData.SnekInfos.Count);
+
+            foreach (var snekInfos in resolvedData.SnekInfos.Concat(resolvedData.SnekInfos.SelectMany(x => x.Subsneks)))
+            {
+                var commands = new List<SnekCommandStats>();
+
+                foreach (var command in snekInfos.Commands)
+                {
+                    commands.Add(new SnekCommandStats(command.Aliases.First()));
+                }
+                
+                sneks.Add(new SnekStats(snekInfos.Name, commands));
+            }
+
+            toReturn.Add(new MedusaStats(name, resolvedData.Strings.GetDescription(culture), sneks));
+        }
+        return toReturn;
+    }
+
+    public async Task OnReadyAsync()
+    {
+        foreach (var name in _medusaConfig.GetLoadedMedusae())
+        {
+            var result = await InternalLoadAsync(name);
+            if(result != MedusaLoadResult.Success)
+                Log.Warning("Unable to load '{MedusaName}' medusa", name);
+            else 
+                Log.Warning("Loaded medusa '{MedusaName}'", name);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public async Task<MedusaLoadResult> LoadMedusaAsync(string medusaName)
+    {
+        // try loading on this shard first to see if it works
+        var res = await InternalLoadAsync(medusaName);
+        if (res == MedusaLoadResult.Success)
+        {
+            // if it does publish it so that other shards can load the medusa too
+            // this method will be ran twice on this shard but it doesn't matter as 
+            // the second attempt will be ignored
+            await _pubSub.Pub(_loadKey, medusaName);
+        }
+
+        return res;
+    }
+    
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public async Task<MedusaUnloadResult> UnloadMedusaAsync(string medusaName)
+    {
+        var res = await InternalUnloadAsync(medusaName);
+        if (res == MedusaUnloadResult.Success)
+        {
+            await _pubSub.Pub(_unloadKey, medusaName);
+        }
+
+        return res;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public string[] GetCommandExampleArgs(string medusaName, string commandName, CultureInfo culture)
+    {
+        if (!_resolved.TryGetValue(medusaName, out var data))
+            return Array.Empty<string>();
+
+        return data.Strings.GetCommandStrings(commandName, culture).Args
+               ?? data.SnekInfos
+                      .SelectMany(x => x.Commands)
+                      .FirstOrDefault(x => x.Aliases.Any(alias
+                          => alias.Equals(commandName, StringComparison.InvariantCultureIgnoreCase)))
+                      ?.OptionalStrings
+                      .Args
+               ?? new[] { string.Empty };
+    }
+
+    public Task ReloadStrings()
+        => _pubSub.Pub(_stringsReload, true);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void ReloadStringsSync()
+    {
+        foreach (var resolved in _resolved.Values)
+        {
+            resolved.Strings.Reload();
+        }
+    }
+    
+    private async Task ReloadStringsInternal()
+    {
+        await _lock.WaitAsync();
+        try
+        {
+            ReloadStringsSync();
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public string GetCommandDescription(string medusaName, string commandName, CultureInfo culture)
+    {
+        if (!_resolved.TryGetValue(medusaName, out var data))
+            return string.Empty;
+
+        return data.Strings.GetCommandStrings(commandName, culture).Desc
+               ?? data.SnekInfos
+                      .SelectMany(x => x.Commands)
+                      .FirstOrDefault(x => x.Aliases.Any(alias
+                          => alias.Equals(commandName, StringComparison.InvariantCultureIgnoreCase)))
+                      ?.OptionalStrings
+                      .Desc
+               ?? string.Empty;
+    }
+    
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private async ValueTask<MedusaLoadResult> InternalLoadAsync(string name)
+    {
+        if (_resolved.ContainsKey(name))
+            return MedusaLoadResult.AlreadyLoaded;
+        
+        var safeName = Uri.EscapeDataString(name);
+        name = name.ToLowerInvariant();
+
+        await _lock.WaitAsync();
+        try
+        {
+            if (LoadAssemblyInternal(safeName,
+                    out var ctx,
+                    out var snekData,
+                    out var services,
+                    out var strings,
+                    out var typeReaders))
+            {
+                var moduleInfos = new List<ModuleInfo>();
+
+                LoadTypeReadersInternal(typeReaders);
+
+                foreach (var point in snekData)
+                {
+                    try
+                    {
+                        // initialize snek and subsneks
+                        await point.Instance.InitializeAsync();
+                        foreach (var sub in point.Subsneks)
+                        {
+                            await sub.Instance.InitializeAsync();
+                        }
+
+                        var module = await LoadModuleInternalAsync(name, point, strings, services);
+                        moduleInfos.Add(module);
+                    }
+                    catch (Exception ex)
+                    {
+                        Log.Warning(ex,
+                            "Error loading snek {SnekName}",
+                            point.Name);
+                    }
+                }
+
+                var execs = GetExecsInternal(snekData, strings, services);
+                await _behHandler.AddRangeAsync(execs);
+
+                _resolved[name] = new(LoadContext: ctx,
+                    ModuleInfos: moduleInfos.ToImmutableArray(),
+                    SnekInfos: snekData.ToImmutableArray(),
+                    strings,
+                    typeReaders,
+                    execs)
+                {
+                    Services = services
+                };
+
+                
+                services = null;
+                _medusaConfig.AddLoadedMedusa(safeName);
+                return MedusaLoadResult.Success;
+            }
+
+            return MedusaLoadResult.Empty;
+        }
+        catch (Exception ex) when (ex is FileNotFoundException or BadImageFormatException)
+        {
+            return MedusaLoadResult.NotFound;
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "An error occurred loading a medusa");
+            return MedusaLoadResult.UnknownError;
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private IReadOnlyCollection<ICustomBehavior> GetExecsInternal(IReadOnlyCollection<SnekInfo> snekData, IMedusaStrings strings, IServiceProvider services)
+    {
+        var behs = new List<ICustomBehavior>();
+        foreach (var snek in snekData)
+        {
+            behs.Add(new BehaviorAdapter(new(snek.Instance), strings, services));
+
+            foreach (var sub in snek.Subsneks)
+            {
+                behs.Add(new BehaviorAdapter(new(sub.Instance), strings, services));
+            }
+        }
+
+        
+        return behs;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void LoadTypeReadersInternal(Dictionary<Type, TypeReader> typeReaders)
+    {
+        var notAddedTypeReaders = new List<Type>();
+        foreach (var (type, typeReader) in typeReaders)
+        {
+            // if type reader for this type already exists, it will not be replaced
+            if (_cmdService.TypeReaders.Contains(type))
+            {
+                notAddedTypeReaders.Add(type);
+                continue;
+            }
+    
+            _cmdService.AddTypeReader(type, typeReader);
+        }
+    
+        // remove the ones that were not added
+        // to prevent them from being unloaded later
+        // as they didn't come from this medusa
+        foreach (var toRemove in notAddedTypeReaders)
+        {
+            typeReaders.Remove(toRemove);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private bool LoadAssemblyInternal(
+        string safeName,
+        [NotNullWhen(true)] out WeakReference<MedusaAssemblyLoadContext>? ctxWr,
+        [NotNullWhen(true)] out IReadOnlyCollection<SnekInfo>? snekData,
+        out IServiceProvider services,
+        out IMedusaStrings strings,
+        out Dictionary<Type, TypeReader> typeReaders)
+    {
+        ctxWr = null;
+        snekData = null;
+        
+        var path = $"{BASE_DIR}/{safeName}/{safeName}.dll";
+        strings = MedusaStrings.CreateDefault($"{BASE_DIR}/{safeName}");
+        var ctx = new MedusaAssemblyLoadContext(Path.GetDirectoryName(path)!);
+        var a = ctx.LoadFromAssemblyPath(Path.GetFullPath(path));
+        var sis = LoadSneksFromAssembly(a, out services);
+        typeReaders = LoadTypeReadersFromAssembly(a, strings, services);
+
+        if (sis.Count == 0)
+        {
+            return false;
+        }
+
+        ctxWr = new(ctx);
+        snekData = sis;
+        
+        return true;
+    }
+
+    private static readonly Type _paramParserType = typeof(ParamParser<>);
+    
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private Dictionary<Type, TypeReader> LoadTypeReadersFromAssembly(
+        Assembly assembly,
+        IMedusaStrings strings,
+        IServiceProvider services)
+    {
+        var paramParsers = assembly.GetExportedTypes()
+                .Where(x => x.IsClass
+                            && !x.IsAbstract
+                            && x.BaseType is not null
+                            && x.BaseType.IsGenericType
+                            && x.BaseType.GetGenericTypeDefinition() == _paramParserType);
+
+        var typeReaders = new Dictionary<Type, TypeReader>();
+        foreach (var parserType in paramParsers)
+        {
+            var parserObj = ActivatorUtilities.CreateInstance(services, parserType);
+
+            var targetType = parserType.BaseType!.GetGenericArguments()[0];
+            var typeReaderInstance = (TypeReader)Activator.CreateInstance(
+                typeof(ParamParserAdapter<>).MakeGenericType(targetType),
+                args: new[] { parserObj, strings, services })!;
+            
+            typeReaders.Add(targetType, typeReaderInstance);
+        }
+
+        return typeReaders;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private async Task<ModuleInfo> LoadModuleInternalAsync(string medusaName, SnekInfo snekInfo, IMedusaStrings strings, IServiceProvider services)
+    {
+        var module = await _cmdService.CreateModuleAsync(snekInfo.Instance.Prefix,
+            CreateModuleFactory(medusaName, snekInfo, strings, services));
+        
+        return module;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private Action<ModuleBuilder> CreateModuleFactory(
+        string medusaName,
+        SnekInfo snekInfo,
+        IMedusaStrings strings,
+        IServiceProvider medusaServices)
+        => mb =>
+        {
+            var m = mb.WithName(snekInfo.Name);
+
+            foreach (var cmd in snekInfo.Commands)
+            {
+                m.AddCommand(cmd.Aliases.First(),
+                    CreateCallback(cmd.ContextType,
+                        new(snekInfo),
+                        new(cmd),
+                        new(medusaServices),
+                        strings),
+                    CreateCommandFactory(medusaName, cmd));
+            }
+
+            foreach (var subInfo in snekInfo.Subsneks)
+                m.AddModule(subInfo.Instance.Prefix, CreateModuleFactory(medusaName, subInfo, strings, medusaServices));
+        };
+
+    private static readonly RequireContextAttribute _reqGuild = new RequireContextAttribute(ContextType.Guild);
+    private static readonly RequireContextAttribute _reqDm = new RequireContextAttribute(ContextType.DM);
+    private Action<CommandBuilder> CreateCommandFactory(string medusaName, SnekCommandData cmd)
+        => (cb) =>
+        {
+            cb.AddAliases(cmd.Aliases.Skip(1).ToArray());
+
+            if (cmd.ContextType == CommandContextType.Guild)
+                cb.AddPrecondition(_reqGuild);
+            else if (cmd.ContextType == CommandContextType.Dm)
+                cb.AddPrecondition(_reqDm);
+
+            cb.WithPriority(cmd.Priority);
+            
+            // using summary to save method name
+            // method name is used to retrieve desc/usages
+            cb.WithRemarks($"medusa///{medusaName}");
+            cb.WithSummary(cmd.MethodInfo.Name.ToLowerInvariant());
+            
+            foreach (var param in cmd.Parameters)
+            {
+                cb.AddParameter(param.Name, param.Type, CreateParamFactory(param));
+            }
+        };
+
+    private Action<ParameterBuilder> CreateParamFactory(ParamData paramData)
+        => (pb) =>
+        {
+            pb.WithIsMultiple(paramData.IsParams)
+              .WithIsOptional(paramData.IsOptional)
+              .WithIsRemainder(paramData.IsLeftover);
+        };
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private Func<ICommandContext, object[], IServiceProvider, CommandInfo, Task> CreateCallback(
+        CommandContextType contextType,
+        WeakReference<SnekInfo> snekDataWr,
+        WeakReference<SnekCommandData> snekCommandDataWr,
+        WeakReference<IServiceProvider> medusaServicesWr,
+        IMedusaStrings strings)
+        => async (context, parameters, svcs, _) =>
+        {
+            if (!snekCommandDataWr.TryGetTarget(out var cmdData)
+                || !snekDataWr.TryGetTarget(out var snekData)
+                || !medusaServicesWr.TryGetTarget(out var medusaServices))
+            {
+                Log.Warning("Attempted to run an unloaded snek's command");
+                return;
+            }
+                
+            var paramObjs = ParamObjs(contextType, cmdData, parameters, context, svcs, medusaServices, strings);
+
+            try
+            {
+                var methodInfo = cmdData.MethodInfo;
+                if (methodInfo.ReturnType == typeof(Task)
+                    || (methodInfo.ReturnType.IsGenericType
+                        && methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(Task<>)))
+                {
+                    await (Task)methodInfo.Invoke(snekData.Instance, paramObjs)!;
+                }
+                else if (methodInfo.ReturnType == typeof(ValueTask))
+                {
+                    await ((ValueTask)methodInfo.Invoke(snekData.Instance, paramObjs)!).AsTask();
+                }
+                else // if (methodInfo.ReturnType == typeof(void))
+                {
+                    methodInfo.Invoke(snekData.Instance, paramObjs);
+                }
+            }
+            finally
+            {
+                paramObjs = null;
+                cmdData = null;
+                
+                snekData = null;
+                medusaServices = null;
+            }
+        };
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static object[] ParamObjs(
+        CommandContextType contextType,
+        SnekCommandData cmdData,
+        object[] parameters,
+        ICommandContext context,
+        IServiceProvider svcs,
+        IServiceProvider svcProvider,
+        IMedusaStrings strings)
+    {
+        var extraParams = contextType == CommandContextType.Unspecified ? 0 : 1;
+        extraParams += cmdData.InjectedParams.Count;
+
+        var paramObjs = new object[parameters.Length + extraParams];
+
+        var startAt = 0;
+        if (contextType != CommandContextType.Unspecified)
+        {
+            paramObjs[0] = ContextAdapterFactory.CreateNew(context, strings, svcs);
+
+            startAt = 1;
+        }
+
+        for (var i = 0; i < cmdData.InjectedParams.Count; i++)
+        {
+            var svc = svcProvider.GetService(cmdData.InjectedParams[i]);
+            if (svc is null)
+            {
+                throw new ArgumentException($"Cannot inject a service of type {cmdData.InjectedParams[i]}");
+            }
+
+            paramObjs[i + startAt] = svc;
+
+            svc = null;
+        }
+
+        startAt += cmdData.InjectedParams.Count;
+
+        for (var i = 0; i < parameters.Length; i++)
+            paramObjs[startAt + i] = parameters[i];
+        
+        return paramObjs;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private async Task<MedusaUnloadResult> InternalUnloadAsync(string name)
+    {
+        name = name.ToLowerInvariant();
+        if (!_resolved.Remove(name, out var lsi))
+            return MedusaUnloadResult.NotLoaded;
+
+        await _lock.WaitAsync();
+        try
+        {
+            UnloadTypeReaders(lsi.TypeReaders);
+
+            foreach (var mi in lsi.ModuleInfos)
+            {
+                await _cmdService.RemoveModuleAsync(mi);
+            }
+
+            await _behHandler.RemoveRangeAsync(lsi.Execs);
+            
+            await DisposeSnekInstances(lsi);
+
+            var lc = lsi.LoadContext;
+
+            // removing this line will prevent assembly from being unloaded quickly
+            // as this local variable will be held for a long time potentially
+            // due to how async works
+            lsi.Services = null!;
+            lsi = null;
+            
+            _medusaConfig.RemoveLoadedMedusa(name);
+            return UnloadInternal(lc)
+                ? MedusaUnloadResult.Success
+                : MedusaUnloadResult.PossiblyUnable;
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+
+    private void UnloadTypeReaders(Dictionary<Type, TypeReader> valueTypeReaders)
+    {
+        foreach (var tr in valueTypeReaders)
+        {
+            _cmdService.TryRemoveTypeReader(tr.Key, false, out _);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private async Task DisposeSnekInstances(ResolvedMedusa medusa)
+    {
+        foreach (var si in medusa.SnekInfos)
+        {
+            try
+            {
+                await si.Instance.DisposeAsync();
+                foreach (var sub in si.Subsneks)
+                {
+                    await sub.Instance.DisposeAsync();
+                }  
+            }
+            catch (Exception ex)
+            {
+                Log.Warning(ex,
+                    "Failed cleanup of Snek {SnekName}. This medusa might not unload correctly",
+                    si.Instance.Name);
+            }
+        }
+
+        // medusae = null;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private bool UnloadInternal(WeakReference<MedusaAssemblyLoadContext> lsi)
+    {
+        UnloadContext(lsi);
+        GcCleanup();
+
+        return !lsi.TryGetTarget(out _);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void UnloadContext(WeakReference<MedusaAssemblyLoadContext> lsiLoadContext)
+    {
+        if(lsiLoadContext.TryGetTarget(out var ctx))
+            ctx.Unload();
+    }
+    
+    private void GcCleanup()
+    {
+        // cleanup
+        for (var i = 0; i < 10; i++)
+        {
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            GC.WaitForFullGCComplete();
+            GC.Collect();
+        }
+    }
+
+    private static readonly Type _snekType = typeof(Snek);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private IServiceProvider LoadMedusaServicesInternal(Assembly a)
+        => new ServiceCollection()
+           .Scan(x => x.FromAssemblies(a)
+                       .AddClasses(static x => x.WithAttribute<svcAttribute>(x => x.Lifetime == Lifetime.Transient))
+                       .AsSelfWithInterfaces()
+                       .WithTransientLifetime()
+                       .AddClasses(static x => x.WithAttribute<svcAttribute>(x => x.Lifetime == Lifetime.Singleton))
+                       .AsSelfWithInterfaces()
+                       .WithSingletonLifetime())
+           .BuildServiceProvider();
+
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public IReadOnlyCollection<SnekInfo> LoadSneksFromAssembly(Assembly a, out IServiceProvider services)
+    {
+        var medusaServices = LoadMedusaServicesInternal(a);
+        services = new MedusaServiceProvider(_botServices, medusaServices);
+        
+        // find all types in teh assembly
+        var types = a.GetExportedTypes();
+        // snek is always a public non abstract class
+        var classes = types.Where(static x => x.IsClass
+                                              && (x.IsNestedPublic || x.IsPublic)
+                                              && !x.IsAbstract
+                                              && x.BaseType == _snekType
+                                              && (x.DeclaringType is null || x.DeclaringType.IsAssignableTo(_snekType)))
+                           .ToList();
+
+        var topModules = new Dictionary<Type, SnekInfo>();
+        
+        foreach (var cl in classes)
+        {
+            if (cl.DeclaringType is not null)
+                continue;
+            
+            // get module data, and add it to the topModules dictionary
+            var module = GetModuleData(cl, services);
+            topModules.Add(cl, module);
+        }
+
+        foreach (var c in classes)
+        {
+            if (c.DeclaringType is not Type dt)
+                continue;
+
+            // if there is no top level module which this module is a child of
+            // just print a warning and skip it
+            if (!topModules.TryGetValue(dt, out var parentData))
+            {
+                Log.Warning("Can't load submodule {SubName} because parent module {Name} does not exist",
+                    c.Name,
+                    dt.Name);
+                continue;
+            }
+            
+            GetModuleData(c, services, parentData);
+        }
+
+        return topModules.Values.ToArray();
+    }
+    
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private SnekInfo GetModuleData(Type type, IServiceProvider services, SnekInfo? parentData = null)
+    {
+        var filters = type.GetCustomAttributes<FilterAttribute>(true)
+                          .ToArray();
+        
+        var instance = (Snek)ActivatorUtilities.CreateInstance(services, type);
+        
+        var module = new SnekInfo(instance.Name,
+            parentData,
+            instance,
+            GetCommands(instance, type),
+            filters);
+
+        if (parentData is not null)
+            parentData.Subsneks.Add(module);
+
+        return module;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private IReadOnlyCollection<SnekCommandData> GetCommands(Snek instance, Type type)
+    {
+        var methodInfos = type
+                          .GetMethods(BindingFlags.Instance
+                                      | BindingFlags.DeclaredOnly
+                                      | BindingFlags.Public)
+                          .Where(static x =>
+                          {
+                              if(x.GetCustomAttribute<cmdAttribute>(true) is null)
+                                  return false;
+
+                              if (x.ReturnType.IsGenericType)
+                              {
+                                  var genericType = x.ReturnType.GetGenericTypeDefinition();
+                                  if (genericType == typeof(Task<>))
+                                      return true;
+                              
+                                  // if (genericType == typeof(ValueTask<>))
+                                  //     return true;
+
+                                  Log.Warning("Method {MethodName} has an invalid return type: {ReturnType}",
+                                      x.Name,
+                                      x.ReturnType);
+                                  
+                                  return false;
+                              }
+
+                              var succ = x.ReturnType == typeof(Task)
+                                         || x.ReturnType == typeof(ValueTask)
+                                         || x.ReturnType == typeof(void);
+
+                              if (!succ)
+                              {
+                                  Log.Warning("Method {MethodName} has an invalid return type: {ReturnType}",
+                                      x.Name,
+                                      x.ReturnType);
+                              }
+
+                              return succ;
+                          });
+        
+        
+        var cmds = new List<SnekCommandData>();
+        foreach (var method in methodInfos)
+        {
+            var filters = method.GetCustomAttributes<FilterAttribute>().ToArray();
+            var prio = method.GetCustomAttribute<prioAttribute>()?.Priority ?? 0;
+
+            var paramInfos = method.GetParameters();
+            var cmdParams = new List<ParamData>();
+            var diParams = new List<Type>();
+            var cmdContext = CommandContextType.Unspecified;
+            var canInject = false;
+            for (var paramCounter = 0; paramCounter < paramInfos.Length; paramCounter++)
+            {
+                var pi = paramInfos[paramCounter];
+
+                var paramName = pi.Name ?? "unnamed";
+                var isContext = paramCounter == 0 && pi.ParameterType.IsAssignableTo(typeof(AnyContext));
+
+                var leftoverAttribute = pi.GetCustomAttribute<leftoverAttribute>(true);
+                var hasDefaultValue = pi.HasDefaultValue;
+                var isLeftover = leftoverAttribute != null;
+                var isParams = pi.GetCustomAttribute<ParamArrayAttribute>() is not null;
+                var paramType = pi.ParameterType;
+                var isInjected = pi.GetCustomAttribute<injectAttribute>(true) is not null;
+
+                if (isContext)
+                {
+                    if (hasDefaultValue || leftoverAttribute != null || isParams)
+                        throw new ArgumentException("IContext parameter cannot be optional, leftover, constant or params. " + GetErrorPath(method, pi));
+
+                    if (paramCounter != 0)
+                        throw new ArgumentException($"IContext parameter has to be first. {GetErrorPath(method, pi)}");
+
+                    canInject = true;
+                    
+                    if (paramType.IsAssignableTo(typeof(GuildContext)))
+                        cmdContext = CommandContextType.Guild;
+                    else if (paramType.IsAssignableTo(typeof(DmContext)))
+                        cmdContext = CommandContextType.Dm;
+                    else
+                        cmdContext = CommandContextType.Any;
+                    
+                    continue;
+                }
+
+                if (isInjected)
+                {
+                    if (!canInject && paramCounter != 0)
+                        throw new ArgumentException($"Parameters marked as [Injected] have to come after IContext");
+
+                    canInject = true;
+                    
+                    diParams.Add(paramType);
+                    continue;
+                }
+
+                canInject = false;
+
+                if (isParams)
+                {
+                    if (hasDefaultValue)
+                        throw new NotSupportedException("Params can't have const values at the moment. "
+                                                        + GetErrorPath(method, pi));
+                    // if it's params, it means it's an array, and i only need a parser for the actual type,
+                    // as the parser will run on each array element, it can't be null
+                    paramType = paramType.GetElementType()!;
+                }
+
+                // leftover can only be the last parameter.
+                if (isLeftover && paramCounter != paramInfos.Length - 1)
+                {
+                    var path = GetErrorPath(method, pi);
+                    Log.Error("Only one parameter can be marked [Leftover] and it has to be the last one. {Path} ",
+                        path);
+                    throw new ArgumentException("Leftover attribute error.");
+                }
+
+                cmdParams.Add(new ParamData(paramType, paramName, hasDefaultValue, isLeftover, isParams));
+            }
+
+
+            var cmdAttribute = method.GetCustomAttribute<cmdAttribute>()!; 
+            var aliases = cmdAttribute.Aliases;
+            if (aliases.Length == 0)
+                aliases = new[] { method.Name.ToLowerInvariant() };
+            
+            cmds.Add(new(
+                aliases,
+                method,
+                instance,
+                filters,
+                cmdContext,
+                diParams,
+                cmdParams,
+                new(cmdAttribute.desc, cmdAttribute.args),
+                prio
+            ));
+        }
+
+        return cmds;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private string GetErrorPath(MethodInfo m, System.Reflection.ParameterInfo pi)
+        => $@"Module: {m.DeclaringType?.Name} 
+Command: {m.Name}
+ParamName: {pi.Name}
+ParamType: {pi.ParameterType.Name}";
+}
+
+public enum MedusaLoadResult
+{
+    Success,
+    NotFound,
+    AlreadyLoaded,
+    Empty,
+    UnknownError,
+}
+
+public enum MedusaUnloadResult
+{
+    Success,
+    NotLoaded,
+    PossiblyUnable,
+    NotFound,
+}

src/NadekoBot/Common/Medusa/MedusaServiceProvider.cs

@@ -0,0 +1,24 @@
+using System.Runtime.CompilerServices;
+
+namespace Nadeko.Medusa;
+
+public class MedusaServiceProvider : IServiceProvider
+{
+    private readonly IServiceProvider _nadekoServices;
+    private readonly IServiceProvider _medusaServices;
+
+    public MedusaServiceProvider(IServiceProvider nadekoServices, IServiceProvider medusaServices)
+    {
+        _nadekoServices = nadekoServices;
+        _medusaServices = medusaServices;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public object? GetService(Type serviceType)
+    {
+        if (!serviceType.Assembly.IsCollectible)
+            return _nadekoServices.GetService(serviceType);
+
+        return _medusaServices.GetService(serviceType);
+    }
+}

src/NadekoBot/Common/Medusa/Models/ParamData.cs

@@ -0,0 +1,9 @@
+namespace Nadeko.Medusa;
+
+public sealed record ParamData(
+    Type Type,
+    string Name,
+    bool IsOptional,
+    bool IsLeftover,
+    bool IsParams
+);

src/NadekoBot/Common/Medusa/Models/ResolvedMedusa.cs

@@ -0,0 +1,14 @@
+using System.Collections.Immutable;
+
+namespace Nadeko.Medusa;
+
+public sealed record ResolvedMedusa(
+    WeakReference<MedusaAssemblyLoadContext> LoadContext,
+    IImmutableList<ModuleInfo> ModuleInfos,
+    IImmutableList<SnekInfo> SnekInfos,
+    IMedusaStrings Strings,
+    Dictionary<Type, TypeReader> TypeReaders,
+    IReadOnlyCollection<ICustomBehavior> Execs)
+{
+    public IServiceProvider Services { get; set; } = null!;
+}

src/NadekoBot/Common/Medusa/Models/SnekCommandData.cs

@@ -0,0 +1,41 @@
+using Microsoft.VisualBasic;
+using System.Reflection;
+using CommandStrings = Nadeko.Snake.CommandStrings;
+
+namespace Nadeko.Medusa;
+
+public sealed class SnekCommandData
+{
+    public SnekCommandData(
+        IReadOnlyCollection<string> aliases,
+        MethodInfo methodInfo,
+        Snek module,
+        FilterAttribute[] filters,
+        CommandContextType contextType,
+        IReadOnlyList<Type> injectedParams,
+        IReadOnlyList<ParamData> parameters,
+        CommandStrings strings,
+        int priority)
+    {
+        Aliases = aliases;
+        MethodInfo = methodInfo;
+        Module = module;
+        Filters = filters;
+        ContextType = contextType;
+        InjectedParams = injectedParams;
+        Parameters = parameters;
+        Priority = priority;
+        OptionalStrings = strings;
+    }
+
+    public CommandStrings OptionalStrings { get; set; }
+
+    public IReadOnlyCollection<string> Aliases { get; }
+    public MethodInfo MethodInfo { get; set; }
+    public Snek Module { get; set; }
+    public FilterAttribute[] Filters { get; set; }
+    public CommandContextType ContextType { get; }
+    public IReadOnlyList<Type> InjectedParams { get; }
+    public IReadOnlyList<ParamData> Parameters { get; }
+    public int Priority { get; }
+}

src/NadekoBot/Common/Medusa/Models/SnekData.cs

@@ -0,0 +1,11 @@
+namespace Nadeko.Medusa;
+
+public sealed record SnekInfo(
+    string Name,
+    SnekInfo? Parent,
+    Snek Instance,
+    IReadOnlyCollection<SnekCommandData> Commands,
+    IReadOnlyCollection<FilterAttribute> Filters)
+{
+    public List<SnekInfo> Subsneks { get; set; } = new();
+}

src/NadekoBot/Common/ModuleBehaviors/IEarlyBehavior.cs

@@ -1,10 +0,0 @@
-namespace NadekoBot.Common.ModuleBehaviors;
-
-/// <summary>
-///     Implemented by modules which block execution before anything is executed
-/// </summary>
-public interface IEarlyBehavior
-{
-    int Priority { get; }
-    Task<bool> RunBehavior(IGuild guild, IUserMessage msg);
-}

src/NadekoBot/Common/ModuleBehaviors/IExecNoCommand.cs

@@ -0,0 +1,19 @@
+namespace NadekoBot.Common.ModuleBehaviors;
+
+/// <summary>
+///     Executed if no command was found for this message
+/// </summary>
+public interface IExecNoCommand
+{
+    /// <summary>
+    /// Executed at the end of the lifecycle if no command was found
+    /// <see cref="IExecOnMessage"/> →
+    /// <see cref="IInputTransformer"/> →
+    /// <see cref="IExecPreCommand"/> →
+    /// [<see cref="IExecPostCommand"/> | *<see cref="IExecNoCommand"/>*]
+    /// </summary>
+    /// <param name="guild"></param>
+    /// <param name="msg"></param>
+    /// <returns>A task representing completion</returns>
+    Task ExecOnNoCommandAsync(IGuild guild, IUserMessage msg);
+}

src/NadekoBot/Common/ModuleBehaviors/IExecOnMessage.cs

@@ -0,0 +1,21 @@
+namespace NadekoBot.Common.ModuleBehaviors;
+
+/// <summary>
+///     Implemented by modules to handle non-bot messages received
+/// </summary>
+public interface IExecOnMessage
+{
+    int Priority { get; }
+
+    /// <summary>
+    /// Ran after a non-bot message was received
+    /// *<see cref="IExecOnMessage"/>* →
+    /// <see cref="IInputTransformer"/> →
+    /// <see cref="IExecPreCommand"/> →
+    /// [<see cref="IExecPostCommand"/> | <see cref="IExecNoCommand"/>]
+    /// </summary>
+    /// <param name="guild">Guild where the message was sent</param>
+    /// <param name="msg">The message that was received</param>
+    /// <returns>Whether further processing of this message should be blocked</returns>
+    Task<bool> ExecOnMessageAsync(IGuild guild, IUserMessage msg);
+}

src/NadekoBot/Common/ModuleBehaviors/IExecPostCommand.cs

@@ -0,0 +1,22 @@
+namespace NadekoBot.Common.ModuleBehaviors;
+
+/// <summary>
+/// This interface's method is executed after the command successfully finished execution.
+/// ***There is no support for this method in NadekoBot services.***
+/// It is only meant to be used in medusa system
+/// </summary>
+public interface IExecPostCommand
+{
+    /// <summary>
+    /// Executed after a command was successfully executed
+    /// <see cref="IExecOnMessage"/> →
+    /// <see cref="IInputTransformer"/> →
+    /// <see cref="IExecPreCommand"/> →
+    /// [*<see cref="IExecPostCommand"/>* | <see cref="IExecNoCommand"/>]
+    /// </summary>
+    /// <param name="ctx">Command context</param>
+    /// <param name="moduleName">Module name</param>
+    /// <param name="commandName">Command name</param>
+    /// <returns>A task representing completion</returns>
+    ValueTask ExecPostCommandAsync(ICommandContext ctx, string moduleName, string commandName);
+}

src/NadekoBot/Common/ModuleBehaviors/IExecPreCommand.cs

@@ -0,0 +1,25 @@
+namespace NadekoBot.Common.ModuleBehaviors;
+
+/// <summary>
+/// This interface's method is executed after a command was found but before it was executed.
+/// Able to block further processing of a command
+/// </summary>
+public interface IExecPreCommand
+{
+    public int Priority { get; }
+
+    /// <summary>
+    /// <para>
+    /// Ran after a command was found but before execution.
+    /// </para>
+    /// <see cref="IExecOnMessage"/> →
+    /// <see cref="IInputTransformer"/> →
+    /// *<see cref="IExecPreCommand"/>* →
+    /// [<see cref="IExecPostCommand"/> | <see cref="IExecNoCommand"/>]
+    /// </summary>
+    /// <param name="context">Command context</param>
+    /// <param name="moduleName">Name of the module</param>
+    /// <param name="command">Command info</param>
+    /// <returns>Whether further processing of the command is blocked</returns>
+    Task<bool> ExecPreCommandAsync(ICommandContext context, string moduleName, CommandInfo command);
+}

src/NadekoBot/Common/ModuleBehaviors/IInputTransformer.cs

@@ -1,8 +1,23 @@
 namespace NadekoBot.Common.ModuleBehaviors;
 
+/// <summary>
+/// Implemented by services which may transform input before a command is searched for
+/// </summary>
 public interface IInputTransformer
 {
-    Task<string> TransformInput(
+    /// <summary>
+    /// Ran after a non-bot message was received
+    /// <see cref="IExecOnMessage"/> ->
+    /// *<see cref="IInputTransformer"/>* ->
+    /// <see cref="IExecPreCommand"/> ->
+    /// [<see cref="IExecPostCommand"/> OR <see cref="IExecNoCommand"/>]
+    /// </summary>
+    /// <param name="guild">Guild</param>
+    /// <param name="channel">Channel in which the message was sent</param>
+    /// <param name="user">User who sent the message</param>
+    /// <param name="input">Content of the message</param>
+    /// <returns>New input, if any, otherwise null</returns>
+    Task<string?> TransformInput(
         IGuild guild,
         IMessageChannel channel,
         IUser user,

src/NadekoBot/Common/ModuleBehaviors/ILateBlocker.cs

@@ -1,8 +0,0 @@
-namespace NadekoBot.Common.ModuleBehaviors;
-
-public interface ILateBlocker
-{
-    public int Priority { get; }
-
-    Task<bool> TryBlockLate(ICommandContext context, string moduleName, CommandInfo command);
-}

src/NadekoBot/Common/ModuleBehaviors/ILateExecutor.cs

@@ -1,9 +0,0 @@
-namespace NadekoBot.Common.ModuleBehaviors;
-
-/// <summary>
-///     Last thing to be executed, won't stop further executions
-/// </summary>
-public interface ILateExecutor
-{
-    Task LateExecute(IGuild guild, IUserMessage msg);
-}