chatgpt_assistant 0.1.0

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,77 @@
+# ChatGPT Assistant
+
+This Ruby gem provides an easy way to initialize a client for Telegram and Discord bots using the ChatGPT API, audio transcription, IBM Cloud Text to Speech, and AWS Polly, creating an assistant that can answer questions in text and voice and have a conversation with the user.
+
+## Requirements
+
+- Ruby > 2.6.0
+- Docker
+- Docker Compose
+
+## Installation
+
+To install the gem, run:
+
+```bash
+gem install chatgpt_assistant
+```
+
+Then, edit the .env_sample file to include the necessary credentials and rename it to .env. Run bundle install to install the necessary dependencies.
+
+Remember to edit docker-compose.prod.yml when deploying to production.
+
+Alternatively, you can clone/fork this repo to use it as you wish.
+
+### Installation as a gem example
+
+```bash
+gem install chatgpt_assistant
+chatgpt_assistant PATH_TO_FOLDER
+cd PATH_TO_FOLDER
+cp .env_sample .env
+bundle install
+```
+
+## Installation as a repo
+Run in your terminal:
+```bash
+git clone https://github.com/JesusGautamah/chatgpt_assistant.git
+cd chatgpt_assistant
+cp .env_sample .env
+bundle install
+```
+
+Make sure to run bundle before using the Lucy Dockerunner rake tasks.
+
+## Usage
+
+You can start the Docker Compose services required for the gem using the rake tasks provided by the Lucy Dockerunner gem. These tasks include compose:up, compose:down, compose:status, compose:shell, compose:restart, and others listed previously.
+
+For example, to start the services, run:
+
+```ruby
+rake compose:up
+```
+
+
+To stop the services, run:
+
+```ruby
+rake compose:down
+```
+
+After starting the Docker Compose services, you can use the features of the gem to create a chat assistant that responds to questions in both text and voice using the services mentioned above.
+
+## More commands at https://github.com/JesusGautamah/lucy_dockerunner
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/JesusGautamah/chatgpt_assistant. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/JesusGautamah/chatgpt_assistant/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ChatgptAssistant project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/JesusGautamah/chatgpt_assistant/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "lucy_dockerunner"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+LucyDockerunner.load_tasks

data/deploy.sh

@@ -0,0 +1,10 @@
+#!/usr/bin bash
+
+# This script is used to deploy the application to the server
+
+echo "Deploying the application to the server..."
+cd chatgpt_assistant
+git pull
+sudo docker compose up -d
+sudo docker compose restart
+echo "Deployed the application to the server"

data/deploy_and_build.sh

@@ -0,0 +1,11 @@
+#!/usr/bin bash
+
+# This script is used to deploy the application to the server
+
+echo "Deploying the application to the server..."
+cd chatgpt_assistant
+git pull
+sudo docker compose build
+sudo docker compose up -d
+sudo docker compose restart
+echo "Deployed the application to the server"

data/docker-compose.prod.yml

@@ -0,0 +1,34 @@
+version: "3.3"
+services:
+  db:
+    image: postgres:12.2
+    ports:
+      - "5432:5432"
+    volumes:
+      - ./db_data:/var/lib/postgresql/data
+    env_file:
+      - .env
+  telegram:
+    build: .
+    command: bash -c "exe/chatgpt_bot telegram"
+    volumes:
+      - .:/chatgpt_assistant
+    environment:
+      POSTGRES_HOST: db
+    env_file:
+      - .env
+    depends_on:
+      - db
+  discord:
+    build: .
+    command: bash -c "exe/chatgpt_bot discord"
+    volumes:
+      - .:/chatgpt_assistant
+    environment:
+      POSTGRES_HOST: db
+    env_file:
+      - .env
+    depends_on:
+      - db
+volumes:
+  postgres:

data/docker-compose.yml

