CI Fixes and Testing within PRs (#64)

* add: validate thread creation in ollama channel

* rm: channel_id variable

* add: short notes for threads

* update: openFile to openConfig for clarity

* update: test ci runs on master

* add: notes for work

* add: basic chat storing via json

* update: stores entire msgHist according to capacity

* add: removes json file if thread is deleted

* add: chats with independent histories

* add: private vs public threads

* update: validate threads made by ollama for chats

* update: cleanup and version increment

.env.sample

@@ -4,9 +4,6 @@ CLIENT_TOKEN = BOT_TOKEN
 # id token of a discord server
 GUILD_ID = GUILD_ID
 
-# Channel where the bot listens to messages
-CHANNEL_ID = CHANNEL_ID
-
 # model for the bot to query from (i.e. llama2 [llama2:13b], mistral, codellama, etc... )
 MODEL = MODEL_NAME
 
@@ -22,6 +19,3 @@ DISCORD_IP = IP_ADDRESS
 
 # subnet address, ex. 172.18.0.0 as we use /16.
 SUBNET_ADDRESS = ADDRESS
-
-# list of admins to handle admin commands for the bot, use single quotes
-ADMINS=['username1', 'username2', 'username3', ...]

.github/workflows/build-test.yml

@@ -1,84 +0,0 @@
-name: Builds
-run-name: Validate Node and Docker Builds
-on:
-    push:
-        branches:
-            - master
-
-jobs: 
-    Discord-Node-Build: # test if the node install and run
-        runs-on: ubuntu-latest
-        timeout-minutes: 2
-        steps:
-            - name: Checkout Repository
-              uses: actions/checkout@v4
-
-            - name: Set up Node Environment v18.18.2
-              uses: actions/setup-node@v4
-              with:
-                node-version: 18.18.2
-                cache: 'npm'
-
-            - name: Install Project Dependencies
-              run: |
-                npm install
-
-            - name: Build Application
-              run: |
-                npm run build
-
-            - name: Create Environment Variables
-              run: |
-                touch .env
-                echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
-                echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
-                echo CHANNEL_ID = ${{ secrets.CHANNEL_ID }} >> .env
-                echo MODEL = ${{ secrets.MODEL }} >> .env
-                echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
-                echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
-                echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
-                echo ADMINS = ${{ secrets.ADMINS }} >> .env
-              
-              # set -e ensures if nohup fails, this section fails
-            - name: Startup Discord Bot Client
-              run: |
-                set -e
-                nohup npm run prod &
-
-    Discord-Ollama-Container-Build: # test docker build and run
-      runs-on: ubuntu-latest
-      timeout-minutes: 2
-      steps:
-          - name: Checkout Repository
-            uses: actions/checkout@v4
-
-          - name: Set up Node Environment v18.18.2
-            uses: actions/setup-node@v4
-            with:
-              node-version: 18.18.2
-              cache: 'npm'
-
-          - name: Create Environment Variables
-            run: |
-              touch .env
-              echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
-              echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
-              echo CHANNEL_ID = ${{ secrets.CHANNEL_ID }} >> .env
-              echo MODEL = ${{ secrets.MODEL }} >> .env
-              echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
-              echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
-              echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
-              echo ADMINS = ${{ secrets.ADMINS }} >> .env
-
-          - name: Setup Docker Network and Images
-            run: |
-              npm run docker:start-cpu
-          
-          - name: Check Images Exist
-            run: |
-              (docker images | grep -q 'discord/bot' && docker images | grep -qE 'ollama/ollama') || exit 1
-
-          - name: Check Containers Exist
-            run: |
-              (docker ps | grep -q 'ollama' && docker ps | grep -q 'discord') || exit 1
-

.github/workflows/build.yml

@@ -0,0 +1,79 @@
+name: Builds
+run-name: Validate Node and Docker Builds
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  Discord-Node-Build: # test if the node install and run
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node Environment v18.18.2
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18.18.2
+          cache: "npm"
+
+      - name: Install Project Dependencies
+        run: |
+          npm install
+
+      - name: Build Application
+        run: |
+          npm run build
+
+      - name: Create Environment Variables
+        run: |
+          touch .env
+          echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
+          echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
+          echo MODEL = ${{ secrets.MODEL }} >> .env
+          echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
+          echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
+          echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
+
+        # set -e ensures if nohup fails, this section fails
+      - name: Startup Discord Bot Client
+        run: |
+          set -e
+          nohup npm run prod &
+
+  Discord-Ollama-Container-Build: # test docker build and run
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node Environment v18.18.2
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18.18.2
+          cache: "npm"
+
+      - name: Create Environment Variables
+        run: |
+          touch .env
+          echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
+          echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
+          echo MODEL = ${{ secrets.MODEL }} >> .env
+          echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
+          echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
+          echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
+
+      - name: Setup Docker Network and Images
+        run: |
+          npm run docker:start-cpu
+
+      - name: Check Images Exist
+        run: |
+          (docker images | grep -q 'discord/bot' && docker images | grep -qE 'ollama/ollama') || exit 1
+
+      - name: Check Containers Exist
+        run: |
+          (docker ps | grep -q 'ollama' && docker ps | grep -q 'discord') || exit 1

.github/workflows/test.yml

@@ -0,0 +1,69 @@
+name: Tests
+run-name: Test source code for errors
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  Discord-Node-Test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node Environment v18.18.2
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18.18.2
+          cache: "npm"
+
+      - name: Install Project Dependencies
+        run: |
+          npm install
+
+      - name: Create Environment Variables
+        run: |
+          touch .env
+          echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
+          echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
+          echo MODEL = ${{ secrets.MODEL }} >> .env
+          echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
+          echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
+          echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
+
+      - name: Test Application
+        run: |
+          npm run test:run
+
+  Discord-Ollama-Container-Test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node Environment v18.18.2
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18.18.2
+          cache: "npm"
+
+      - name: Create Environment Variables
+        run: |
+          touch .env
+          echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
+          echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
+          echo MODEL = ${{ secrets.MODEL }} >> .env
+          echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
+          echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
+          echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
+
+      - name: Setup Docker Network and Images
+        run: |
+          npm run docker:start-cpu
+
+      - name: Test Docker Container
+        run: |
+          npm run docker:test

README.md

@@ -4,7 +4,8 @@
     <h3><a href="#"></a>Ollama as your Discord AI Assistant</h3>
     <p><a href="#"></a><a href="https://creativecommons.org/licenses/by/4.0/"><img alt="License" src="https://img.shields.io/badge/License-CC_BY_4.0-darkgreen.svg" /></a>
     <a href="#"></a><a href="https://github.com/kevinthedang/discord-ollama/releases/latest"><img alt="Release" src="https://img.shields.io/github/v/release/kevinthedang/discord-ollama?logo=github" /></a>
-    <a href="#"></a><a href="https://github.com/kevinthedang/discord-ollama/actions/workflows/build-test.yml"><img alt="Build Status" src="https://github.com/kevinthedang/discord-ollama/actions/workflows/build-test.yml/badge.svg" /></a>
+    <a href="#"></a><a href="https://github.com/kevinthedang/discord-ollama/actions/workflows/build.yml"><img alt="Build Status" src="https://github.com/kevinthedang/discord-ollama/actions/workflows/build.yml/badge.svg" /></a>
+    <a href="#"></a><a href="https://github.com/kevinthedang/discord-ollama/actions/workflows/test.yml"><img alt="Testing Status" src="https://github.com/kevinthedang/discord-ollama/actions/workflows/test.yml/badge.svg" /></a>
 </div>
 
 ## About/Goals
@@ -16,9 +17,9 @@ The project aims to:
   * [x] Containerization with Docker
   * [x] Slash Commands Compatible
   * [x] Generated Token Length Handling for >2000 ~~or >6000 characters~~
-    * [ ] Token Length Handling of any message size
+    * [x] Token Length Handling of any message size
   * [ ] External WebUI Integration
-  * [ ] Administrator Role Compatible
+  * [x] Administrator Role Compatible
 * [ ] Allow others to create their own models personalized for their own servers!
   * [ ] Documentation on creating your own LLM
   * [ ] Documentation on web scrapping and cleaning

docker-compose.yml

@@ -8,16 +8,14 @@ services:
     build: ./                     # find docker file in designated path
     container_name: discord
     restart: always               # rebuild container always
-    image: discord/bot:0.4.0
+    image: discord/bot:0.5.0
     environment:
       CLIENT_TOKEN: ${CLIENT_TOKEN}
       GUILD_ID: ${GUILD_ID}
-      CHANNEL_ID: ${CHANNEL_ID}
       MODEL: ${MODEL}
       CLIENT_UID: ${CLIENT_UID}
       OLLAMA_IP: ${OLLAMA_IP}
       OLLAMA_PORT: ${OLLAMA_PORT}
-      ADMINS: ${ADMINS}
     networks:
       ollama-net:
         ipv4_address: ${DISCORD_IP}
@@ -41,6 +39,8 @@ services:
     ports: 
       - ${OLLAMA_PORT}:${OLLAMA_PORT}
 
+# Put Redis Container here?
+
 # create a network that supports giving addresses withing a specific subnet
 networks:
   ollama-net:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-ollama",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Ollama Integration into discord",
   "main": "build/index.js",
   "exports": "./build/index.js",
@@ -8,6 +8,8 @@
     "dev-tsx": "tsx watch src/index.ts",
     "dev-mon": "nodemon --config nodemon.json src/index.ts",
     "build": "tsc",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "prod": "node .",
     "client": "npm run build && npm run prod",
     "clean": "docker compose down && docker rmi $(docker images | grep $(node -p \"require('./package.json').version\") | tr -s ' ' | cut -d ' ' -f 3) && docker rmi $(docker images --filter \"dangling=true\" -q --no-trunc)",
@@ -17,6 +19,7 @@
     "docker:clean": "docker rmi $(docker images --filter \"dangling=true\" -q --no-trunc)",
     "docker:network": "docker network create --subnet=172.18.0.0/16 ollama-net",
     "docker:build": "docker build --no-cache -t discord/bot:$(node -p \"require('./package.json').version\") .",
+    "docker:test": "docker run -d --rm -v discord:/src/app --name test discord/bot:$(node -p \"require('./package.json').version\") npm run test:run",
     "docker:client": "docker run -d -v discord:/src/app --name discord --network ollama-net --ip 172.18.0.3 discord/bot:$(node -p \"require('./package.json').version\")",
     "docker:ollama": "docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama --network ollama-net --ip 172.18.0.2 ollama/ollama:latest",
     "docker:ollama-cpu": "docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama --network ollama-net --ip 172.18.0.2 ollama/ollama:latest"
@@ -24,17 +27,18 @@
   "author": "Kevin Dang",
   "license": "ISC",
   "dependencies": {
-    "axios": "^1.6.2",
     "discord.js": "^14.14.1",
     "dotenv": "^16.3.1",
     "ollama": "^0.5.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
+    "@vitest/coverage-v8": "^1.6.0",
     "nodemon": "^3.0.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.6.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.0"
   },
   "type": "module",
   "engines": {

src/commands/capacity.ts

@@ -1,6 +1,6 @@
 import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
 import { SlashCommand } from '../utils/commands.js'
-import { openFile } from '../utils/jsonHandler.js'
+import { openConfig } from '../utils/jsonHandler.js'
 
 export const Capacity: SlashCommand = {
     name: 'modify-capacity',
@@ -20,10 +20,10 @@ export const Capacity: SlashCommand = {
     run: async (client: Client, interaction: CommandInteraction) => {
         // fetch channel and message
         const channel = await client.channels.fetch(interaction.channelId)
-        if (!channel || channel.type !== ChannelType.GuildText) return
+        if (!channel || channel.type !== ChannelType.PublicThread) return
 
         // set state of bot chat features
-        openFile('config.json', interaction.commandName, interaction.options.get('context-capacity')?.value)
+        openConfig('config.json', interaction.commandName, interaction.options.get('context-capacity')?.value)
 
         interaction.reply({
             content: `Message History Capacity has been set to \`${interaction.options.get('context-capacity')?.value}\``,

src/commands/disable.ts

@@ -1,10 +1,10 @@
 import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
 import { SlashCommand } from '../utils/commands.js'
-import { openFile } from '../utils/jsonHandler.js'
+import { openConfig } from '../utils/jsonHandler.js'
 
 export const Disable: SlashCommand = {
     name: 'toggle-chat',
-    description: 'toggle all chat features, slash commands will still work.',
+    description: 'toggle all chat features, Adminstrator Only.',
 
     // set available user options to pass to the command
     options: [
@@ -22,8 +22,17 @@ export const Disable: SlashCommand = {
         const channel = await client.channels.fetch(interaction.channelId)
         if (!channel || channel.type !== ChannelType.GuildText) return
 
+        // check if runner is an admin
+        if (!interaction.memberPermissions?.has('Administrator')) {
+            interaction.reply({
+                content: `${interaction.commandName} is an Administrator Command.\n\nYou, ${interaction.member?.user.username}, are not an Administrator in this server.\nPlease contact an admin to use this command.`,
+                ephemeral: true
+            })
+            return
+        }
+
         // set state of bot chat features
-        openFile('config.json', interaction.commandName, interaction.options.get('enabled')?.value)
+        openConfig('config.json', interaction.commandName, interaction.options.get('enabled')?.value)
 
         interaction.reply({
             content: `Chat features has been \`${interaction.options.get('enabled')?.value ?  "enabled" : "disabled" }\``,

src/commands/index.ts

@@ -5,9 +5,11 @@ import { MessageStream } from './messageStream.js'
 import { Disable } from './disable.js'
 import { Shutoff } from './shutoff.js'
 import { Capacity } from './capacity.js'
+import { PrivateThreadCreate } from './threadPrivateCreate.js'
 
 export default [
     ThreadCreate,
+    PrivateThreadCreate,
     MessageStyle,
     MessageStream,
     Disable,

src/commands/messageStream.ts

@@ -1,6 +1,6 @@
 import { ApplicationCommandOptionType, ChannelType, Client, CommandInteraction } from 'discord.js'
 import { SlashCommand } from '../utils/commands.js'
-import { openFile } from '../utils/jsonHandler.js'
+import { openConfig } from '../utils/jsonHandler.js'
 
 export const MessageStream: SlashCommand = {
     name: 'message-stream',
@@ -20,10 +20,10 @@ export const MessageStream: SlashCommand = {
     run: async (client: Client, interaction: CommandInteraction) => {
         // verify channel
         const channel = await client.channels.fetch(interaction.channelId)
-        if (!channel || channel.type !== ChannelType.GuildText) return
+        if (!channel || channel.type !== ChannelType.PublicThread) return
 
         // save value to json and write to it
-        openFile('config.json', interaction.commandName, interaction.options.get('stream')?.value)
+        openConfig('config.json', interaction.commandName, interaction.options.get('stream')?.value)
 
         interaction.reply({
             content: `Message streaming preferences for embed set to: \`${interaction.options.get('stream')?.value}\``,

src/commands/messageStyle.ts

@@ -1,6 +1,6 @@
 import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
 import { SlashCommand } from '../utils/commands.js'
-import { openFile } from '../utils/jsonHandler.js'
+import { openConfig } from '../utils/jsonHandler.js'
 
 export const MessageStyle: SlashCommand = {
     name: 'message-style',
@@ -20,10 +20,10 @@ export const MessageStyle: SlashCommand = {
     run: async (client: Client, interaction: CommandInteraction) => {
         // fetch channel and message
         const channel = await client.channels.fetch(interaction.channelId)
-        if (!channel || channel.type !== ChannelType.GuildText) return
+        if (!channel || channel.type !== ChannelType.PublicThread) return
 
         // set the message style
-        openFile('config.json', interaction.commandName, interaction.options.get('embed')?.value)
+        openConfig('config.json', interaction.commandName, interaction.options.get('embed')?.value)
 
         interaction.reply({
             content: `Message style preferences for embed set to: \`${interaction.options.get('embed')?.value}\``,

src/commands/shutoff.ts

@@ -1,10 +1,9 @@
 import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
 import { SlashCommand } from '../utils/commands.js'
-import Keys from '../keys.js'
 
 export const Shutoff: SlashCommand = {
     name: 'shutoff',
-    description: 'shutdown the bot. You will need to manually bring it online again.',
+    description: 'shutdown the bot. You will need to manually bring it online again. Administrator Only.',
 
     // set available user options to pass to the command
     options: [
@@ -25,24 +24,22 @@ export const Shutoff: SlashCommand = {
         // log this, this will probably be improtant for logging who did this
         console.log(`User -> ${interaction.user.tag} attempting to shutdown ${client.user!!.tag}`)
 
-        // create list of superUsers based on string parse
-        const superUsers: string[] = JSON.parse(Keys.superUser.replace(/'/g, '"'))
-
         // check if admin or false on shutdown
-        if (interaction.user.tag !in superUsers) {
+        if (!interaction.memberPermissions?.has('Administrator')) {
             interaction.reply({
-                content: `Shutdown failed:\n\n${interaction.user.tag}, You do not have permission to shutoff **${client.user?.tag}**.`,
+                content: `**Shutdown Aborted:**\n\n${interaction.user.tag}, You do not have permission to shutoff **${client.user?.tag}**.`,
                 ephemeral: true
             })
             return // stop from shutting down
         } else if (!interaction.options.get('are-you-sure')?.value) {
             interaction.reply({
-                content: `Shutdown failed:\n\n${interaction.user.tag}, You didn't want to shutoff **${client.user?.tag}**.`,
+                content: `**Shutdown Aborted:**\n\n${interaction.user.tag}, You didn't want to shutoff **${client.user?.tag}**.`,
                 ephemeral: true
             })
-            return
+            return // chickened out
         }
 
+        // Shutoff cleared, do it
         interaction.reply({
             content: `${client.user?.tag} is ${interaction.options.get('are-you-sure')?.value ?  "shutting down now." : "not shutting down." }`,
             ephemeral: true

src/commands/threadCreate.ts

@@ -1,5 +1,6 @@
 import { ChannelType, Client, CommandInteraction, TextChannel } from 'discord.js'
 import { SlashCommand } from '../utils/commands.js'
+import { openThreadInfo } from '../utils/jsonHandler.js'
 
 export const ThreadCreate: SlashCommand = {
     name: 'thread',
@@ -12,16 +13,21 @@ export const ThreadCreate: SlashCommand = {
         if (!channel || channel.type !== ChannelType.GuildText) return
 
         const thread = await (channel as TextChannel).threads.create({
-            name: `support-${Date.now()}`,
+            name: `${client.user?.username}-support-${Date.now()}`,
-            reason: `Support ticket ${Date.now()}`
+            reason: `Support ticket ${Date.now()}`,
+            type: ChannelType.PublicThread
         })
 
         // Send a message in the thread
-        thread.send(`**User:** ${interaction.user} \n**People in Coversation:** ${thread.memberCount}`)
+        thread.send(`Hello ${interaction.user} and others! \n\nIt's nice to meet you. Please talk to me by typing **@${client.user?.username}** with your prompt.`)
+
+        // handle storing this chat channel
+        // store: thread.id, thread.name
+        openThreadInfo(`${thread.id}.json`, thread)
 
         // user only reply
         return interaction.reply({
-            content: `I can help you in the Thread below. \n**Thread ID:** ${thread.id}`,
+            content: `I can help you in thread **${thread.id}** below.`,
             ephemeral: true
         })
     }

src/commands/threadPrivateCreate.ts

@@ -0,0 +1,34 @@
+import { ChannelType, Client, CommandInteraction, TextChannel } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openThreadInfo } from '../utils/jsonHandler.js'
+
+export const PrivateThreadCreate: SlashCommand = {
+    name: 'private-thread',
+    description: 'creates a private thread and mentions user',
+
+    // Query for server information
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch the channel
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        const thread = await (channel as TextChannel).threads.create({
+            name: `${client.user?.username}-private-support-${Date.now()}`,
+            reason: `Support ticket ${Date.now()}`,
+            type: ChannelType.PrivateThread
+        })
+
+        // Send a message in the thread
+        thread.send(`Hello ${interaction.user}! \n\nIt's nice to meet you. Please talk to me by typing @${client.user?.username} with your prompt.`)
+
+        // handle storing this chat channel
+        // store: thread.id, thread.name
+        openThreadInfo(`${thread.id}.json`, thread)
+
+        // user only reply
+        return interaction.reply({
+            content: `I can help you in thread **${thread.id}**. Please refer to the private channel below this one.`,
+            ephemeral: true
+        })
+    }
+}

src/events/index.ts

@@ -2,10 +2,12 @@ import { Event } from '../utils/index.js'
 import interactionCreate from './interactionCreate.js'
 import messageCreate from './messageCreate.js'
 import ready from './ready.js'
+import threadDelete from './threadDelete.js'
 
 // Centralized export for all events
 export default [
     ready,
     messageCreate,
-    interactionCreate
+    interactionCreate,
+    threadDelete
 ] as Event[] // staticly is better ts practice, dynamic exporting is possible

src/events/messageCreate.ts

@@ -1,17 +1,25 @@
-import { ChatResponse } from 'ollama'
+import { embedMessage, event, Events, normalMessage, UserMessage } from '../utils/index.js'
-import { embedMessage, event, Events, normalMessage } from '../utils/index.js'
+import { Configuration, getConfig, getThread, openConfig, openThreadInfo } from '../utils/jsonHandler.js'
-import { Configuration, getConfig, openFile } from '../utils/jsonHandler.js'
 import { clean } from '../utils/mentionClean.js'
+import { ThreadChannel } from 'discord.js'
 
 /** 
  * Max Message length for free users is 2000 characters (bot or not).
  * @param message the message received from the channel
  */
-export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama }, message) => {
+export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama, client }, message) => {
     log(`Message \"${clean(message.content)}\" from ${message.author.tag} in channel/thread ${message.channelId}.`)
 
-    // Hard-coded channel to test output there only, in our case "ollama-endpoint"
+    // need new check for "open/active" threads here!
-    if (message.channelId != tokens.channel) return
+    const threadMessages: UserMessage[] = await new Promise((resolve) => {
+        // set new queue to modify
+        getThread(`${message.channelId}.json`, (threadInfo) => {
+            if (threadInfo?.messages)
+                resolve(threadInfo.messages)
+            else
+                log(`Channel/Thread ${message.channelId} does not exist.`)
+        }) 
+    })
 
     // Do not respond if bot talks in the chat
     if (message.author.tag === message.client.user.tag) return
@@ -19,6 +27,8 @@ export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama
     // Only respond if message mentions the bot
     if (!message.mentions.has(tokens.clientUid)) return
 
+    let shouldStream = false
+
     // Try to query and send embed     
     try {
         const config: Configuration = await new Promise((resolve, reject) => {
@@ -45,11 +55,18 @@ export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama
                     msgHist.capacity = config.options['modify-capacity']
                 }
 
+                // set stream state
+                shouldStream = config.options['message-stream'] as boolean || false
+
                 resolve(config)
             })
         })
 
-        let response: ChatResponse    
+        // response string for ollama to put its response
+        let response: string
+
+        // set up new queue
+        msgHist.setQueue(threadMessages)
 
         // check if we can push, if not, remove oldest
         while (msgHist.size() >= msgHist.capacity) msgHist.dequeue()
@@ -62,9 +79,9 @@ export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama
         
         // undefined or false, use normal, otherwise use embed
         if (config.options['message-style'])
-            response = await embedMessage(message, ollama, tokens, msgHist)
+            response = await embedMessage(message, ollama, tokens, msgHist, shouldStream)
         else
-            response = await normalMessage(message, ollama, tokens, msgHist)
+            response = await normalMessage(message, ollama, tokens, msgHist, shouldStream)
 
         // If something bad happened, remove user query and stop
         if (response == undefined) { msgHist.pop(); return }
@@ -75,11 +92,17 @@ export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama
         // successful query, save it in context history
         msgHist.enqueue({ 
             role: 'assistant', 
-            content: response.message.content 
+            content: response
         })
+
+        // only update the json on success
+        openThreadInfo(`${message.channelId}.json`, 
+            client.channels.fetch(message.channelId) as unknown as ThreadChannel, 
+            msgHist.getItems()
+        )
     } catch (error: any) {
         msgHist.pop() // remove message because of failure
-        openFile('config.json', 'message-style', false)
+        openConfig('config.json', 'message-style', false)
         message.reply(`**Error Occurred:**\n\n**Reason:** *${error.message}*`)
     }
 })

src/events/threadDelete.ts

@@ -0,0 +1,20 @@
+import { ThreadChannel } from 'discord.js'
+import { event, Events } from '../utils/index.js'
+import fs from 'fs'
+
+/**
+ * Event to remove the associated .json file for a thread once deleted
+ */
+export default event(Events.ThreadDelete, ({ log }, thread: ThreadChannel) => {
+    const filePath = `data/${thread.id}.json`
+    if (fs.existsSync(filePath)) {
+        fs.unlink(filePath, (error) => {
+            if (error)
+                log(`Error deleting file ${filePath}`, error)
+            else
+                log(`Successfully deleted ${filePath} thread info`)
+        })
+    } else {
+        log(`File ${filePath} does not exist.`)
+    }
+})

src/keys.ts

@@ -2,13 +2,11 @@ import { getEnvVar } from './utils/env.js'
 
 export const Keys = {
     clientToken: getEnvVar('CLIENT_TOKEN'),
-    channel: getEnvVar('CHANNEL_ID'),
     model: getEnvVar('MODEL'),
     clientUid: getEnvVar('CLIENT_UID'),
     guildId: getEnvVar('GUILD_ID'),
     ipAddress: getEnvVar('OLLAMA_IP'),
     portAddress: getEnvVar('OLLAMA_PORT'),
-    superUser: getEnvVar('ADMINS')
 } as const // readonly keys
 
 export default Keys

src/queues/queue.ts

@@ -53,10 +53,18 @@ export class Queue<T> implements IQueue<T> {
     }
 
     /**
-     * Geet the queue as an array
+     * Get the queue as an array
      * @returns a array of T items
      */
     getItems(): T[] {
         return this.storage
     }
+
+    /**
+     * Set a new queue to modify
+     * @param newQueue new queue of T[] to modify
+     */
+    setQueue(newQueue: T[]): void {
+        this.storage = newQueue
+    }
 }

src/utils/events.ts

@@ -15,11 +15,22 @@ export type EventKeys = keyof ClientEvents // only wants keys of ClientEvents ob
  * @param clientUid the discord id for the bot
  */
 export type Tokens = {
-    channel: string,
     model: string,
     clientUid: string
 }
 
+/**
+ * Parameters to run the chat query
+ * @param model the model to run
+ * @param ollama ollama api client
+ * @param msgHist message history
+ */
+export type ChatParams = {
+    model: string, 
+    ollama: Ollama, 
+    msgHist: UserMessage[]
+}
+
 /** 
  * Format for the messages to be stored when communicating when the bot
  * @param role either assistant, user, or system

src/utils/index.ts

@@ -3,4 +3,5 @@ export * from './env.js'
 export * from './events.js'
 export * from './messageEmbed.js'
 export * from './messageNormal.js'
-export * from './commands.js'
+export * from './commands.js'
+export * from './streamHandler.js'

src/utils/jsonHandler.ts

@@ -1,4 +1,7 @@
+import { ThreadChannel } from 'discord.js'
+import { UserMessage } from './events.js'
 import fs from 'fs'
+import path from 'path'
 
 export interface Configuration {
     readonly name: string
@@ -10,6 +13,12 @@ export interface Configuration {
     }
 }
 
+export interface Thread {
+    readonly id: string
+    readonly name: string
+    messages: UserMessage[]
+}
+
 /**
  * Method to open a file in the working directory and modify/create it
  * 
@@ -17,19 +26,19 @@ export interface Configuration {
  * @param key key value to access
  * @param value new value to assign
  */
-export function openFile(filename: string, key: string, value: any) {
+export function openConfig(filename: string, key: string, value: any) {
     // check if the file exists, if not then make the config file
     if (fs.existsSync(filename)) {
         fs.readFile(filename, 'utf8', (error, data) => {
             if (error)
-                console.log(`[Error: openFile] Incorrect file format`)
+                console.log(`[Error: openConfig] Incorrect file format`)
             else {
                 const object = JSON.parse(data)
                 object['options'][key] = value
                 fs.writeFileSync(filename, JSON.stringify(object, null, 2))
             }
         })
-    } else {
+    } else { // work on dynamic file creation
         const object: Configuration = JSON.parse('{ \"name\": \"Discord Ollama Confirgurations\" }')
 
         // set standard information for config file and options
@@ -38,10 +47,16 @@ export function openFile(filename: string, key: string, value: any) {
         }
 
         fs.writeFileSync(filename, JSON.stringify(object, null, 2))
-        console.log(`[Util: openFile] Created 'config.json' in working directory`)
+        console.log(`[Util: openConfig] Created '${filename}' in working directory`)
     }
 }
 
+/**
+ * Method to obtain the configurations of the message chat/thread
+ * 
+ * @param filename name of the configuration file to get
+ * @param callback function to allow a promise from getting the config
+ */
 export async function getConfig(filename: string, callback: (config: Configuration | undefined) => void): Promise<void> {
     // attempt to read the file and get the configuration
     if (fs.existsSync(filename)) {
@@ -55,4 +70,59 @@ export async function getConfig(filename: string, callback: (config: Configurati
     } else {
         callback(undefined) // file not found
     }
+}
+
+/**
+ * Method to open/create and modify a json file containing thread information
+ * 
+ * @param filename name of the thread file
+ * @param thread the thread with all of the interactions
+ * @param message message contents and from who
+ */
+export function openThreadInfo(filename: string, thread: ThreadChannel, messages: UserMessage[] = []) {
+    // check if the file exists, if not then make the config file
+    const fullFileName = `data/${filename}`
+    if (fs.existsSync(fullFileName)) {
+        fs.readFile(fullFileName, 'utf8', (error, data) => {
+            if (error)
+                console.log(`[Error: openConfig] Incorrect file format`)
+            else {
+                const object = JSON.parse(data)
+                object['messages'] = messages as []
+                fs.writeFileSync(fullFileName, JSON.stringify(object, null, 2))
+            }
+        })
+    } else { // file doesn't exist, create it
+        const object: Configuration = JSON.parse(`{ \"id\": \"${thread?.id}\", \"name\": \"${thread?.name}\", \"messages\": []}`)
+
+        const directory = path.dirname(fullFileName)
+        if (!fs.existsSync(directory))
+            fs.mkdirSync(directory, { recursive: true })
+
+        // only creating it, no need to add anything
+        fs.writeFileSync(fullFileName, JSON.stringify(object, null, 2))
+        console.log(`[Util: openThreadInfo] Created '${fullFileName}' in working directory`)
+    }
+}
+
+/**
+ * Method to obtain the configurations of the message chat/thread
+ * 
+ * @param filename name of the configuration file to get
+ * @param callback function to allow a promise from getting the config
+ */
+export async function getThread(filename: string, callback: (config: Thread | undefined) => void): Promise<void> {
+    // attempt to read the file and get the configuration
+    const fullFileName = `data/${filename}`
+    if (fs.existsSync(fullFileName)) {
+        fs.readFile(fullFileName, 'utf8', (error, data) => {
+            if (error) {
+                callback(undefined) 
+                return // something went wrong... stop
+            }
+            callback(JSON.parse(data))
+        })
+    } else {
+        callback(undefined) // file not found
+    }
 }

src/utils/messageEmbed.ts

@@ -1,6 +1,6 @@
 import { EmbedBuilder, Message } from 'discord.js'
 import { ChatResponse, Ollama } from 'ollama'
-import { UserMessage } from './events.js'
+import { ChatParams, UserMessage, streamResponse, blockResponse } from './index.js'
 import { Queue } from '../queues/queue.js'
 
 /**
@@ -13,13 +13,14 @@ export async function embedMessage(
     message: Message,
     ollama: Ollama,
     tokens: {
-        channel: string,
         model: string
     },
-    msgHist: Queue<UserMessage>
+    msgHist: Queue<UserMessage>,
-) {
+    stream: boolean
+): Promise<string> {
     // bot response
-    let response: ChatResponse
+    let response: ChatResponse | AsyncGenerator<ChatResponse, any, unknown>
+    let result: string = ''
 
     // initial message to client
     const botMessage = new EmbedBuilder()
@@ -30,28 +31,88 @@ export async function embedMessage(
     // send the message
     const sentMessage = await message.channel.send({ embeds: [botMessage] })
 
+    // create params
+    const params: ChatParams = {
+        model: tokens.model,
+        ollama: ollama,
+        msgHist: msgHist.getItems()
+    }
+
     try {
-        // Attempt to query model for message
+        // check if embed needs to stream
-        response = await ollama.chat({
+        if (stream) {
-            model: tokens.model,
+            response = await streamResponse(params)
-            messages: msgHist.getItems(),
-            options: {
-                num_thread: 8, // remove if optimization needed further
-                mirostat: 1,
-                mirostat_tau: 2.0,
-                top_k: 70
-            },
-            stream: false
-        })
 
-        // dummy message to let user know that query is underway
+            for await (const portion of response) {
-        const newEmbed = new EmbedBuilder()
+                result += portion.message.content
-            .setTitle(`Responding to ${message.author.tag}`)
-            .setDescription(response.message.content || 'No Content to Provide...')
-            .setColor('#00FF00')
 
-        // edit the message
+                // exceeds handled length
-        sentMessage.edit({ embeds: [newEmbed] })
+                if (result.length > 5000) {
+                    const errorEmbed = new EmbedBuilder()
+                    .setTitle(`Responding to ${message.author.tag}`)
+                    .setDescription(`Response length ${result.length} has exceeded Discord maximum.\n\nLong Stream messages not supported.`)
+                    .setColor('#00FF00')
+
+                    // send error
+                    message.channel.send({ embeds: [errorEmbed] })
+                    break // cancel loop and stop
+                }
+
+                // new embed per token...
+                const streamEmbed = new EmbedBuilder()
+                .setTitle(`Responding to ${message.author.tag}`)
+                .setDescription(result || 'No Content Yet...')
+                .setColor('#00FF00')
+
+                // edit the message
+                sentMessage.edit({ embeds: [streamEmbed] })
+            }
+        } else {
+            response = await blockResponse(params)
+            result = response.message.content
+
+            // long message, split into different embeds sadly.
+            if (result.length > 5000) {
+                const firstEmbed = new EmbedBuilder()
+                .setTitle(`Responding to ${message.author.tag}`)
+                .setDescription(result.slice(0, 5000) || 'No Content to Provide...')
+                .setColor('#00FF00')
+
+                // replace first embed
+                sentMessage.edit({ embeds: [firstEmbed] })
+
+                // take the rest out
+                result = result.slice(5000)
+
+                // handle the rest
+                while (result.length > 5000) {
+                    const whileEmbed = new EmbedBuilder()
+                    .setTitle(`Responding to ${message.author.tag}`)
+                    .setDescription(result.slice(0, 5000) || 'No Content to Provide...')
+                    .setColor('#00FF00')
+
+                    message.channel.send({ embeds: [whileEmbed] })
+                    result = result.slice(5000)
+                }
+
+                const lastEmbed = new EmbedBuilder()
+                .setTitle(`Responding to ${message.author.tag}`)
+                .setDescription(result || 'No Content to Provide...')
+                .setColor('#00FF00')
+
+                // rest of the response
+                message.channel.send({ embeds: [lastEmbed] })
+            } else {
+                // only need to create 1 embed, handles 6000 characters
+                const newEmbed = new EmbedBuilder()
+                .setTitle(`Responding to ${message.author.tag}`)
+                .setDescription(result || 'No Content to Provide...')
+                .setColor('#00FF00')
+
+                // edit the message
+                sentMessage.edit({ embeds: [newEmbed] })
+            }
+        }
     } catch(error: any) {
         console.log(`[Util: messageEmbed] Error creating message: ${error.message}`)
         const errorEmbed = new EmbedBuilder()
@@ -64,5 +125,5 @@ export async function embedMessage(
     } 
 
     // Hope there is a response! undefined otherwie
-    return response!!
+    return result
 }

src/utils/messageNormal.ts

@@ -1,6 +1,6 @@
 import { Message } from 'discord.js'
 import { ChatResponse, Ollama } from 'ollama'
-import { UserMessage } from './events.js'
+import { ChatParams, UserMessage, streamResponse, blockResponse } from './index.js'
 import { Queue } from '../queues/queue.js'
 
 /**
@@ -13,41 +13,66 @@ export async function normalMessage(
     message: Message,
     ollama: Ollama,
     tokens: {
-        channel: string,
         model: string
     },
-    msgHist: Queue<UserMessage>
+    msgHist: Queue<UserMessage>,
-) {
+    stream: boolean
+): Promise<string> {
     // bot's respnse
-    let response: ChatResponse
+    let response: ChatResponse | AsyncGenerator<ChatResponse, any, unknown>
+    let result: string = ''
 
     await message.channel.send('Generating Response . . .').then(async sentMessage => {
         try {
-            // Attempt to query model for message
+            const params: ChatParams = {
-            response = await ollama.chat({
                 model: tokens.model,
-                messages: msgHist.getItems(),
+                ollama: ollama,
-                options: {
+                msgHist: msgHist.getItems()
-                    num_thread: 8, // remove if optimization needed further
+            } 
-                    mirostat: 1,
-                    mirostat_tau: 2.0,
-                    top_k: 70
-                },
-                stream: false
-            })
 
-            // check if message length > discord max for normal messages
+            // run query based on stream preference, true = stream, false = block
-            if (response.message.content.length > 2000) {
+            if (stream) {
-                sentMessage.edit(response.message.content.slice(0, 2000))
+                response = await streamResponse(params)
-                message.channel.send(response.message.content.slice(2000))
+                for await (const portion of response) {
-            } else // edit the 'generic' response to new message
+                    // append token to message
-                sentMessage.edit(response.message.content)            
+                    result += portion.message.content
+
+                    // exceeds handled length
+                    if (result.length > 2000) {
+                        message.channel.send(`Response length ${result.length} has exceeded Discord maximum.\n\nLong Stream messages not supported.`)
+                        break // stop stream
+                    }
+
+                    // resent current output, THIS WILL BE SLOW due to discord limits!
+                    sentMessage.edit(result || 'No Content Yet...')
+                }
+            }
+            else {
+                response = await blockResponse(params)
+                result = response.message.content
+
+                // check if message length > discord max for normal messages
+                if (result.length > 2000) {
+                    sentMessage.edit(result.slice(0, 2000))
+                    result = result.slice(2000)
+
+                    // handle for rest of message that is >2000
+                    while (result.length > 2000) {
+                        message.channel.send(result.slice(0, 2000))
+                        result = result.slice(2000)
+                    }
+
+                    // last part of message
+                    message.channel.send(result)
+                } else // edit the 'generic' response to new message since <2000
+                    sentMessage.edit(result)
+            }            
         } catch(error: any) {
             console.log(`[Util: messageNormal] Error creating message: ${error.message}`)
             sentMessage.edit(`**Response generation failed.**\n\nReason: ${error.message}`)
         }
     })
 
-    // Hope there is a response, force client to believe
+    // return the string representation of ollama query response
-    return response!!
+    return result
-}
+}

src/utils/streamHandler.ts

@@ -0,0 +1,40 @@
+import { ChatResponse } from "ollama"
+import { ChatParams } from "./index.js"
+
+/**
+ * Method to query the Ollama client for async generation
+ * @param params 
+ * @returns Asyn
+ */
+export async function streamResponse(params: ChatParams): Promise<AsyncGenerator<ChatResponse, any, unknown>> {
+    return await params.ollama.chat({
+        model: params.model,
+        messages: params.msgHist,
+        options: {
+            num_thread: 8, // remove if optimization needed further
+            mirostat: 1,
+            mirostat_tau: 2.0,
+            top_k: 70
+        },
+        stream: true
+    })
+}
+
+/**
+ * Method to query the Ollama client for a block response 
+ * @param params parameters to query the client
+ * @returns ChatResponse generated by the Ollama client
+ */
+export async function blockResponse(params: ChatParams): Promise<ChatResponse> {
+    return await params.ollama.chat({
+        model: params.model,
+        messages: params.msgHist,
+        options: {
+            num_thread: 8, // remove if optimization needed further
+            mirostat: 1,
+            mirostat_tau: 2.0,
+            top_k: 70
+        },
+        stream: false
+    })
+}

src/utils/streamParse.ts

@@ -1,27 +0,0 @@
-import { AxiosResponse } from 'axios'
-
-/**
- * When running a /api/chat stream, the output needs to be parsed into an array of objects
- *  This method is used for development purposes and testing
- * 
- * This will not work as intended with the inclusion of ollama-js, needs to be modified to work with it
- * 
- * @param stream Axios response to from Ollama
- */
-export function parseStream(stream: AxiosResponse<any, any>) {
-    // split string by newline
-    const keywordObjects: string[] = stream.data.trim().split('\n')
-
-    // parse string and load them into objects
-    const keywordsArray: {
-        model: string,
-        created_at: string,
-        message: {
-            role: string,
-            content: string
-        },
-        done: boolean
-    }[] = keywordObjects.map((keywordString) => JSON.parse(keywordString))
-
-    return keywordsArray
-}

tests/commands.test.ts

@@ -0,0 +1,27 @@
+// describe marks a test suite
+// expect takes a value from an expression
+// it marks a test case
+import { describe, expect, it } from 'vitest'
+import commands from '../src/commands'
+
+/**
+ * Commands test suite, tests the commands object
+ * Each command is to be tested elsewhere, this file
+ * is to ensure that the commands object is defined.
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#commands', () => {
+    // test definition of commands object
+    it('references defined object', () => {
+        // toBe compares the value to the expected value
+        expect(typeof commands).toBe('object')
+    })
+
+    // test specific commands in the object
+    it('references specific commands', () => {
+        const commandsString = commands.map(e => e.name).join(', ')
+        expect(commandsString).toBe('thread, private-thread, message-style, message-stream, toggle-chat, shutoff, modify-capacity')
+    })
+})

tests/events.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import events from '../src/events'
+
+/**
+ * Events test suite, tests the events object
+ * Each event is to be tested elsewhere, this file
+ * is to ensure that the events object is defined.
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#events', () => {
+    // test definition of events object
+    it('references defined object', () => {
+        expect(typeof events).toBe('object')
+    })
+
+    // test specific events in the object
+    it('references specific events', () => {
+        const eventsString = events.map(e => e.key.toString()).join(', ')
+        expect(eventsString).toBe('ready, messageCreate, interactionCreate, threadDelete')
+    })
+})

tests/getEnvVar.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import { getEnvVar } from '../src/utils'
+
+/**
+ * getEnvVar test suite, tests the getEnvVar function
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#getEnvVar', () => {
+    // dummy set of keys
+    const keys = {
+        clientToken: 'CLIENT_TOKEN',
+    }
+
+    // set keys in environment
+    process.env['clientToken'] = keys.clientToken
+
+    // test for non-empty string
+    it('returns a non-empty string', () => {
+        expect(getEnvVar('CLIENT_TOKEN')).not.toBe('')
+    })
+
+    // test for string type
+    it('returns a string', () => {
+        expect(typeof getEnvVar('CLIENT_TOKEN')).toBe('string')
+    })
+
+    // test for distinct key
+    it('returns a distinct key', () => {
+        expect(getEnvVar('CLIENT_TOKEN')).toEqual(process.env[keys.clientToken])
+    })
+
+    // test for fallback case
+    it('returns a fallback', () => {
+        expect(getEnvVar('NON_EXISTENT_KEY', 'fallback')).toBe('fallback')
+    })
+
+    // test that all keys are consistently found
+    it('returns all keys found', () => {
+        for (const key in keys) {
+            expect(getEnvVar(key)).toEqual(keys[key])
+        }
+    })
+
+    // test that an error is thrown if key is not found
+    it('throws an error if key is not found', () => {
+        expect(() => getEnvVar('NON_EXISTENT_KEY')).toThrowError()
+    })
+})

tests/mentionClean.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { clean } from '../src/utils/mentionClean'
+import { getEnvVar } from '../src/utils'
+
+/**
+ * MentionClean test suite, tests the clean function
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#clean', () => {
+    // test for id removal from message
+    it('removes the mention from a message', () => {
+        const message = `<@${getEnvVar('CLIENT_UID')}> Hello, World!`
+        expect(clean(message)).toBe('Hello, World!')
+    })
+})

tests/queue.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+import { Queue } from '../src/queues/queue'
+
+/**
+ * Queue test suite, tests the Queue class
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#queue', () => {
+    let queue= new Queue<string>()
+
+    // test for queue creation
+    it('creates a new queue', () => {
+        expect(queue).not.toBeNull()
+    })
+
+    // test for queue capacity creation
+    it('adds specific capacity to the queue', () => {
+        queue = new Queue<string>(2)
+        expect(queue).not.toBeNull()
+    })
+
+    // test for enqueue success, size update
+    it('adds items to the queue', () => {
+        queue.enqueue('hello')
+        expect(queue.size()).toBe(1)
+    })
+
+    // test for multiple enqueue success, size update
+    it('adds multiple items to the queue', () => {
+        queue.enqueue('world')
+        expect(queue.size()).toBe(2)
+    })
+
+    // test for enqueue failure upon capacity overflow
+    it('throws an error when the queue is full', () => {
+        expect(() => queue.enqueue('!')).toThrowError()
+    })
+
+    // test for getItems success
+    it('returns all items in the queue', () => {
+        expect(queue.getItems()).toEqual(['hello', 'world'])
+    })
+
+    // test for pop success, size update
+    it('removes an item from the front of the queue', () => {
+        queue.pop()
+        expect(queue.size() && queue.getItems()[0]).toBe(1 && 'hello')
+    })
+
+    // test for dequeue success, size update
+    it('removes an item from the back of the queue', () => {
+        queue.dequeue()
+        expect(queue.size() && queue.getItems()[0]).toBe(0 && 'world')
+    })
+
+    // test for getItems success with nothing in the list
+    it('returns an empty array when the queue is empty', () => {
+        expect(queue.getItems()).toEqual([])
+    })
+})

vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig, configDefaults } from 'vitest/config'
+
+// config for vitest
+export default defineConfig({
+    test: {
+        globals: true, // <-- reduces test file imports
+        coverage: {
+            exclude: [...configDefaults.exclude, 'build/*'], // <-- exclude JS build
+            reporter: ['text', 'html'] // <-- reports in text, html
+        }
+    }
+})