Data Directory on Chat for Preferences (#105)

* Fix: data directory created on for openConfig

* Update: version increment

.env.sample

@@ -1,27 +1,18 @@
 # Discord token for the bot
 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
 
 # discord bot user id for mentions
 CLIENT_UID = BOT_USER_ID
 
-# ip/port address of docker container, I use 172.18.X.X for docker, 127.0.0.1 for local
+# ip/port address of docker container, I use 172.18.0.3 for docker, 127.0.0.1 for local
 OLLAMA_IP = IP_ADDRESS
 OLLAMA_PORT = PORT
 
-# ip address for discord bot container, I use 172.18.X.X, use different IP than ollama_ip
+# ip address for discord bot container, I use 172.18.0.2, use different IP than ollama_ip
 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/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Bug Report for Fixes/Improvements
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest Features
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+## Issue
+A clear and concise description of what the problem/feature is.
+
+## Solution
+* Provide steps or ideals to how to implement or investigate this new feature.
+
+## References
+* Provide additional context and external references here

.github/pull_request_template.md

@@ -0,0 +1,19 @@
+## Steps to Creating a Pull Request
+* Assign yourself as the **Assignee**
+* Allow one of the Code Owners/Maintainers review the changes proposed by the Pull Request.
+* Provide appropriate labels as necessary
+
+> [!TIP]
+> `enchancement` for new features, `documentation` for modifications to the docs, `performance` for performance related changes, and so on.
+
+* Provide a description of the work that has been done.
+    * It is nice to know what was added, removed, modified, and with screenshots of those changes.
+
+> [!TIP]
+> You can have them under **Added**, **Removed**, **Updates**, and **Screenshots** if any (**Changes** could also be used).
+
+## After the Pull Request is Opened
+* One the Pull Request has been created, please add any Issue(s) that are being addressed by this change (if any).
+* If the reviewer(s) mention any changes or open threads for questions, please resolve those as soon as you can.
+
+# Ensure you version increment as necessary!!!

.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:
+  push:
+    branches:
+      - master # runs after Pull Request is merged
+
+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 lts/hydrogen
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/hydrogen
+          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 lts/hydrogen
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/hydrogen
+          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 'kevinthedang/discord-ollama' && 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/release.yml

@@ -0,0 +1,51 @@
+name: release
+run-name: Release Docker Image
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  Deploy-Image:
+    runs-on: ubuntu-latest
+    environment: release
+    timeout-minutes: 3
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node Environment lts/hydrogen
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/hydrogen
+          cache: "npm"
+
+      - name: Create Environment Variables
+        run: |
+          touch .env
+          echo CLIENT_TOKEN = NOT_REAL_TOKEN >> .env
+          echo GUILD_ID = 123456 >> .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: Get Version from package.json
+        run: echo "VERSION=$(jq -r '.version' package.json)" >> $GITHUB_ENV
+      
+      - name: Build Image
+        run: |
+          npm run docker:build
+
+      - name: Build Image as Latest
+        run: |
+          npm run docker:build-latest
+      
+      - name: Log into Docker
+        run: |
+          docker login --username ${{ vars.DOCKER_USER }} --password ${{ secrets.DOCKER_PASS }}
+
+      - name: Release Docker Image
+        run: |
+          docker push ${{ vars.DOCKER_USER }}/discord-ollama:${{ env.VERSION }}
+          docker push ${{ vars.DOCKER_USER }}/discord-ollama:latest

.github/workflows/test.yml

@@ -0,0 +1,50 @@
+name: Tests
+run-name: Unit Tests
+on:
+  pull_request:
+    branches:
+      - master
+    paths:
+      - '*'
+      - 'package*.json'
+      - 'src/**'
+      - 'tests/**'
+      - '!docs/**'
+      - '!imgs/**'
+      - '!.github/**'
+      - '.github/workflows/**'
+      - '!.gitignore'
+      - '!LICENSE'
+      - '!README'
+
+jobs:
+  Discord-Node-Test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node Environment lts/hydrogen
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/hydrogen
+          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

Dockerfile

@@ -1,5 +1,5 @@
 # use node LTS image for version 18
-FROM node:18.18.2
+FROM node:hydrogen-alpine
 
 # set working directory inside container
 WORKDIR /app

LICENSE

@@ -0,0 +1,395 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

README.md

@@ -1,23 +1,30 @@
 <div align="center">
-    <p><a href="#"><a href="https://ollama.ai/"><img alt="ollama" src="./imgs/ollama-icon.png" width="200px" /></a><img alt="+" src="./imgs/grey-plus.png" width="100px" /></a><a href="https://discord.com/"><img alt="discord" src="./imgs/discord-icon.png" width="190px" /></a></p>
+    <p><a href="#"><a href="https://ollama.ai/"><img alt="ollama" src="./imgs/ollama-icon.png" width="200px" /></a><img alt="+" src="./imgs/grey-plus.png" width="100px" /></a><a href="https://discord.com/"><img alt="discord" src="./imgs/discord-icon.png" width="195px" /></a></p>
     <h1>Discord Ollama Integration</h1>
     <h3><a href="#"></a>Ollama as your Discord AI Assistant</h3>
-    <p><a href="#"></a><a href="https://creativecommons.org/licenses/by-nc/4.0/"><img alt="License" src="https://img.shields.io/badge/License-CC_BY--NC_4.0-darkgreen.svg" /></a>
+    <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
 Ollama is an AI model management tool that allows users to install and use custom large language models locally.  
 The project aims to:
 * [x] Create a Discord bot that will utilize Ollama and chat to chat with users! 
-  * [ ] User Preferences on Chat
-  * [ ] Message Persistance on Channels and Threads
+  * [x] User Preferences on Chat
+  * [x] Message Persistance on Channels and Threads
+    * [x] Threads
+    * [x] Channels
   * [x] Containerization with Docker
   * [x] Slash Commands Compatible
-  * [ ] Generated Token Length Handling for >2000 or >6000 characters
-  * [ ] External WebUI Integration
-  * [ ] Administrator Role Compatible
+  * [x] Generated Token Length Handling for >2000
+    * [x] Token Length Handling of any message size
+  * [x] User vs. Server Preferences
+  * [ ] Redis Caching
+  * [x] Administrator Role Compatible
+  * [x] Multi-User Chat Generation (Multiple users chatting at the same time) - This was built into from Ollama `v0.2.1+`
+  * [ ] Automatic and Manual model pulling through the Discord client
 * [ ] Allow others to create their own models personalized for their own servers!
   * [ ] Documentation on creating your own LLM
   * [ ] Documentation on web scrapping and cleaning
@@ -26,20 +33,25 @@ The project aims to:
 * Clone this repo using `git clone https://github.com/kevinthedang/discord-ollama.git` or just use [GitHub Desktop](https://desktop.github.com/) to clone the repo.
 * You will need a `.env` file in the root of the project directory with the bot's token. There is a `.env.sample` is provided for you as a reference for what environment variables.
     * For example, `CLIENT_TOKEN = [Bot Token]`
-* Please refer to the docs for bot setup. **NOTE**: These guides assume you already know how to setup a bot account for discord.
+* Please refer to the docs for bot setup.
     * [Local Machine Setup](./docs/setup-local.md)
     * [Docker Setup for Servers and Local Machines](./docs/setup-docker.md)
+        * Nvidia is recommended for now, but support for other GPUs should be development.
         * Local use is not recommended.
+    * [Creating a Discord App](./docs/setup-discord-app.md)
 
 ## Resources
 * [NodeJS](https://nodejs.org/en)
-    * This project uses `v20.10.0+` (npm `10.2.5`). Consider using [nvm](https://github.com/nvm-sh/nvm) for multiple NodeJS versions.
-        * To run dev in `ts-node`, using `v18.18.2` is recommended. **CAUTION**: `v18.19.0` or `lts/hydrogen` will not run properly.
+    * This project runs on `lts\hydrogen`.
+        * To run dev in `ts-node`/`nodemon`, using `v18.18.2` is recommended. 
         * To run dev with `tsx`, you can use `v20.10.0` or earlier.
     * This project supports any NodeJS version above `16.x.x` to only allow ESModules.
-* [Ollama](https://ollama.ai/)
+* [Ollama](https://ollama.com/)
     * [Ollama Docker Image](https://hub.docker.com/r/ollama/ollama)
-    * **IMPORTANT**: For Nvidia GPU setup, **install** `nvidia container toolkit/runtime` then **configure** it with Docker to utilize Nvidia driver.
+
+> [!CAUTION]
+> `v18.X.X` or `lts/hydrogen` will not run properly for `npm run dev-mon`. It is recommended to just use `npm run dev-tsx` for development. The nodemon version will likely be removed in a future update.
+
 * [Discord Developer Portal](https://discord.com/developers/docs/intro)
 * [Discord.js Docs](https://discord.js.org/docs/packages/discord.js/main)
 * [Setting up Docker (Ubuntu 20.04)](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-20-04)
@@ -49,4 +61,4 @@ The project aims to:
 * [Kevin Dang](https://github.com/kevinthedang)
 * [Jonathan Smoley](https://github.com/JT2M0L3Y)
 
-[discord-ollama](https://github.com/kevinthedang/discord-ollama) © 2023 by [Kevin Dang](https://github.com/kevinthedang) is licensed under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/?ref=chooser-v1)
+[discord-ollama](https://github.com/kevinthedang/discord-ollama) © 2023 by [Kevin Dang](https://github.com/kevinthedang) is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)

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.3.5
+    image: kevinthedang/discord-ollama:0.5.9
     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:

docs/setup-discord-app.md

@@ -0,0 +1,47 @@
+## Discord App/Bot Setup
+* Refer to the [Discord Developers](https://discord.com/build/app-developers) tab on their site.
+* Click on **Getting Started** and it may prompt you to log in. Do that.
+* You should see this upon logging in.
+
+![First App!](../imgs/tutorial/discord-dev.png)
+
+* Click on **Create App**, you should not be prompted to create an App with a name. If you are apart of a team, you may choose to create it for your team or for yourself.
+
+![App Create Modal](../imgs/tutorial/create-app.png)
+
+* Great! Not you should have your App created. It should bring you to a page like this.
+
+![Created App](../imgs/tutorial/created-app.png)
+
+* From here, you will need you App's token, navigate to the **Bot** tab and click **Reset Token** to generate a new token to interact with you bot.
+* The following app will not exist, usage of this token will be pointless as this is a guide.
+
+![Token](../imgs/tutorial/token.png)
+
+* You will also need your App's **Client ID**, navigate to **OAuth2** and copy your id.
+
+![Client Id](../imgs/tutorial/client-id.png)
+
+* That should be all of the environment variables needed from Discord, now we need this app on your server.
+* Navigate to **Installation** and Copy the provided **Install Link** to allow your App to your server.
+* You should set the **Guild Install** permissions as you like, for this purpose we will allow admin priviledges for now. Ensure the **bot** scope is added to do this.
+
+![Scope](../imgs/tutorial/scope.png)
+![Invite Link](../imgs/tutorial/invite.png)
+
+* Notice that your App's **Client Id** is apart of the **Install Link**.
+* Paste this link in a web browser and you should see something like this.
+
+![Server Invite Initial](../imgs/tutorial/server-invite-1.png)
+
+* Click **Add to Server** and you should see this.
+
+![Server Invite Auth](../imgs/tutorial/server-invite-2-auth.png)
+
+* Choose a server to add the App to, then click **Continue** then **Authorize**. You should see this after that.
+
+![Invite Success](../imgs/tutorial/server-invite-3.png)
+
+* Congratulations! You should now see you App on your server!
+
+![Its Alive!](../imgs/tutorial/bot-in-server.png)

docs/setup-docker.md

@@ -47,6 +47,7 @@ sudo systemctl restart docker
     * `DISCORD_IP = 172.18.0.3`
     * `SUBNET_ADDRESS = 172.18.0.0`
     * Don't understand any of this? watch a Networking video to understand subnetting.
+    * You also need all environment variables shown in [`.env.sample`](../.env.sample)
 * You will need a model in the container for this to work properly, on Docker Desktop go to the `Containers` tab, select the `ollama` container, and select `Exec` to run as root on your container. Now, run `ollama pull [model name]` to get your model.
     * For Linux Servers, you need another shell to pull the model, or if you run `docker compose build && docker compose up -d`, then it will run in the background to keep your shell. Run `docker exec -it ollama bash` to get into the container and run the samme pull command above.
 * Otherwise, there is no need to install any npm packages for this, you just need to run `npm run start` to pull the containers and spin them up.
@@ -54,6 +55,7 @@ sudo systemctl restart docker
     * `docker compose stop`
     * `docker compose rm`
     * `docker ps` to check if containers have been removed.
+    * This may not work if the nvidia installation was done incorrectly. If this is the case, please utilize the [Manual "Clean-up"](#manual-run-with-docker) shown below.
 * You can also use `npm run clean` to clean up the containers and remove the network to address a possible `Address already in use` problem.
 
 ## Manual Run (with Docker)

docs/setup-local.md

@@ -1,19 +1,24 @@
 ## Ollama Setup
 * Go to Ollama's [Linux download page](https://ollama.ai/download/linux) and run the simple curl command they provide. The command should be `curl https://ollama.ai/install.sh | sh`.
-* Now the the following commands in separate terminals to test out how it works!
+* Since Ollama will run as a systemd service, there is no need to run `ollama serve` unless you disable it. If you do disable it or have an older `ollama` version, do the following:
     * In terminal 1 -> `ollama serve` to setup ollama
     * In terminal 2 -> `ollama run [model name]`, for example `ollama run llama2`
         * The models can vary as you can create your own model. You can also view ollama's [library](https://ollama.ai/library) of models.
-    * If there are any issues running ollama because of missing LLMs, run `ollama pull [model name]` as it will pull the model if Ollama has it in their library.
+* Otherwise, if you have the latest `ollama`, you can just run `ollama run [model name]` rather than running this in 2 terminals.
+* If there are any issues running ollama because of missing LLMs, run `ollama pull [model name]` as it will pull the model if Ollama has it in their library.
     * This can also be done in [wsl](https://learn.microsoft.com/en-us/windows/wsl/install) for Windows machines.
+    * This should also not be a problem is a future feature that allows for pulling of models via discord client. For now, they must be pulled manually.
 * You can now interact with the model you just ran (it might take a second to startup).
     * Response time varies with processing power!
 
 ## To Run Locally (without Docker)
 * Run `npm install` to install the npm packages.
 * Ensure that your [.env](../.env.sample) file's `OLLAMA_IP` is `127.0.0.1` to work properly.
+    * You only need your `CLIENT_TOKEN`, `GUILD_ID`, `MODEL`, `CLIENT_UID`, `OLLAMA_IP`, `OLLAMA_PORT`.
+    * The ollama ip and port should just use it's defaults by nature. If not, utilize `OLLAMA_IP = 127.0.0.1` and `OLLAMA_PORT = 11434`.
 * Now, you can run the bot by running `npm run client` which will build and run the decompiled typescript and run the setup for ollama.
     * **IMPORTANT**: This must be ran in the wsl/Linux instance to work properly! Using Command Prompt/Powershell/Git Bash/etc. will not work on Windows (at least in my experience).
     * Refer to the [resources](../README.md#resources) on what node version to use.
-* Open up a separate terminal/shell (you will need wsl for this if on windows) and run `ollama serve` to startup ollama.
+* If you are using wsl, open up a separate terminal/shell to startup the ollama service. Again, if you are running an older ollama, you must run `ollama serve` in that shell.
+    * If you are on an actual Linux machine/VM there is no need for another terminal (unless you have an older ollama version).
     * If you do not have a model, you will need to run `ollama pull [model name]` in a separate terminal to get it.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-ollama",
-  "version": "0.3.5",
+  "version": "0.5.9",
   "description": "Ollama Integration into discord",
   "main": "build/index.js",
   "exports": "./build/index.js",
@@ -8,33 +8,37 @@
     "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)",
     "start": "docker compose build --no-cache && docker compose up -d",
     "docker:start": "npm run docker:network && npm run docker:build && npm run docker:client && npm run docker:ollama",
     "docker:start-cpu": "npm run docker:network && npm run docker:build && npm run docker:client && npm run docker:ollama-cpu",
-    "docker:clean": "docker rmi $(docker images --filter \"dangling=true\" -q --no-trunc)",
+    "docker:clean": "docker rm -f discord && docker rm -f ollama && 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: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:build": "docker build --no-cache -t kevinthedang/discord-ollama:$(node -p \"require('./package.json').version\") .",
+    "docker:build-latest": "docker build --no-cache -t kevinthedang/discord-ollama:latest .",
+    "docker:client": "docker run -d -v discord:/src/app --name discord --network ollama-net --ip 172.18.0.3 kevinthedang/discord-ollama:$(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"
   },
   "author": "Kevin Dang",
   "license": "ISC",
   "dependencies": {
-    "axios": "^1.6.2",
-    "discord.js": "^14.14.1",
-    "dotenv": "^16.3.1",
-    "ollama": "^0.4.6"
+    "discord.js": "^14.15.3",
+    "dotenv": "^16.4.5",
+    "ollama": "^0.5.6"
   },
   "devDependencies": {
-    "@types/node": "^20.10.5",
-    "nodemon": "^3.0.2",
+    "@types/node": "^20.14.12",
+    "@vitest/coverage-v8": "^2.0.4",
+    "nodemon": "^3.1.4",
     "ts-node": "^10.9.2",
-    "tsx": "^4.6.2",
-    "typescript": "^5.3.3"
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.4"
   },
   "type": "module",
   "engines": {

src/commands/capacity.ts

@@ -0,0 +1,33 @@
+import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openConfig } from '../utils/index.js'
+
+export const Capacity: SlashCommand = {
+    name: 'modify-capacity',
+    description: 'number of messages bot will hold for context.',
+
+    // set available user options to pass to the command
+    options: [
+        {
+            name: 'context-capacity',
+            description: 'a number to set capacity',
+            type: ApplicationCommandOptionType.Number,
+            required: true
+        }
+    ],
+
+    // Query for message information and set the style
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch channel and message
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== (ChannelType.PrivateThread && ChannelType.PublicThread && ChannelType.GuildText)) return
+
+        // set state of bot chat features
+        openConfig(`${interaction.user.username}-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}\``,
+            ephemeral: true
+        })
+    }
+}

src/commands/channelToggle.ts

@@ -0,0 +1,33 @@
+import { ApplicationCommandOptionType, ChannelType, Client, CommandInteraction } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openConfig } from '../utils/index.js'
+
+export const ChannelToggle: SlashCommand = {
+    name: 'channel-toggle',
+    description: 'toggles channel or thread usage.',
+
+    // set user option for toggling
+    options: [
+        {
+            name: 'toggle-channel',
+            description: 'toggle channel usage, otherwise threads',
+            type: ApplicationCommandOptionType.Boolean,
+            required: true
+        }
+    ],
+
+    // Query for chatting preference
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch channel location
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== (ChannelType.PrivateThread && ChannelType.PublicThread && ChannelType.GuildText)) return
+
+        // set state of bot channel preferences
+        openConfig(`${interaction.guildId}-config.json`, interaction.commandName, interaction.options.get('toggle-channel')?.value)
+
+        interaction.reply({
+            content: `Channel Preferences have for Regular Channels set to \`${interaction.options.get('toggle-channel')?.value}\``,
+            ephemeral: true
+        })
+    }
+}

src/commands/cleanUserChannelHistory.ts

@@ -0,0 +1,34 @@
+import { ChannelType, Client, CommandInteraction, TextChannel } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { clearChannelInfo } from '../utils/index.js'
+
+export const ClearUserChannelHistory: SlashCommand = {
+    name: 'clear-user-channel-history',
+    description: 'clears history for user running this command in current channel',
+
+    // Clear channel history for intended user
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch current channel
+        const channel = await client.channels.fetch(interaction.channelId)
+
+        // if not an existing channel or a GuildText, fail command
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        // clear channel info for user
+        const successfulWipe = await clearChannelInfo(interaction.channelId, 
+            interaction.channel as TextChannel, 
+            interaction.user.username)
+
+        // check result of clearing history
+        if (successfulWipe)
+            interaction.reply({ 
+                content: `Channel history in **${channel.name}** cleared for **${interaction.user.username}**.`, 
+                ephemeral: true
+            })
+        else
+            interaction.reply({ 
+                content: `Channel history could not be found for **${interaction.user.username}** in **${channel.name}**.\n\nPlease chat with **${client.user?.username}** to start a chat history.`, 
+                ephemeral: true
+            })
+    }
+}

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/index.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(`${interaction.guildId}-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

@@ -4,11 +4,19 @@ import { MessageStyle } from './messageStyle.js'
 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'
+import { ChannelToggle } from './channelToggle.js'
+import { ClearUserChannelHistory } from './cleanUserChannelHistory.js'
 
 export default [
     ThreadCreate,
+    PrivateThreadCreate,
     MessageStyle,
     MessageStream,
     Disable,
-    Shutoff
+    Shutoff,
+    Capacity,
+    ChannelToggle,
+    ClearUserChannelHistory
 ] as SlashCommand[]

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/index.js'
 
 export const MessageStream: SlashCommand = {
     name: 'message-stream',
@@ -20,13 +20,13 @@ 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.PrivateThread && ChannelType.PublicThread && ChannelType.GuildText)) return
 
         // save value to json and write to it
-        openFile('config.json', interaction.commandName, interaction.options.get('stream')?.value)
+        openConfig(`${interaction.user.username}-config.json`, interaction.commandName, interaction.options.get('stream')?.value)
 
         interaction.reply({
-            content: `Message streaming preferences for embed set to: \`${interaction.options.get('stream')?.value}\``,
+            content: `Message streaming preferences set to: \`${interaction.options.get('stream')?.value}\``,
             ephemeral: true
         })
     }

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/index.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.PrivateThread && ChannelType.PublicThread && ChannelType.GuildText)) return
 
         // set the message style
-        openFile('config.json', interaction.commandName, interaction.options.get('embed')?.value)
+        openConfig(`${interaction.user.username}-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/index.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()}`,
-            reason: `Support ticket ${Date.now()}`
+            name: `${client.user?.username}-support-${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.\n\nIf I do not respond, ensure \`channel-toggle\` is set to \`false\``)
+
+        // 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/index.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,73 +1,155 @@
-import { ChatResponse } from 'ollama'
-import { embedMessage, event, Events, normalMessage } from '../utils/index.js'
-import { Configuration, getConfig, openFile } from '../utils/jsonHandler.js'
+import { embedMessage, event, Events, normalMessage, UserMessage } from '../utils/index.js'
+import { getChannelInfo, getServerConfig, getThread, getUserConfig, openChannelInfo, openConfig, openThreadInfo, ServerConfig, UserConfig } from '../utils/index.js'
+import { clean } from '../utils/mentionClean.js'
+import { TextChannel, ThreadChannel } from 'discord.js'
 
 /** 
  * Max Message length for free users is 2000 characters (bot or not).
+ * Bot supports infinite lengths for normal messages.
+ * 
  * @param message the message received from the channel
  */
-export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama }, message) => {
-    log(`Message \"${message.content}\" from ${message.author.tag} in channel/thread ${message.channelId}.`)
-
-    // Hard-coded channel to test output there only, in our case "ollama-endpoint"
-    if (message.channelId != tokens.channel) return
+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}.`)
 
     // Do not respond if bot talks in the chat
-    if (message.author.tag === message.client.user.tag) return
+    if (message.author.username === message.client.user.username) return
 
     // Only respond if message mentions the bot
     if (!message.mentions.has(tokens.clientUid)) return
 
-    // check if we can push, if not, remove oldest
-    if (msgHist.size() === msgHist.getCapacity()) msgHist.dequeue()
+    // default stream to false
+    let shouldStream = false
  
-    // push user response
-    msgHist.enqueue({
-        role: 'user',
-        content: message.content
-    })
-
-    // Try to query and send embed     
     try {
-        const config: Configuration = await new Promise((resolve, reject) => {
-            getConfig('config.json', (config) => {
+        // Retrieve Server/Guild Preferences
+        const serverConfig: ServerConfig = await new Promise((resolve, reject) => {
+            getServerConfig(`${message.guildId}-config.json`, (config) => {
                 // check if config.json exists
                 if (config === undefined) {
-                    reject(new Error('No Configuration is set up.\n\nCreating \`config.json\` with \`message-style\` set as \`true\` for embedded messages.\nPlease try chatting again.'))
+                    // Allowing chat options to be available
+                    openConfig(`${message.guildId}-config.json`, 'toggle-chat', true)
+
+                    // default to channel scope chats
+                    openConfig(`${message.guildId}-config.json`, 'channel-toggle', true)
+                    reject(new Error('No Server Preferences is set up.\n\nCreating default server preferences file...\nPlease try chatting again.'))
                     return
                 }
 
                 // check if chat is disabled
-                if(!config.options['toggle-chat']) {
+                if (!config.options['toggle-chat']) {
                     reject(new Error('Admin(s) have disabled chat features.\n\n Please contact your server\'s admin(s).'))
                     return
                 }
+
+                // ensure channel json exists, if not create it
+                if (config.options['channel-toggle']) {
+                    openChannelInfo(message.channelId,
+                        message.channel as TextChannel, 
+                        message.author.username
+                    )
+                }
+
                 resolve(config)
             })
         })
 
-        let response: ChatResponse    
+        // Retrieve User Preferences
+        const userConfig: UserConfig = await new Promise((resolve, reject) => {
+            getUserConfig(`${message.author.username}-config.json`, (config) => {
+                if (config === undefined) {
+                    openConfig(`${message.author.username}-config.json`, 'message-style', false)
+                    reject(new Error('No User Preferences is set up.\n\nCreating preferences file with \`message-style\` set as \`false\` for regular messages.\nPlease try chatting again.'))
+                    return
+                }
+    
+                // check if there is a set capacity in config
+                if (typeof config.options['modify-capacity'] !== 'number')
+                    log(`Capacity is undefined, using default capacity of ${msgHist.capacity}.`)
+                else if (config.options['modify-capacity'] === msgHist.capacity)
+                    log(`Capacity matches config as ${msgHist.capacity}, no changes made.`)
+                else {
+                    log(`New Capacity found. Setting Context Capacity to ${config.options['modify-capacity']}.`)
+                    msgHist.capacity = config.options['modify-capacity']
+                }
+    
+                // set stream state
+                shouldStream = config.options['message-stream'] as boolean || false
+    
+                resolve(config)
+            })
+        })
+
+        
+
+        // need new check for "open/active" threads/channels here!
+        const chatMessages: UserMessage[] = await new Promise((resolve) => {
+            // set new queue to modify
+            if (serverConfig.options['channel-toggle']) {
+                getChannelInfo(`${message.channelId}-${message.author.username}.json`, (channelInfo) => {
+                    if (channelInfo?.messages)
+                        resolve(channelInfo.messages)
+                    else
+                        log(`Channel ${message.channel}-${message.author.username} does not exist.`)
+                })
+            } else {
+                getThread(`${message.channelId}.json`, (threadInfo) => {
+                    if (threadInfo?.messages)
+                        resolve(threadInfo.messages)
+                    else
+                        log(`Thread ${message.channelId} does not exist.`)
+                }) 
+            }
+        })
+
+        // response string for ollama to put its response
+        let response: string
+
+        // set up new queue
+        msgHist.setQueue(chatMessages)
+
+        // check if we can push, if not, remove oldest
+        while (msgHist.size() >= msgHist.capacity) msgHist.dequeue()
+
+        // push user response before ollama query
+        msgHist.enqueue({
+            role: 'user',
+            content: clean(message.content)
+        })
         
         // undefined or false, use normal, otherwise use embed
-        if (config.options['message-style'])
-            response = await embedMessage(message, ollama, tokens, msgHist)
+        if (userConfig.options['message-style'])
+            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 }
 
         // if queue is full, remove the oldest message
-        if (msgHist.size() === msgHist.getCapacity()) msgHist.dequeue()
+        while (msgHist.size() >= msgHist.capacity) msgHist.dequeue()
 
-        // successful query, save it as history
+        // successful query, save it in context history
         msgHist.enqueue({ 
             role: 'assistant', 
-            content: response.message.content 
+            content: response
         })
+
+        // only update the json on success
+        if (serverConfig.options['channel-toggle']) {
+            openChannelInfo(message.channelId, 
+                message.channel as TextChannel, 
+                message.author.tag, 
+                msgHist.getItems()
+            )
+        } else {
+            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', true)
         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,10 @@ 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

@@ -17,7 +17,7 @@ export class Queue<T> implements IQueue<T> {
      * Set up Queue
      * @param capacity max length of queue
      */
-    constructor(private capacity: number = 5) {}
+    constructor(public capacity: number = 5) {}
 
     /**
      * Put item in front of queue
@@ -53,7 +53,7 @@ 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[] {
@@ -61,10 +61,10 @@ export class Queue<T> implements IQueue<T> {
     }
 
     /**
-     * Get capacity of the queue
-     * @returns capacity of queue
+     * Set a new queue to modify
+     * @param newQueue new queue of T[] to modify
      */
-    getCapacity(): number {
-        return this.capacity
+    setQueue(newQueue: T[]): void {
+        this.storage = newQueue
     }
 }

src/utils/configInterfaces.ts

@@ -0,0 +1,58 @@
+import { UserMessage } from './events.js'
+
+export interface UserConfiguration {
+    'message-stream'?: boolean,
+    'message-style'?: boolean,
+    'modify-capacity': number
+}
+
+export interface ServerConfiguration {
+    'toggle-chat'?: boolean,
+    'channel-toggle'?: boolean
+}
+
+/**
+ * Parent Configuration interface
+ * 
+ * @see ServerConfiguration server settings per guild
+ * @see UserConfiguration user configurations (only for the user for any server)
+ */
+export interface Configuration {
+    readonly name: string
+    options: UserConfiguration | ServerConfiguration
+}
+
+/**
+ * User config to use outside of this file
+ */
+export interface UserConfig {
+    readonly name: string
+    options: UserConfiguration
+}
+
+export interface ServerConfig {
+    readonly name: string
+    options: ServerConfiguration
+}
+
+export interface Thread {
+    readonly id: string
+    readonly name: string
+    messages: UserMessage[]
+}
+
+export interface Channel {
+    readonly id: string
+    readonly name: string
+    readonly user: string
+    messages: UserMessage[]
+}
+
+/**
+ * Check if the configuration we are editing/taking from is a Server Config
+ * @param key name of command we ran
+ * @returns true if command is from Server Config, false otherwise
+ */
+export function isServerConfigurationKey(key: string): key is keyof ServerConfiguration {
+    return ['toggle-chat', 'channel-toggle'].includes(key);
+}

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/handlers/chatHistoryHandler.ts

@@ -0,0 +1,183 @@
+import { TextChannel, ThreadChannel } from 'discord.js'
+import { Configuration, Thread, Channel, UserMessage } from '../index.js'
+import fs from 'fs'
+import path from 'path'
+
+/**
+ * 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: openThreadInfo] 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
+    }
+}
+
+/**
+ * Method to check if a thread history file exists
+ * 
+ * @param channel parent thread of the requested thread (can be GuildText)
+ * @returns true if channel does not exist, false otherwise
+ */
+async function checkChannelInfoExists(channel: TextChannel, user: string) {
+    // thread exist handler
+    const isThread: boolean = await new Promise((resolve) => {
+        getThread(`${channel.id}-${user}.json`, (channelInfo) => {
+            if (channelInfo?.messages)
+                resolve(true)
+            else
+                resolve(false)
+        })
+    })
+    return isThread
+}
+
+/**
+ * Method to clear channel history for requesting user
+ * 
+ * @param filename guild id string
+ * @param channel the TextChannel in the Guild
+ * @param user username of user
+ * @returns nothing
+ */
+export async function clearChannelInfo(filename: string, channel: TextChannel, user: string): Promise<boolean> {
+    const channelInfoExists: boolean = await checkChannelInfoExists(channel, user)
+
+    // If thread does not exist, file can't be found
+    if (!channelInfoExists) return false
+
+    // Attempt to clear user channel history
+    const fullFileName = `data/${filename}-${user}.json`
+    const cleanedHistory: boolean = await new Promise((resolve) => {
+        fs.readFile(fullFileName, 'utf8', (error, data) => {
+            if (error)
+                console.log(`[Error: openChannelInfo] Incorrect file format`)
+            else {
+                const object = JSON.parse(data)
+                if (object['messages'].length === 0) // already empty, let user know
+                    resolve(false)
+                else {
+                    object['messages'] = [] // cleared history
+                    fs.writeFileSync(fullFileName, JSON.stringify(object, null, 2))
+                    resolve(true)
+                }
+            }
+        })
+    })
+    console.log(cleanedHistory)
+    return cleanedHistory
+}
+
+/**
+ * Method to open the channel history
+ * 
+ * @param filename name of the json file for the channel by user
+ * @param channel the text channel info
+ * @param user the user's name
+ * @param messages their messages
+ */
+export async function openChannelInfo(filename: string, channel: TextChannel, user: string, messages: UserMessage[] = []): Promise<void> {
+    const isThread: boolean = await new Promise((resolve) => {
+        getThread(`${channel.id}.json`, (threadInfo) => {
+            if (threadInfo?.messages)
+                resolve(true)
+            else
+                resolve(false)
+        })
+    })
+
+    // this is a thread channel, do not duplicate files
+    if (isThread) return
+
+    const fullFileName = `data/${filename}-${user}.json`
+    if (fs.existsSync(fullFileName)) {
+        fs.readFile(fullFileName, 'utf8', (error, data) => {
+            if (error)
+                console.log(`[Error: openChannelInfo] Incorrect file format`)
+            else {
+                const object = JSON.parse(data)
+                if (object['messages'].length === 0)
+                    object['messages'] = messages as []
+                else if (object['messages'].length !== 0 && messages.length !== 0)
+                    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\": \"${channel?.id}\", \"name\": \"${channel?.name}\", \"user\": \"${user}\", \"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: openChannelInfo] Created '${fullFileName}' in working directory`)
+    }
+}
+
+/**
+ * Method to get the channel information/history
+ * 
+ * @param filename name of the json file for the channel by user
+ * @param callback function to handle resolving message history
+ */
+export async function getChannelInfo(filename: string, callback: (config: Channel | undefined) => void): Promise<void> {
+    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/handlers/configHandler.ts

@@ -0,0 +1,92 @@
+import { Configuration, ServerConfig, UserConfig, isServerConfigurationKey } from '../index.js'
+import fs from 'fs'
+import path from 'path'
+
+/**
+ * Method to open a file in the working directory and modify/create it
+ * 
+ * @param filename name of the file
+ * @param key key value to access
+ * @param value new value to assign
+ */
+// add type of change (server, user)
+export function openConfig(filename: string, key: string, value: any) {
+    const fullFileName = `data/${filename}`
+    
+    // check if the file exists, if not then make the config file
+    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['options'][key] = value
+                fs.writeFileSync(fullFileName, JSON.stringify(object, null, 2))
+            }
+        })
+    } else { // work on dynamic file creation
+        let object: Configuration
+        if (isServerConfigurationKey(key))
+            object = JSON.parse('{ \"name\": \"Server Confirgurations\" }')
+        else
+            object = JSON.parse('{ \"name\": \"User Confirgurations\" }')
+
+        // set standard information for config file and options
+        object['options'] = {
+            [key]: value
+        }
+
+        const directory = path.dirname(fullFileName)
+        if (!fs.existsSync(directory))
+            fs.mkdirSync(directory, { recursive: true })
+
+        fs.writeFileSync(`data/${filename}`, JSON.stringify(object, null, 2))
+        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 getServerConfig(filename: string, callback: (config: ServerConfig | undefined) => void): Promise<void> {
+    const fullFileName = `data/${filename}`
+
+    // attempt to read the file and get the configuration
+    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
+    }
+}
+
+/**
+ * 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 getUserConfig(filename: string, callback: (config: UserConfig | undefined) => void): Promise<void> {
+    const fullFileName = `data/${filename}`
+
+    // attempt to read the file and get the configuration
+    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/handlers/streamHandler.ts

@@ -0,0 +1,39 @@
+import { ChatResponse } from "ollama"
+import { ChatParams } from "../index.js"
+import { AbortableAsyncIterator } from "ollama/src/utils.js"
+
+/**
+ * Method to query the Ollama client for async generation
+ * @param params 
+ * @returns Asyn
+ */
+export async function streamResponse(params: ChatParams): Promise<AbortableAsyncIterator<ChatResponse>> {
+    return await params.ollama.chat({
+        model: params.model,
+        messages: params.msgHist,
+        options: {
+            mirostat: 1,
+            mirostat_tau: 2.0,
+            top_k: 70
+        },
+        stream: true
+    }) as unknown as AbortableAsyncIterator<ChatResponse>
+}
+
+/**
+ * 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: {
+            mirostat: 1,
+            mirostat_tau: 2.0,
+            top_k: 70
+        },
+        stream: false
+    })
+}

src/utils/index.ts

@@ -4,3 +4,9 @@ export * from './events.js'
 export * from './messageEmbed.js'
 export * from './messageNormal.js'
 export * from './commands.js'
+export * from './configInterfaces.js'
+
+// handler imports
+export * from './handlers/chatHistoryHandler.js'
+export * from './handlers/configHandler.js'
+export * from './handlers/streamHandler.js'

src/utils/jsonHandler.ts

@@ -1,57 +0,0 @@
-import fs from 'fs'
-
-export interface Configuration {
-    readonly name: string
-    options: {
-        'message-stream'?: boolean,
-        'message-style'?: boolean,
-        'toggle-chat'?: boolean
-    }
-}
-
-/**
- * Method to open a file in the working directory and modify/create it
- * 
- * @param filename name of the file
- * @param key key value to access
- * @param value new value to assign
- */
-export function openFile(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`)
-            else {
-                const object = JSON.parse(data)
-                object['options'][key] = value
-                fs.writeFileSync(filename, JSON.stringify(object, null, 2))
-            }
-        })
-    } else {
-        const object: Configuration = JSON.parse('{ \"name\": \"Discord Ollama Confirgurations\" }')
-
-        // set standard information for config file and options
-        object['options'] = {
-            [key]: value
-        }
-
-        fs.writeFileSync(filename, JSON.stringify(object, null, 2))
-        console.log(`[Util: openFile] Created 'config.json' in working directory`)
-    }
-}
-
-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)) {
-        fs.readFile(filename, 'utf8', (error, data) => {
-            if (error) {
-                callback(undefined) 
-                return // something went wrong... stop
-            }
-            callback(JSON.parse(data))
-        })
-    } else {
-        callback(undefined) // file not found
-    }
-}

src/utils/mentionClean.ts

@@ -0,0 +1,16 @@
+import Keys from "../keys.js"
+
+/**
+ * Clean up the bot user_id so it only has the prompt
+ * 
+ * Sample: <@CLIENT_ID> Hello
+ *  - we want to remove <@CLIENT_ID>
+ *  - replace function works well for this
+ * 
+ * @param message 
+ * @returns 
+ */
+export function clean(message: string): string {
+    const cleanedMessage: string = message.replace(`<@${Keys.clientUid}>`, '').trim()
+    return cleanedMessage
+}

src/utils/messageEmbed.ts

@@ -1,7 +1,8 @@
 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'
+import { AbortableAsyncIterator } from 'ollama/src/utils.js'
 
 /**
  * Method to send replies as normal text on discord like any other user
@@ -13,13 +14,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 | AbortableAsyncIterator<ChatResponse>
+    let result: string = ''
 
     // initial message to client
     const botMessage = new EmbedBuilder()
@@ -30,28 +32,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
-        response = await ollama.chat({
-            model: tokens.model,
-            messages: msgHist.getItems(),
-            options: {
-                num_thread: 8, // remove if optimization needed further
-                mirostat: 1,
-                mirostat_tau: 2.0,
-                top_k: 70
-            },
-            stream: false
-        })
+        // check if embed needs to stream
+        if (stream) {
+            response = await streamResponse(params)
 
-        // dummy message to let user know that query is underway
-        const newEmbed = new EmbedBuilder()
-            .setTitle(`Responding to ${message.author.tag}`)
-            .setDescription(response.message.content || 'No Content to Provide...')
-            .setColor('#00FF00')
+            for await (const portion of response) {
+                result += portion.message.content
 
-        // edit the message
-        sentMessage.edit({ embeds: [newEmbed] })
+                // exceeds handled length
+                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 +126,5 @@ export async function embedMessage(
     } 
 
     // Hope there is a response! undefined otherwie
-    return response!!
+    return result
 }

src/utils/messageNormal.ts

@@ -1,7 +1,8 @@
 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'
+import { AbortableAsyncIterator } from 'ollama/src/utils.js'
 
 /**
  * Method to send replies as normal text on discord like any other user
@@ -13,37 +14,70 @@ 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 | AbortableAsyncIterator<ChatResponse>
+    let result: string = ''
 
-    await message.reply('Generating Response . . .').then(async sentMessage => {
+    await message.channel.send('Generating Response . . .').then(async sentMessage => {
         try {
-            // Attempt to query model for message
-            response = await ollama.chat({
+            const params: ChatParams = {
                 model: tokens.model,
-                messages: msgHist.getItems(),
-                options: {
-                    num_thread: 8, // remove if optimization needed further
-                    mirostat: 1,
-                    mirostat_tau: 2.0,
-                    top_k: 70
-                },
-                stream: false
-            })
+                ollama: ollama,
+                msgHist: msgHist.getItems()
+            } 
 
-            // edit the 'generic' response to new message
-            sentMessage.edit(response.message.content)
+            // run query based on stream preference, true = stream, false = block
+            if (stream) {
+                let messageBlock: Message = sentMessage
+                response = await streamResponse(params) // THIS WILL BE SLOW due to discord limits!
+                for await (const portion of response) {
+                    // check if over discord message limit
+                    if (result.length + portion.message.content.length > 2000) {
+                        result = portion.message.content
+
+                        // new message block, wait for it to send and assign new block to respond.
+                        await message.channel.send("Creating new stream block...").then(sentMessage => { messageBlock = sentMessage })
+                    } else {
+                        result += portion.message.content
+                        
+                        // ensure block is not empty
+                        if (result.length > 5)
+                            messageBlock.edit(result) 
+                    }         
+                    console.log(result)
+                }
+            }
+            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 response!!
+    // return the string representation of ollama query response
+    return result
 }

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, channel-toggle, clear-user-channel-history')
+    })
+})

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([])
+    })
+})

tsconfig.json

@@ -2,8 +2,8 @@
   "compilerOptions": {
     // Dependent on node version
     "target": "ES2020",
-    "module": "Node16",
-    "moduleResolution": "Node16",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "strict": true,
     // We must set the type
     "noImplicitAny": true,
@@ -13,11 +13,17 @@
     "strictNullChecks": true,
     // We can import json files like JavaScript
     "resolveJsonModule": true,
-    // Decompile .ts to .js into a folder named dist
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    // Decompile .ts to .js into a folder named build
     "outDir": "build",
-    "rootDir": "src"
+    "rootDir": "src",
+    "baseUrl": ".",
+    "paths": {
+      "*": ["node_modules/"]
+    }
   },
   // environment for env vars
-  "include": ["src/**/*"],
+  "include": ["src/**/*.ts"],
   "exclude": ["node_modules"]
 }

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
+        }
+    }
+})