@@ -0,0 +1,34 @@
+version: "3.3"
+services:
+  db:
+    image: postgres:12.2
+    ports:
+      - "5432:5432"
+    volumes:
+      - ./db_data:/var/lib/postgresql/data
+    env_file:
+      - .env
+  telegram:
+    build: .
+    command: bash -c "exe/chatgpt_bot telegram"
+    volumes:
+      - .:/chatgpt_assistant
+    environment:
+      POSTGRES_HOST: db
+    env_file:
+      - .env
+    depends_on:
+      - db
+  discord:
+    build: .
+    command: bash -c "exe/chatgpt_bot discord"
+    volumes:
+      - .:/chatgpt_assistant
+    environment:
+      POSTGRES_HOST: db
+    env_file:
+      - .env
+    depends_on:
+      - db
+volumes:
+  postgres:

data/exe/chatgpt_assistant

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+path = ARGV[0]
+raise "Please specify the path to copy files to" if path.nil?
+
+puts "Creating new chatgpt assistant at #{path}"
+
+`mkdir -p #{path}`
+
+raise "Path must be empty" unless Dir.empty?(path)
+
+gem_dir = Gem::Specification.find_by_name("chatgpt_assistant").gem_dir
+
+`cp -r #{gem_dir}/lib #{path}`
+
+`mkdir -p #{path}/exe`
+
+`cp #{gem_dir}/exe/chatgpt_bot #{path}/exe`
+
+`mkdir -p #{path}/logs`
+
+`mkdir -p #{path}/voice`
+
+%w[Gemfile Gemfile.lock README.md Rakefile .env_sample .rubocop.yml .rspec].each do |file|
+  `cp #{gem_dir}/#{file} #{path}`
+end
+
+%w[docker-compose.yml docker-compose.prod.yml Dockerfile LICENSE LICENSE.txt].each do |file|
+  `cp #{gem_dir}/#{file} #{path}`
+end
+
+%w[/.bundle/ /.yardoc /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ /db_data /db_data/*
+   .rspec_status .env /logs/telegram_chatgpt.log /voice/audio* /voice/ibm* /voice/polly* /voice/aws*].each do |file_to_ignore|
+  `echo "#{file_to_ignore}" >> #{path}/.gitignore`
+end
+
+`cd #{path} && git init`
+
+puts "Done! Now you can run 'cd #{path} && bundle install'"
+puts "Build the docker image with 'rake compose:build'"
+puts "Run the bot with 'rake compose:up'"
+puts "For more information, see the README.md file"

data/exe/chatgpt_bot

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/chatgpt_assistant"
+
+puts "Starting Chatgpt Assistant"
+puts "Bot Type: #{ARGV[0]}"
+puts "Mode: #{ENV["MODE"]}"
+case ARGV[0]
+when "telegram"
+  ChatgptAssistant::Main.new("telegram").start
+when "discord"
+  ChatgptAssistant::Main.new("discord").start
+when "migrate"
+  ChatgptAssistant::Config.new.migrate
+end

data/lib/bots/application_bot.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible to contain the shared variables between the bot classes
+  class ApplicationBot
+    def initialize(config)
+      @config = config
+      default_msg = DefaultMessages.new(@config.language)
+      @logger = ChatterLogger.new
+      @openai_api_key = @config.openai_api_key
+      @telegram_token = @config.telegram_token
+      @discord_token = @config.discord_token
+      @discord_client_id = @config.discord_client_id
+      @discord_prefix = @config.discord_prefix
+      @database = @config.db_connection
+      @mode = @config.mode
+      @commom_messages = default_msg.commom_messages
+      @error_messages = default_msg.error_messages
+      @success_messages = default_msg.success_messages
+      @help_messages = default_msg.help_messages
+    end
+
+    def chatter
+      @chatter ||= Chatter.new(openai_api_key)
+    end
+
+    def audio_recognition
+      @audio_recognition ||= AudioRecognition.new(openai_api_key)
+    end
+
+    def audio_synthesis
+      @audio_synthesis ||= AudioSynthesis.new(config)
+    end
+
+    def message_create(message, chat_id, role)
+      Message.create(content: message, chat_id: chat_id, role: role)
+    end
+
+    def find_useremail(email)
+      User.find_by(email: email)
+    end
+
+    def find_userdiscord(discord_id)
+      User.find_by(discord_id: discord_id)
+    end
+
+    def find_usertelegram(telegram_id)
+      User.find_by(telegram_id: telegram_id)
+    end
+
+    def valid_password?(user, password)
+      return false if password.nil?
+
+      salt = user.password_salt
+      password_hash = user.password_hash
+
+      BCrypt::Engine.hash_secret(password, salt) == password_hash
+    end
+
+    def auth_userdiscord(email, password, discord_id)
+      user = find_useremail(email)
+      return "user not found" unless user
+      return "wrong password" if password.nil?
+
+      valid_password?(user, password) ? user_disc_access(discord_id, user.email) : "wrong password"
+    end
+
+    def user_disc_access(discord_id, user_email)
+      last_access = find_userdiscord(discord_id)
+      new_access = find_useremail(user_email)
+      last_acess.update(discord_id: nil) if last_access && (last_access != new_access)
+      new_access.update(discord_id: discord_id)
+      new_access
+    end
+
+    def discord_user_create(discord_id, email, password, name)
+      user = User.new(discord_id: discord_id, email: email, password_hash: password, name: name)
+      last_access = find_userdiscord(discord_id)
+      last_access&.update(discord_id: nil)
+      user.save
+    end
+
+    def auth_usertelegram(email, password, telegram_id)
+      user = find_useremail(email)
+      return "user not found" unless user
+      return "wrong password" if password.nil?
+
+      valid_password?(user, password) ? user_tele_access(telegram_id, user.email) : "wrong password"
+    end
+
+    def user_tele_access(telegram_id, user_email)
+      last_access = find_usertelegram(telegram_id)
+      new_access = find_useremail(user_email)
+      last_acess.update(telegram_id: nil) if last_access && (last_access != new_access)
+      new_access.update(telegram_id: telegram_id)
+      new_access
+    end
+
+    def telegram_user_create(telegram_id, email, password, name)
+      user = User.new(telegram_id: telegram_id, email: email, password_hash: password, name: name)
+      last_access = find_usertelegram(telegram_id)
+      last_access&.update(telegram_id: nil)
+      user.save
+    end
+
+    def delete_all_voice_files
+      Dir.glob("voice/*").each do |file|
+        next if [".keep", "voice/.keep"].include?(file)
+
+        File.delete(file)
+      end
+    end
+
+    attr_reader :openai_api_key, :telegram_token, :database, :default_msg,
+                :logger, :mode, :config, :discord_token, :discord_client_id,
+                :discord_prefix, :commom_messages, :error_messages, :success_messages,
+                :help_messages
+  end
+end

data/lib/bots/discord_bot.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible to handle the discord bot
+  class DiscordBot < ApplicationBot
+    def start
+      start_logs
+      start_event
+      login_event
+      register_event
+      list_event
+      hist_event
+      help_event
+      new_chat_event
+      sl_chat_event
+      ask_event
+      voice_connect_event
+      disconnect_event
+      speak_event
+      bot_init
+    end
+
+    private
+
+    attr_reader :message
+    attr_accessor :evnt, :user, :chats, :chat
+
+    def bot
+      @bot ||= Discordrb::Commands::CommandBot.new(
+        token: discord_token,
+        client_id: discord_client_id,
+        prefix: discord_prefix
+      )
+    end
+
+    def start_logs
+      logger.log("Starting Discord bot")
+      logger.log("Discord Prefix: #{discord_prefix}")
+    end
+
+    def start_event
+      bot.command :start do |event|
+        @evnt = event
+        @user = event.user
+        start_action
+      end
+      logger.log("Start Event Configured")
+    end
+
+    def start_action
+      logger.log("USER: #{user.username} - #{user.id}\n MESSAGE: #{event.message.content}")
+      evnt.respond commom_messages[:start]
+      evnt.respond commom_messages[:start_helper].gsub("register/", "gpt!register ")
+      evnt.respond commom_messages[:start_sec_helper].gsub("login/", "gpt!login ")
+    end
+
+    def login_event
+      bot.command :login do |event|
+        @message = event.message.content.split(" ")[1]
+        @evnt = event
+        message.nil? ? event.respond(commom_messages[:login]) : login_action
+      end
+      logger.log("Login Event Configured")
+    end
+
+    def login_action
+      user_email = message.split(":")[0]
+      user_password = message.split(":")[1]
+      case auth_userdiscord(user_email, user_password, evnt.user.id)
+      when "user not found"
+        logger.log("User not found: #{user_email}")
+        evnt.respond error_messages[:user_not_found]
+      when "wrong password"
+        logger.log("Wrong password: #{user_email}")
+        evnt.respond error_messages[:wrong_password]
+      when find_useremail(user_email)
+        logger.log("User logged in: #{user_email}")
+        evnt.respond success_messages[:user_logged_in]
+      end
+    end
+
+    def register_event
+      bot.command :register do |event|
+        @message = event.message.content.split(" ")[1]
+        @evnt = event
+        message.nil? ? event.respond(commom_messages[:register]): register_action
+      end
+      logger.log("Register Event Configured")
+    end
+
+    def register_action
+      user_email = message.split(":")[0]
+      user_password = message.split(":")[1]
+      find_useremail(user_email).nil? ? create_user_action(user_email, user_password) : evnt.respond(error_messages[:user_already_exists])
+    end
+
+    def create_user_action(mail, pass)
+      logger.log("Creating user #{mail}")
+      id = evnt.user.id
+      name = evnt.user.username
+      discord_user_create(id, mail, pass, name) ? evnt.respond(success_messages[:user_created]) : evnt.respond(error_messages[:user_not_created])
+    end
+
+    def list_event
+      bot.command :list do |event|
+        @evnt = event
+        @user = User.find_by(discord_id: event.user.id)
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+
+        @chats = Chat.where(user_id: user.id) if user
+        event.respond error_messages[:chat_not_found] if chats.empty? && user
+
+        list_action if user && !chats.empty?
+      end
+      logger.log("List Event Configured")
+    end
+
+    def list_action
+      chats_title = chats.map(&:title)
+      evnt.respond commom_messages[:chat_list]
+      evnt.respond chats_title.join("\n")
+    end
+
+    def hist_event
+      bot.command :hist do |event|
+        @evnt = event
+        @user = User.find_by(discord_id: event.user.id)
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+        title = event.message.content.split(" ")[1 .. -1].join(" ")
+        @chat = Chat.find_by(user_id: user.id, title: title) if user
+        event.respond error_messages[:chat_not_found] if chat.nil? && user
+        hist_action if user && chat
+      end
+      logger.log("Hist Event Configured")
+    end
+
+    def hist_action
+      messages = Message.where(chat_id: chat.id).order(:created_at)
+      messages.each do |message|
+        evnt.respond "#{message.role} - #{message.content}\n#{message.created_at.strftime("%d/%m/%Y %H:%M")}"
+      end
+      "This is the end of the chat history"
+    end
+
+    def help_event
+      bot.command :help do |event|
+        @evnt  = event
+        help_action
+      end
+      logger.log("Help Event Configured")
+    end
+
+    def help_action
+      message = help_messages.join("\n").gsub(" /", " gpt!")
+                               .gsub("register/", "gpt!register ")
+                               .gsub("login/", "gpt!login ")
+                               .gsub("new_chat/", "gpt!new_chat/")
+                               .gsub("sl_chat/", "gpt!sl_chat/")
+      evnt.respond message
+    end
+
+    def new_chat_event
+      bot.command :new_chat do |event|
+        @evnt = event
+        @user = User.find_by(discord_id: event.user.id)
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+        create_chat_action if user
+      end
+      logger.log("New Chat Event Configured")
+    end
+
+    def create_chat_action
+      chat_title = event.message.content.split(" ")[1..].join(" ")
+      chat = Chat.new(user_id: user.id, title: chat_title, status: 0)
+      chat.save ? respond_with_success : evnt.respond(error_messages[:chat_creation])
+    end
+
+    def respond_with_success
+      user.update(current_chat_id: chat.id)
+      evnt.respond success_messages[:chat_created]
+    end
+
+    def sl_chat_event
+      bot.command :sl_chat do |event|
+        @evnt = event
+        chat_to_select = event.message.content.split(" ")[1..].join(" ")
+        
+        @user = User.find_by(discord_id: event.user.id)
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+
+        sl_chat_action(chat_to_select) if user
+      end
+      logger.log("SL Chat Event Configured")
+    end
+
+    def sl_chat_action(chat_to_select)
+      @chat = Chat.find_by(title: chat_to_select, user_id: user.id)
+      evnt.respond error_messages[:chat_not_found] if chat.nil?
+      user.update(current_chat_id: chat.id) if chat
+      evnt.respond success_messages[:chat_selected] if chat
+    end
+
+    def ask_event
+      bot.command :ask do |event|
+        @evnt = event
+        @message = event.message.content.split(" ")[1..].join(" ")
+        @user = User.find_by(discord_id: event.user.id)
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+        ask_action if user
+      end
+      logger.log("Ask Event Configured")
+    end
+
+    def ask_action
+      @chat = Chat.where(id: user.current_chat_id).last
+      evnt.respond error_messages[:chat_not_found] if chat.nil?
+      @message = Message.new(chat_id: chat.id, content: message, role: "user") if chat
+      (message.save ? answer_action : evnt.respond(error_messages[:message_not_saved])) if chat
+    end
+
+    def answer_action
+      response = chatter.chat(message.content, chat.id)
+      evnt.respond response
+    end
+
+    def voice_connect_event
+      bot.command :connect do |event|
+        @evnt = event
+        @user = User.find_by(discord_id: event.user.id)
+        @chat = Chat.where(id: user.current_chat_id).last
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+        event.respond error_messages[:chat_not_found] if user && chat.nil?
+        event.respond error_messages[:user_not_in_voice_channel] if event.user.voice_channel.nil? && user
+        event.respond error_messages[:bot_already_connected] if event.voice && user
+        bot.voice_connect(event.user.voice_channel) if bot_disconnected?
+        "Connected to voice channel" if bot_connected?
+      end
+      logger.log("Voice Connect Event Configured")
+    end
+
+    def bot_disconnected?
+      user && evnt.user.voice_channel && !evnt.voice && !chat.nil?
+    end
+
+    def bot_connected?
+      user && evnt.user.voice_channel && evnt.voice && !chat.nil?
+    end
+
+    def disconnect_event
+      bot.command :disconnect do |event|
+        @evnt = event
+        @user = User.find_by(discord_id: event.user.id)
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+        event.respond error_messages[:user_not_in_voice_channel] if event.user.voice_channel.nil? && user
+        event.respond error_messages[:user_not_connected] if !event.voice && user
+        disconnect_action if user && event.user.voice_channel && event.voice
+      end
+      logger.log("Disconnect Event Configured")
+    end
+
+    def disconnect_action
+      logger.log("Disconnecting from voice channel: #{evnt.user.voice_channel.name}")
+      bot.voice_destroy(event.user.voice_channel)
+      logger.log("Disconnected from voice channel: #{evnt.user.voice_channel.name}")
+      "Disconnected from voice channel"
+    end
+
+    def speak_event
+      bot.command :speak do |event|
+        @evnt = event
+        @message = event.message.content.split(" ")[1..].join(" ")
+        @user = User.find_by(discord_id: event.user.id)
+        @chat = Chat.where(id: user.current_chat_id).last
+        event.respond error_messages[:user_not_logged_in] if user.nil?
+        event.respond error_messages[:user_not_in_voice_channel] if event.user.voice_channel.nil? && user
+        event.respond error_messages[:bot_not_in_voice_channel] if !event.voice && user
+        event.respond error_messages[:chat_not_found] if user && event.user.voice_channel && event.voice && chat.nil?
+        ask_to_speak_action if user && event.user.voice_channel && event.voice && !chat.nil?
+      end
+    end
+
+    def ask_to_speak_action
+      Message.create(chat_id: chat.id, content: message, role: "user")
+      response = chatter.chat(message, chat.id)
+      audio_path = audio_synthesis.synthesize_text(response)
+      speak_answer_action(audio_path, response)
+    end
+
+    def speak_answer_action(audio_path, response)
+      evnt.respond response
+      evnt.voice.play_file(audio_path)
+      delete_all_voice_files
+      "OK"
+    end
+
+    def bot_init
+      logger.log("Discord bot started")
+      at_exit { bot.stop }
+      bot.run
+    rescue StandardError
+      start
+    end
+  end
+end