chore: rebuild and version bump

chore: release v0.10.7

.envrc

@@ -0,0 +1 @@
+use flake

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: eRgo35

.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "senpai" ]
+  pull_request:
+    branches: [ "senpai" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

.github/workflows/release-plz.yml

@@ -0,0 +1,27 @@
+name: Release Plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  push:
+    branches:
+      - senpai
+
+jobs:
+  release-plz:
+    name: Release-plz
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        env:
+          GITHUB_TOKEN: ${{ secrets.RELEASE_PLZ_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/release.yml

@@ -0,0 +1,281 @@
+# Copyright 2022-2024, axodotdev
+# SPDX-License-Identifier: MIT or Apache-2.0
+#
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * builds artifacts with cargo-dist (archives, installers, hashes)
+# * uploads those artifacts to temporary workflow zip
+# * on success, uploads the artifacts to a GitHub Release
+#
+# Note that the GitHub Release will be created with a generated
+# title/body based on your changelogs.
+
+name: Release
+permissions:
+  "contents": "write"
+
+# This task will run whenever you push a git tag that looks like a version
+# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
+# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
+# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
+# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
+#
+# If PACKAGE_NAME is specified, then the announcement will be for that
+# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
+#
+# If PACKAGE_NAME isn't specified, then the announcement will be for all
+# (cargo-dist-able) packages in the workspace with that version (this mode is
+# intended for workspaces with only one dist-able package, or with all dist-able
+# packages versioned/released in lockstep).
+#
+# If you push multiple tags at once, separate instances of this workflow will
+# spin up, creating an independent announcement for each one. However, GitHub
+# will hard limit this to 3 tags per commit, as it will assume more tags is a
+# mistake.
+#
+# If there's a prerelease-style suffix to the version, then the release(s)
+# will be marked as a prerelease.
+on:
+  pull_request:
+  push:
+    tags:
+      - '**[0-9]+.[0-9]+.[0-9]+*'
+
+jobs:
+  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
+  plan:
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.plan.outputs.manifest }}
+      tag: ${{ !github.event.pull_request && github.ref_name || '' }}
+      tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
+      publishing: ${{ !github.event.pull_request }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cargo-dist
+        # we specify bash to get pipefail; it guards against the `curl` command
+        # failing. otherwise `sh` won't catch that `curl` returned non-0
+        shell: bash
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.20.0/cargo-dist-installer.sh | sh"
+      - name: Cache cargo-dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/cargo-dist
+      # sure would be cool if github gave us proper conditionals...
+      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
+      # functionality based on whether this is a pull_request, and whether it's from a fork.
+      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
+      # but also really annoying to build CI around when it needs secrets to work right.)
+      - id: plan
+        run: |
+          cargo dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "cargo dist ran successfully"
+          cat plan-dist-manifest.json
+          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-plan-dist-manifest
+          path: plan-dist-manifest.json
+
+  # Build and packages all the platform-specific things
+  build-local-artifacts:
+    name: build-local-artifacts (${{ join(matrix.targets, ', ') }})
+    # Let the initial task tell us to not run (currently very blunt)
+    needs:
+      - plan
+    if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }}
+    strategy:
+      fail-fast: false
+      # Target platforms/runners are computed by cargo-dist in create-release.
+      # Each member of the matrix has the following arguments:
+      #
+      # - runner: the github runner
+      # - dist-args: cli flags to pass to cargo dist
+      # - install-dist: expression to run to install cargo-dist on the runner
+      #
+      # Typically there will be:
+      # - 1 "global" task that builds universal installers
+      # - N "local" tasks that build each platform's binaries and platform-specific installers
+      matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }}
+    runs-on: ${{ matrix.runner }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
+    steps:
+      - name: enable windows longpaths
+        run: |
+          git config --global core.longpaths true
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cargo-dist
+        run: ${{ matrix.install_dist }}
+      # Get the dist-manifest
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - name: Install dependencies
+        run: |
+          ${{ matrix.packages_install }}
+      - name: Build artifacts
+        run: |
+          # Actually do builds and make zips and whatnot
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
+          echo "cargo dist ran successfully"
+      - id: cargo-dist
+        name: Post-build
+        # We force bash here just because github makes it really hard to get values up
+        # to "real" actions without writing to env-vars, and writing to env-vars has
+        # inconsistent syntax between shell and powershell.
+        shell: bash
+        run: |
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-local-${{ join(matrix.targets, '_') }}
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+
+  # Build and package all the platform-agnostic(ish) things
+  build-global-artifacts:
+    needs:
+      - plan
+      - build-local-artifacts
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached cargo-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/cargo-dist
+      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: cargo-dist
+        shell: bash
+        run: |
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "cargo dist ran successfully"
+
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-global
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+  # Determines if we should publish/announce
+  host:
+    needs:
+      - plan
+      - build-local-artifacts
+      - build-global-artifacts
+    # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine)
+    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.host.outputs.manifest }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached cargo-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/cargo-dist
+      # Fetch artifacts from scratch-storage
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: host
+        shell: bash
+        run: |
+          cargo dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          echo "artifacts uploaded and released successfully"
+          cat dist-manifest.json
+          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          # Overwrite the previous copy
+          name: artifacts-dist-manifest
+          path: dist-manifest.json
+      # Create a GitHub Release while uploading all files to it
+      - name: "Download GitHub Artifacts"
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: artifacts
+          merge-multiple: true
+      - name: Cleanup
+        run: |
+          # Remove the granular manifests
+          rm -f artifacts/*-dist-manifest.json
+      - name: Create GitHub Release
+        env:
+          PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}"
+          ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}"
+          ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}"
+          RELEASE_COMMIT: "${{ github.sha }}"
+        run: |
+          # Write and read notes from a file to avoid quoting breaking things
+          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
+
+          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
+
+  announce:
+    needs:
+      - plan
+      - host
+    # use "always() && ..." to allow us to wait for all publish jobs while
+    # still allowing individual publish jobs to skip themselves (for prereleases).
+    # "host" however must run to completion, no skipping allowed!
+    if: ${{ always() && needs.host.result == 'success' }}
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive

.gitignore

@@ -1,3 +1,4 @@
 /target
 **/target
 .env
+.direnv/

.gitmodules

@@ -1,12 +0,0 @@
-[submodule "libs/songbird"]
-	path = libs/songbird
-	url = git@github.com:eRgo35/songbird.git
-[submodule "libs/serenity"]
-	path = libs/serenity
-	url = git@github.com:eRgo35/serenity.git
-[submodule "libs/poise"]
-	path = libs/poise
-	url = git@github.com:eRgo35/poise.git
-[submodule "libs/spotify-parser"]
-	path = libs/spotify-parser
-	url = git@github.com:eRgo35/spotify-parser.git

CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.10.7](https://github.com/eRgo35/lyra/compare/v0.10.6...v0.10.7) - 2024-08-16
+
+### Other
+- update Cargo.lock dependencies
+
+## [0.10.4](https://github.com/eRgo35/lyra/compare/v0.10.3...v0.10.4) - 2024-08-13
+
+### Fixed
+- added wip info for some commands
+
+### Other
+- cargo-dist action setup
+- repo added to Cargo.toml
+- using cargo-dist for package building
+
+## [0.10.3](https://github.com/eRgo35/lyra/compare/v0.10.2...v0.10.3) - 2024-08-13
+
+### Other
+- release-plz
+# Changelog

Cargo.toml

@@ -1,19 +1,19 @@
 [package]
 name = "lyra"
-version = "0.9.1"
+version = "0.10.8"
 authors = ["Michał Czyż <mike@c2yz.com>"]
 edition = "2021"
 description = "A featureful Discord bot written in Rust."
-documentation = "https://lyra.c2yz.com/docs"
+documentation = "https://github.com/eRgo35/lyra"
+repository = "https://github.com/eRgo35/lyra"
 readme = "README.md"
 homepage = "https://lyra.c2yz.com"
 license-file = "LICENSE.md"
 keywords = ["discord", "bot", "rust", "music", "featureful"]
 
 [dependencies]
-lib-spotify-parser = { path = "./libs/spotify-parser" }
+spotify-parser = "1.0.1"
 dotenv = "0.15.0"
-fancy-regex = "0.13.0"
 json = "0.12.4"
 openssl = { version = "0.10.66", features = ["vendored"] }
 owoify = "0.1.5"
@@ -23,9 +23,9 @@ regex = "1.10.6"
 reqwest = { version = "0.11.27", features = ["json"] }
 serde = { version = "1.0.204", features = ["derive"] }
 serde_json = "1.0.122"
-songbird = { version = "0.4.3", default-features = true, features = [
+songbird = { version = "0.4.6", default-features = true, features = [
     "builtin-queue",
-] }
+], git = "https://github.com/eRgo35/songbird" }
 serenity = { default-features = true, features = [
     "cache",
     "framework",
@@ -34,7 +34,6 @@ serenity = { default-features = true, features = [
     "http",
     "rustls_backend",
 ], version = "0.12" }
-
 symphonia = { version = "0.5.4", features = [
     "aac",
     "adpcm",
@@ -53,3 +52,23 @@ once_cell = "1.19.0"
 [patch.crates-io.serenity-voice-model]
 git = "https://github.com/serenity-rs/serenity"
 branch = "current"
+
+# The profile that 'cargo dist' will build with
+[profile.dist]
+inherits = "release"
+lto = "thin"
+
+# Config for 'cargo dist'
+[workspace.metadata.dist]
+# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.20.0"
+# CI backends to support
+ci = "github"
+# The installers to generate for each app
+installers = ["shell"]
+# Target platforms to build apps for (Rust target-triple syntax)
+targets = ["x86_64-unknown-linux-gnu"]
+# Path that installers should place binaries in
+install-path = "CARGO_HOME"
+# Whether to install an updater program
+install-updater = false

README.md

@@ -1,52 +1,82 @@
-# Lyra
+<h2 align="center">
-
+  <a href="https://lyra.c2yz.com" target="blank_">
-![](assets/lyra-256.png)
+    <img height="256" alt="Lyra" src="assets/lyra-256.png" />
-
+  </a>
-Lyra is a music bot written in Rust.
+  <br />
-
+  Lyra: a discord music bot written in rust :crab:
-## Getting Started
+</h2>
 
 Lyra is an open source, discord music bot written in Rust.
-
 The idea behind this project is to allow a user to self-host one's own instance of the bot.
+User no longer has to rely on 3rd-parties to provide them a service.
+The bot can be run on a desktop, a vps or a phone as it's just a simple binary.
 
-User no longer has to rely on 3rd parties to provide them an invite link.
+Currently bot is still heavily in development!
 
-The bot can be run even on a desktop or a phone because after compilation, it's just a simple binary.
+## Getting started
 
-As of now, the bot supports spotify url track recognition through a separate nodejs script. I plan to write the actual parser inside the bot iteself but as of now I postponed it into future release.
+Before you start, you need to create a discord bot and get a token.
+You can do it [here](https://discord.com/developers/applications).
 
-Slash commands are still work in progress! Currently bot is still heavily in development!
+After you create a bot, you need to invite it to your server.
 
-## Setting up
+Then, head to download section and download the latest release (or compile it yourself).
+
+After you download the binary, you need to create a `.env` file in the same directory as the binary.
+Example can be found in `.env.example` file.
+
+```
+DISCORD_TOKEN=<YOUR_DISCORD_TOKEN>
+PREFIX=<YOUR_PREFIX>
+```
+
+DISCORD_TOKEN is the token you got from discord developers page and PREFIX is the prefix you want to use for your bot.
+
+Bot by default reacts only to the prefix. To enable slash commands, while the bot is running type `:register` in the chat (where `:` is your bot prefix).
+
+## Features
+
+- Music playback
+- Audio effects (soon)
+- Some multipurpose commands
+- Slash commands
+- Self-hosted
+
+## Compilation
 
 To compile the source code on your own, you need `rust` and `cargo`
 
-To run a dev version use
+To run a dev version, `cd` into the project directory and type
+
 ```bash
 $ cargo run
 ```
 
 To build a production version use
+
 ```bash
 $ cargo build --release
 ```
 
-If you need an ARM version and just don't want to wait for ages for the program to compile, use
+If you need a version for a different system or architecture, you can use `cross` crate
+
 ```bash
 $ cross build -r --target aarch64-unknown-linux-gnu
 ```
 
 To run a program, just type
+
 ```bash
 $ ./lyra
 ```
 
-if you want to disown it from the shell, I recommend using the script I provided in `scripts` folder
+Remember to provide a `.env` file in the same directory as the binary.
+
+If you want to disown the bot from the shell, I recommend using the script I provided in `scripts` folder
 
 ## Commands
 
-As of now, working commands are:
+As of now, the commands are:
 
 ```
 Music:
@@ -60,7 +90,7 @@ Music:
   /repeat       Loops currently playing song provided amount of times; aliases: repeat, loop, while, for
   /resume       Resumes currently paused song
   /seek         Seeks a track by provided seconds
-  /skip         Skips the currently playing song
+  /skip         Skips the currently playing song; aliases: skip, :skipper:
   /stop         Stops playback and destroys the queue; aliases: stop, end
   /volume       Changes output volume
   /effect       Plays one of available audio effects
@@ -69,13 +99,22 @@ Music:
 Tools:
   /ai           Asks AI
   /dice         Rolls a dice
+  /dictionary   Explains provided query
+  /ip           Shows IP information
+  /metar        Prints metar for provided airport
   /owoify       Owoifies whatever you want uwu
   /ping         Pings you backs with a response time
   /posix        Prints current time in POSIX format
   /qr           Creates a qr code from text
+  /taf          Returns taf for provided airport
+  /uptime       Checks how long the bot has been running
   /verse        Reference Bible by verse
+  /weather      Shows weather for provided location
 
 Help:
   /help         Prints this help message; aliases: help, huh, welp
 
+Use /help command for more info on a command.
+You can edit you message to the bot and the bot will edit its response.
+
 ```

flake.lock

@@ -0,0 +1,46 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1734119587,
+        "narHash": "sha256-AKU6qqskl0yf2+JdRdD0cfxX4b9x3KKV5RqA6wijmPM=",
+        "rev": "3566ab7246670a43abd2ffa913cc62dad9cdf7d5",
+        "revCount": 721821,
+        "type": "tarball",
+        "url": "https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.1.721821%2Brev-3566ab7246670a43abd2ffa913cc62dad9cdf7d5/0193cb18-1103-723d-8c38-29b3e808b002/source.tar.gz"
+      },
+      "original": {
+        "type": "tarball",
+        "url": "https://flakehub.com/f/NixOS/nixpkgs/0.1.%2A.tar.gz"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1734230139,
+        "narHash": "sha256-zsp0Mz8VgyIAnU8UhP/YT1g+zlsl+NIJTBMAbY+RifQ=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "150fbc8aa2bc501041810bbc1dbfe73694a861be",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,87 @@
+{
+  description = "A Nix-flake-based Rust development environment";
+
+  inputs = {
+    nixpkgs.url = "https://flakehub.com/f/NixOS/nixpkgs/0.1.*.tar.gz";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+      rust-overlay,
+    }:
+    let
+      supportedSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+      forEachSupportedSystem =
+        f:
+        nixpkgs.lib.genAttrs supportedSystems (
+          system:
+          f {
+            pkgs = import nixpkgs {
+              inherit system;
+              overlays = [
+                rust-overlay.overlays.default
+                self.overlays.default
+              ];
+            };
+          }
+        );
+    in
+    {
+      overlays.default = final: prev: {
+        rustToolchain =
+          let
+            rust = prev.rust-bin;
+          in
+          if builtins.pathExists ./rust-toolchain.toml then
+            rust.fromRustupToolchainFile ./rust-toolchain.toml
+          else if builtins.pathExists ./rust-toolchain then
+            rust.fromRustupToolchainFile ./rust-toolchain
+          else
+            rust.stable.latest.default.override {
+              extensions = [
+                "rust-src"
+                "rustfmt"
+              ];
+            };
+      };
+
+      devShells = forEachSupportedSystem (
+        { pkgs }:
+        {
+          default = pkgs.mkShell {
+            packages = with pkgs; [
+              rustToolchain
+              openssl
+              pkg-config
+              cargo-deny
+              cargo-edit
+              cargo-watch
+              rust-analyzer
+              cmake
+              opusTools
+              opusfile
+              rustup
+              cargo-cross
+              gcc
+            ];
+
+            env = {
+              # Required by rust-analyzer
+              RUST_SRC_PATH = "${pkgs.rustToolchain}/lib/rustlib/src/rust/library";
+            };
+          };
+        }
+      );
+    };
+}

src/commands.rs

@@ -1,4 +1,3 @@
 pub mod embeds;
-pub mod kashi;
 pub mod music;
 pub mod tools;

src/commands/kashi.rs

@@ -1,3 +0,0 @@
-pub mod kashi;
-
-pub use kashi::kashi;

src/commands/kashi/kashi.rs

@@ -1,17 +0,0 @@
-use crate::{Context, Error};
-
-/// Kashi integration platform (WIP)
-#[poise::command(
-    prefix_command, 
-    slash_command,
-    category = "Kashi"
-)]
-pub async fn kashi(
-    ctx: Context<'_>
-) -> Result<(), Error> {
-    
-    let response = format!("Kashi platform is currently under construction!");
-    ctx.say(response).await?;
-
-    Ok(())
-}

src/commands/music/deafen.rs

@@ -15,7 +15,7 @@ use poise::CreateReply;
 pub async fn deafen(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/join.rs

@@ -27,7 +27,7 @@ pub async fn join(ctx: Context<'_>) -> Result<(), Error> {
         }
     };
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/leave.rs

@@ -15,12 +15,12 @@ use poise::CreateReply;
 pub async fn leave(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();
 
-    if !manager.get(guild_id).is_some() {
+    if manager.get(guild_id).is_none() {
         let msg = "I am not in a voice channel!";
         ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
             .await?;

src/commands/music/mute.rs

@@ -15,7 +15,7 @@ use poise::CreateReply;
 pub async fn mute(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/pause.rs

@@ -9,7 +9,7 @@ use poise::CreateReply;
 pub async fn pause(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/play.rs

@@ -1,23 +1,24 @@
 use crate::commands::music::metadata::Metadata;
+use crate::commands::music::notifier::TrackErrorNotifier;
 use crate::{commands::embeds::error_embed, Context, Error};
 
-use fancy_regex::Regex;
-use lib_spotify_parser;
 use poise::serenity_prelude::{
     Color, CreateEmbed, CreateEmbedAuthor, CreateEmbedFooter, Timestamp,
 };
 use poise::CreateReply;
 use regex::Regex as Regex_Classic;
+use reqwest::Client;
+use serenity::all::GuildId;
 use songbird::events::TrackEvent;
 use songbird::input::AuxMetadata;
 use songbird::input::{Compose, YoutubeDl};
-use songbird::tracks::{TrackHandle, TrackQueue};
+use songbird::tracks::TrackQueue;
+use songbird::Call;
+use spotify_parser;
+use std::collections::VecDeque;
 use std::process::Command;
 use std::time::Duration;
 
-use crate::commands::music::notifier::TrackErrorNotifier;
-use crate::http::HttpKey;
-
 /// Plays a song; \
 /// you can search by query or paste an url; \
 /// aliases: play, p, enqueue
@@ -31,25 +32,15 @@ pub async fn play(
     ctx: Context<'_>,
     #[description = "Provide a query or an url"]
     #[rest]
-    mut song: String,
+    song: String,
 ) -> Result<(), Error> {
-    let regex_spotify = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
-    let regex_youtube =
-        Regex_Classic::new(r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#)
-            .unwrap();
-    let regex_youtube_playlist = Regex::new(
-        r"^((?:https?:)\/\/)?((?:www|m)\.)?((?:youtube\.com)).*(youtu.be\/|list=)([^#&?]*).*",
-    )
-    .unwrap();
-    let regex_spotify_playlist = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:(album|playlist)\/|\?uri=spotify:playlist:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
-
-    let is_playlist = regex_youtube_playlist.is_match(&song).unwrap()
-        || regex_spotify_playlist.is_match(&song).unwrap();
-    let is_spotify =
-        regex_spotify.is_match(&song).unwrap() || regex_spotify_playlist.is_match(&song).unwrap();
-    let is_query = !song.starts_with("http");
-
     let guild_id = ctx.guild_id().unwrap();
+    let http_client = ctx.data().http_client.clone();
+    let manager = songbird::get(ctx.serenity_context()).await.unwrap().clone();
+
+    let mut rest_playlist: VecDeque<String> = VecDeque::new();
+
+    if manager.get(guild_id).is_none() {
         let channel_id = ctx
             .guild()
             .unwrap()
@@ -63,125 +54,132 @@ pub async fn play(
                 let msg = "I am not in a voice channel!";
                 ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
                     .await?;
-
                 return Ok(());
             }
         };
 
-    let http_client = {
-        let data = ctx.serenity_context().data.read().await;
-        data.get::<HttpKey>()
-            .cloned()
-            .expect("Guaranteed to exist in the typemap.")
-    };
-
-    let manager = songbird::get(&ctx.serenity_context())
-        .await
-        .expect("Songbird Voice placed at init")
-        .clone();
-
         if let Ok(handler_lock) = manager.join(guild_id, connect_to).await {
             let mut handler = handler_lock.lock().await;
-
             handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
 
-        if is_playlist && is_spotify {
+            rest_playlist = handle_play(ctx, song, handler, http_client.clone())
-            let tracks: Vec<String> = lib_spotify_parser::retrieve_async_url(&song).await.unwrap();
+                .await
-
+                .unwrap();
-            for (index, url) in tracks.clone().iter().enumerate() {
+        } else {
-                if url.is_empty() {
+            let msg = "Failed to join the voice channel!";
-                    break;
+            ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
+                .await?;
         }
-                let src = YoutubeDl::new_ytdl_like(
+    } else {
-                    "yt-dlp",
+        let handler = manager.get(guild_id).unwrap();
-                    http_client.clone(),
+        let mut handler = handler.lock().await;
-                    format!("ytsearch:{}", url.to_string()),
+        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
-                );
+        rest_playlist = handle_play(ctx, song, handler, http_client.clone())
+            .await
+            .unwrap();
+    }
+
+    handle_playlist(rest_playlist, manager, guild_id, http_client)
+        .await
+        .unwrap();
+
+    Ok(())
+}
+
+async fn handle_play<'a>(
+    ctx: Context<'a>,
+    song: String,
+    mut handler: tokio::sync::MutexGuard<'a, Call>,
+    http_client: Client,
+) -> Result<VecDeque<String>, Error> {
+    let mut results = parse_data(song).await;
+
+    let src: YoutubeDl =
+        YoutubeDl::new_ytdl_like("yt-dlp", http_client, results.pop_front().unwrap());
+
+    ctx.send(
+        CreateReply::default().embed(
+            generate_embed(ctx, src.clone(), handler.queue(), results.clone())
+                .await
+                .unwrap(),
+        ),
+    )
+    .await?;
+
     let aux_metadata = src.clone().aux_metadata().await.unwrap();
-                let track = handler.enqueue_input(src.clone().into()).await;
+
-                let _ = track
+    handler
+        .enqueue_input(src.clone().into())
+        .await
         .typemap()
         .write()
         .await
         .insert::<Metadata>(aux_metadata);
 
-                if index == 0 {
+    Ok(results)
-                    let embed = generate_playlist_embed(ctx, track, tracks.len()).await;
-                    let response = CreateReply::default().embed(embed.unwrap());
-                    ctx.send(response).await?;
-                }
 }
 
-            return Ok(());
+async fn parse_data(data: String) -> VecDeque<String> {
-        }
+    let tracks = spotify_parser::retrieve_async_url(&data)
+        .await
+        .unwrap_or(vec![data])
+        .iter()
+        .flat_map(|track| {
+            if track.contains("?list=") {
+                let regex_youtube = Regex_Classic::new(
+                    r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#,
+                )
+                .unwrap();
 
-        if is_playlist {
+                let list = Command::new("yt-dlp")
-            let raw_list = Command::new("yt-dlp")
+                    .args(["--username", "oauth2", "--password", "''"])
-                .args(["-j", "--flat-playlist", &song])
+                    .args(["-j", "--flat-playlist", track])
                     .output()
-                .expect("failed to execute process")
+                    .expect("Failed to execute process")
                     .stdout;
+                let list = String::from_utf8(list).unwrap();
 
-            let list = String::from_utf8(raw_list.clone()).expect("Invalid UTF-8");
+                regex_youtube
-
-            let urls: Vec<String> = regex_youtube
                     .captures_iter(&list)
-                .map(|capture| capture[1].to_string())
+                    .map(|capture| capture.get(1).unwrap().as_str().to_string())
+                    .collect::<Vec<String>>()
+            } else if track.starts_with("http") {
+                vec![track.clone()]
+            } else {
+                vec![format!("ytsearch:{}", track)]
+            }
+        })
         .collect();
 
-            for (index, url) in urls.clone().iter().enumerate() {
+    tracks
-                if url.is_empty() {
-                    break;
 }
-                let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client.clone(), url.to_string());
+
+async fn handle_playlist(
+    playlist: VecDeque<String>,
+    manager: std::sync::Arc<songbird::Songbird>,
+    guild_id: GuildId,
+    http_client: Client,
+) -> Result<(), Error> {
+    for song in playlist {
+        if manager.get(guild_id).is_some() {
+            let handler = manager.get(guild_id).unwrap();
+            let mut handler = handler.lock().await;
+
+            let src: YoutubeDl =
+                YoutubeDl::new_ytdl_like("yt-dlp", http_client.clone(), song.clone());
+
             let aux_metadata = src.clone().aux_metadata().await.unwrap();
-                let track = handler.enqueue_input(src.clone().into()).await;
+
-                let _ = track
+            handler
+                .enqueue_input(src.clone().into())
+                .await
                 .typemap()
                 .write()
                 .await
                 .insert::<Metadata>(aux_metadata);
-
-                if index == 0 {
-                    let embed = generate_playlist_embed(ctx, track, urls.len()).await;
-                    let response = CreateReply::default().embed(embed.unwrap());
-                    ctx.send(response).await?;
         }
     }
 
-            return Ok(());
-        }
-
-        if is_spotify {
-            song = format!(
-                "ytsearch:{}",
-                lib_spotify_parser::retrieve_async_url(&song)
-                    .await
-                    .unwrap()
-                    .first()
-                    .unwrap()
-            );
-        }
-
-        if is_query {
-            song = format!("ytsearch:{}", song);
-        }
-
-        let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song);
-        let embed = generate_embed(ctx, src.clone(), handler.queue()).await;
-        let response = CreateReply::default().embed(embed.unwrap());
-        ctx.send(response).await?;
-
-        let aux_metadata = src.clone().aux_metadata().await.unwrap();
-
-        let track = handler.enqueue_input(src.clone().into()).await;
-        let _ = track
-            .typemap()
-            .write()
-            .await
-            .insert::<Metadata>(aux_metadata);
-    }
-
     Ok(())
 }
 
@@ -189,6 +187,7 @@ async fn generate_embed(
     ctx: Context<'_>,
     src: YoutubeDl,
     queue: &TrackQueue,
+    results: VecDeque<String>,
 ) -> Result<CreateEmbed, Error> {
     let metadata = src.clone().aux_metadata().await.unwrap();
     let AuxMetadata {
@@ -199,17 +198,21 @@ async fn generate_embed(
         duration,
         ..
     } = metadata;
-    let timestamp = Timestamp::now();
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
-    let mut description = format!("Song added to queue @ {}", queue.len() + 1);
+    let mut description = format!("Enqueued @ {}", queue.len() + 1);
+    let mut tracks = "Tracks enqueued";
 
-    if queue.len() == 0 {
+    if results.len() == 1 {
-        description = format!("Playing now!");
+        tracks = "Track enqueued";
+    }
+
+    if queue.is_empty() {
+        description = "Playing now!".to_string();
     }
 
     let embed = CreateEmbed::default()
-        .author(CreateEmbedAuthor::new("Track enqueued").icon_url(ctx.author().clone().face()))
+        .author(CreateEmbedAuthor::new(tracks).icon_url(ctx.author().clone().face()))
         .colour(Color::from_rgb(255, 58, 97))
         .title(title.unwrap())
         .url(source_url.unwrap())
@@ -226,59 +229,7 @@ async fn generate_embed(
         )
         .field("DJ", ctx.author().name.clone(), true)
         .description(description)
-        .timestamp(timestamp)
+        .timestamp(Timestamp::now())
-        .footer(
-            CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
-                .icon_url(ctx.cache().current_user().face()),
-        );
-
-    Ok(embed)
-}
-
-async fn generate_playlist_embed(
-    ctx: Context<'_>,
-    track: TrackHandle,
-    queue_length: usize,
-) -> Result<CreateEmbed, Error> {
-    let meta_typemap = track.typemap().read().await;
-    let metadata = meta_typemap.get::<Metadata>().unwrap();
-    let AuxMetadata {
-        title,
-        thumbnail,
-        source_url,
-        artist,
-        duration,
-        ..
-    } = metadata;
-    let timestamp = Timestamp::now();
-    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
-    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
-
-    let description = format!("Enqueued tracks: {}", queue_length - 1);
-
-    let embed = CreateEmbed::default()
-        .author(CreateEmbedAuthor::new("Playlist enqueued").icon_url(ctx.author().clone().face()))
-        .colour(Color::from_rgb(255, 58, 97))
-        .title(title.as_ref().unwrap())
-        .url(source_url.as_ref().unwrap())
-        .thumbnail(
-            thumbnail
-                .as_ref()
-                .unwrap_or(&ctx.cache().current_user().face()),
-        )
-        .field(
-            "Artist",
-            artist.as_ref().unwrap_or(&"Unknown Artist".to_string()),
-            true,
-        )
-        .field(
-            "Duration",
-            format!("{:02}:{:02}", duration_minutes, duration_seconds),
-            true,
-        )
-        .field("DJ", ctx.author().name.clone(), true)
-        .description(description)
-        .timestamp(timestamp)
         .footer(
             CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
                 .icon_url(ctx.cache().current_user().face()),

src/commands/music/queue.rs

@@ -16,7 +16,7 @@ const QUEUE_DISPLAY_LENGTH: usize = 10;
 pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/repeat.rs

@@ -21,7 +21,7 @@ pub async fn repeat(
 ) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/resume.rs

@@ -9,7 +9,7 @@ use poise::CreateReply;
 pub async fn resume(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/seek.rs

@@ -14,7 +14,7 @@ pub async fn seek(
 ) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/skip.rs

@@ -17,7 +17,7 @@ use songbird::{input::AuxMetadata, tracks::TrackHandle};
 pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();
@@ -30,23 +30,18 @@ pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
         let track = track_raw.get(1);
         let queue_length = queue.len() - 1;
 
-        let response;
+        let mut response = CreateReply::default().embed(
+            embed(ctx, "Skipped!", "The queue is empty!", "")
+                .await
+                .unwrap(),
+        );
 
-        match track {
+        if let Some(track) = track {
-            Some(track) => {
             response = CreateReply::default().embed(
                 generate_embed(ctx, track.clone(), queue_length)
                     .await
                     .unwrap(),
             );
-            }
-            None => {
-                response = CreateReply::default().embed(
-                    embed(ctx, "Skipped!", "The queue is empty!", "")
-                        .await
-                        .unwrap(),
-                );
-            }
         };
 
         ctx.send(response).await?;

src/commands/music/soundboard/effect.rs

@@ -34,7 +34,7 @@ pub async fn effect(
             .expect("Guaranteed to exist in the typemap.")
     };
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird Voice placed at init")
         .clone();
@@ -85,7 +85,7 @@ async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed,
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
 
-    let description = format!("Playing now!");
+    let description = "Playing now!";
 
     let embed = CreateEmbed::default()
         .author(CreateEmbedAuthor::new("Playing an effect!").icon_url(ctx.author().clone().face()))

src/commands/music/soundboard/stream.rs

@@ -41,7 +41,7 @@ pub async fn stream(
             .expect("Guaranteed to exist in the typemap.")
     };
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird Voice placed at init")
         .clone();
@@ -92,7 +92,7 @@ async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed,
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
 
-    let description = format!("Playing now!");
+    let description = "Playing now!";
 
     let embed = CreateEmbed::default()
         .author(

src/commands/music/stop.rs

@@ -10,7 +10,7 @@ use poise::CreateReply;
 pub async fn stop(ctx: Context<'_>) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/music/volume.rs

@@ -9,7 +9,7 @@ use poise::CreateReply;
 pub async fn volume(ctx: Context<'_>, #[description = "Volume"] volume: f32) -> Result<(), Error> {
     let guild_id = ctx.guild_id().unwrap();
 
-    let manager = songbird::get(&ctx.serenity_context())
+    let manager = songbird::get(ctx.serenity_context())
         .await
         .expect("Songbird client placed at init")
         .clone();

src/commands/tools/ai.rs

@@ -15,7 +15,7 @@ pub async fn ai(
     #[rest]
     prompt: String,
 ) -> Result<(), Error> {
-    let iamsorry = vec![
+    let iamsorry = &[
         "I'm sorry, but as an AI language model, I must follow ethical guidelines, and I cannot engage in harmful, malicious, or offensive behavior.",
         "I'm sorry, but as an AI language model, I may not always be perfect and can make mistakes or provide inaccurate information. Please verify important details from reliable sources.",
         "I'm sorry, but as an AI language model, I can't engage in real-time conversations or remember previous interactions with users.",
@@ -27,19 +27,17 @@ pub async fn ai(
 
     println!("Funny prompts: {}", prompt);
 
-    let response;
+    let response = {
-
-    let _ = {
         let mut rng = rand::thread_rng();
 
-        response = rng.gen_range(0..iamsorry.len());
+        rng.gen_range(0..iamsorry.len())
     };
 
     sleep(Duration::from_secs(1));
 
     ctx.send(
         CreateReply::default().embed(
-            embed(ctx, "AI Response:", "", &format!("{}", iamsorry[response]))
+            embed(ctx, "AI Response:", "", iamsorry[response])
                 .await
                 .unwrap(),
         ),

src/commands/tools/dice.rs

@@ -7,12 +7,9 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Rolls a dice
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn dice(ctx: Context<'_>) -> Result<(), Error> {
-    let dice;
+    let dice = {
-
-    let _ = {
         let mut rng = rand::thread_rng();
-
+        rng.gen_range(1..=6)
-        dice = rng.gen_range(1..7);
     };
 
     ctx.send(

src/commands/tools/ip.rs

@@ -5,7 +5,9 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Shows IP information
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn ip(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
+        CreateReply::default().embed(embed(ctx, "IP Info", "Work in progress", "").await.unwrap()),
+    )
     .await?;
 
     Ok(())

src/commands/tools/metar.rs

@@ -5,7 +5,9 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Prints metar for provided airport
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn metar(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
+        CreateReply::default().embed(embed(ctx, "Metar", "Work in progress", "").await.unwrap()),
+    )
     .await?;
 
     Ok(())

src/commands/tools/taf.rs

@@ -5,7 +5,9 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Returns taf for provided airport
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn taf(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
+        CreateReply::default().embed(embed(ctx, "Taf", "Work in progress", "").await.unwrap()),
+    )
     .await?;
 
     Ok(())

src/commands/tools/weather.rs

@@ -10,7 +10,9 @@ pub async fn weather(
     #[rest]
     _location: String,
 ) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
+        CreateReply::default().embed(embed(ctx, "Weather", "Work in progress", "").await.unwrap()),
+    )
     .await?;
 
     Ok(())

src/main.rs

@@ -9,7 +9,6 @@ use tracing::{error, info, warn};
 mod commands;
 mod http;
 
-use crate::commands::kashi;
 use crate::commands::music;
 use crate::commands::tools;
 use crate::http::HttpKey;
@@ -17,7 +16,9 @@ use crate::http::HttpKey;
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Context<'a> = poise::Context<'a, Data, Error>;
 
-pub struct Data;
+pub struct Data {
+    pub http_client: HttpClient,
+}
 
 async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
     match error {
@@ -45,7 +46,6 @@ async fn main() {
     let prefix = std::env::var("PREFIX").expect("Environment variable `PREFIX` not found!");
 
     let commands = vec![
-        kashi::kashi(),
         music::deafen(),
         music::join(),
         music::leave(),
@@ -141,7 +141,9 @@ async fn main() {
                 )
                 .await?;
 
-                Ok(Data {})
+                Ok(Data {
+                    http_client: HttpClient::new(),
+                })
             })
         })
         .options(options)