Release v.4.5

.gitignore

@@ -162,6 +162,7 @@ logviewer/webpack.generated.js
 .DS_Store
 
 # VisualStudioCode
+.vscode
 .vscode/*
 !.vscode/settings.json
 !.vscode/extensions.json

application/build.gradle

@@ -27,7 +27,7 @@ jib {
         }
     }
     container {
-        mainClass = 'org.togetherjava.tjbot.BootstrapLauncher'
+        mainClass = 'org.togetherjava.tjbot.Application'
         setCreationTime(java.time.Instant.now().toString())
     }
 }
@@ -57,7 +57,7 @@ dependencies {
 
     implementation 'io.mikael:urlbuilder:2.0.9'
 
-    implementation 'org.jsoup:jsoup:1.15.3'
+    implementation 'org.jsoup:jsoup:1.16.1'
 
     implementation 'org.scilab.forge:jlatexmath:1.0.7'
     implementation 'org.scilab.forge:jlatexmath-font-greek:1.0.7'
@@ -73,13 +73,18 @@ dependencies {
     implementation 'io.github.url-detector:url-detector:0.1.23'
 
     implementation 'com.github.ben-manes.caffeine:caffeine:3.1.1'
+
+    implementation 'org.kohsuke:github-api:1.314'
 
-    testImplementation 'org.mockito:mockito-core:5.1.0'
+    testImplementation 'org.mockito:mockito-core:5.3.1'
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
     testImplementation 'org.junit.jupiter:junit-jupiter-params:5.9.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
+
+    implementation "com.theokanning.openai-gpt3-java:api:$chatGPTVersion"
+    implementation "com.theokanning.openai-gpt3-java:service:$chatGPTVersion"
 }
 
 application {
-    mainClass = 'org.togetherjava.tjbot.BootstrapLauncher'
+    mainClass = 'org.togetherjava.tjbot.Application'
 }

application/config.json.template

@@ -88,4 +88,5 @@
     ],
     "logInfoChannelWebhook": "<put_your_webhook_here>",
     "logErrorChannelWebhook": "<put_your_webhook_here>"
+    "openaiApiKey": "<check pins in #tjbot_discussion for the key>"
 }

application/src/main/java/org/togetherjava/tjbot/config/Config.java

@@ -36,6 +36,7 @@ public final class Config {
     private final String mediaOnlyChannelPattern;
     private final String logInfoChannelWebhook;
     private final String logErrorChannelWebhook;
+    private final String openaiApiKey;
 
     @SuppressWarnings("ConstructorWithTooManyParameters")
     @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
@@ -70,7 +71,8 @@ private Config(@JsonProperty(value = "token", required = true) String token,
             @JsonProperty(value = "logInfoChannelWebhook",
                     required = true) String logInfoChannelWebhook,
             @JsonProperty(value = "logErrorChannelWebhook",
-                    required = true) String logErrorChannelWebhook) {
+                    required = true) String logErrorChannelWebhook,
+            @JsonProperty(value = "openaiApiKey", required = true) String openaiApiKey) {
         this.token = Objects.requireNonNull(token);
         this.gistApiKey = Objects.requireNonNull(gistApiKey);
         this.databasePath = Objects.requireNonNull(databasePath);
@@ -93,6 +95,7 @@ private Config(@JsonProperty(value = "token", required = true) String token,
         this.blacklistedFileExtension = Objects.requireNonNull(blacklistedFileExtension);
         this.logInfoChannelWebhook = Objects.requireNonNull(logInfoChannelWebhook);
         this.logErrorChannelWebhook = Objects.requireNonNull(logErrorChannelWebhook);
+        this.openaiApiKey = Objects.requireNonNull(openaiApiKey);
     }
 
     /**
@@ -304,4 +307,13 @@ public String getLogInfoChannelWebhook() {
     public String getLogErrorChannelWebhook() {
         return logErrorChannelWebhook;
     }
+
+    /**
+     * The OpenAI token needed for communicating with OpenAI ChatGPT.
+     *
+     * @return the OpenAI API Token
+     */
+    public String getOpenaiApiKey() {
+        return openaiApiKey;
+    }
 }

application/src/main/java/org/togetherjava/tjbot/features/Features.java

@@ -6,6 +6,8 @@
 import org.togetherjava.tjbot.db.Database;
 import org.togetherjava.tjbot.features.basic.*;
 import org.togetherjava.tjbot.features.bookmarks.*;
+import org.togetherjava.tjbot.features.chaptgpt.ChatGptCommand;
+import org.togetherjava.tjbot.features.chaptgpt.ChatGptService;
 import org.togetherjava.tjbot.features.code.CodeMessageAutoDetection;
 import org.togetherjava.tjbot.features.code.CodeMessageHandler;
 import org.togetherjava.tjbot.features.code.CodeMessageManualDetection;
@@ -72,6 +74,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         ScamHistoryStore scamHistoryStore = new ScamHistoryStore(database);
         HelpSystemHelper helpSystemHelper = new HelpSystemHelper(config, database);
         CodeMessageHandler codeMessageHandler = new CodeMessageHandler();
+        ChatGptService chatGptService = new ChatGptService(config);
 
         // NOTE The system can add special system relevant commands also by itself,
         // hence this list may not necessarily represent the full list of all commands actually
@@ -139,7 +142,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new HelpThreadCommand(config, helpSystemHelper));
         features.add(new ReportCommand(config));
         features.add(new BookmarksCommand(bookmarksSystem));
-
+        features.add(new ChatGptCommand(chatGptService));
         return features;
     }
 }

application/src/main/java/org/togetherjava/tjbot/features/basic/SlashCommandEducator.java

@@ -24,7 +24,7 @@ public final class SlashCommandEducator extends MessageReceiverAdapter {
     private static final Predicate<String> IS_MESSAGE_COMMAND = Pattern.compile("""
             [.!?] #Start of message command
             [a-zA-Z]{2,15} #Name of message command, e.g. 'close'
-            .* #Rest of the message
+            .*[^);] #Rest of the message (don't end with code stuff)
             """, Pattern.COMMENTS).asMatchPredicate();
 
     @Override
@@ -48,24 +48,25 @@ private void sendAdvice(Message message) {
                         Try starting your message with a forward-slash `/` and Discord should open a popup showing you all available commands.
                         A command might then look like `/foo` 👍""";
 
-        createReply(message, content, SLASH_COMMAND_POPUP_ADVICE_PATH).queue();
+        createReply(message, content).queue();
     }
 
-    private static MessageCreateAction createReply(Message messageToReplyTo, String content,
-            String imagePath) {
+    private static MessageCreateAction createReply(Message messageToReplyTo, String content) {
         boolean useImage = true;
-        InputStream imageData = HelpSystemHelper.class.getResourceAsStream("/" + imagePath);
+        InputStream imageData =
+                HelpSystemHelper.class.getResourceAsStream("/" + SLASH_COMMAND_POPUP_ADVICE_PATH);
         if (imageData == null) {
             useImage = false;
         }
 
         MessageEmbed embed = new EmbedBuilder().setDescription(content)
-            .setImage(useImage ? "attachment://" + imagePath : null)
+            .setImage(useImage ? "attachment://" + SLASH_COMMAND_POPUP_ADVICE_PATH : null)
             .build();
 
         MessageCreateAction action = messageToReplyTo.replyEmbeds(embed);
         if (useImage) {
-            action = action.addFiles(FileUpload.fromData(imageData, imagePath));
+            action = action
+                .addFiles(FileUpload.fromData(imageData, SLASH_COMMAND_POPUP_ADVICE_PATH));
         }
 
         return action;

application/src/main/java/org/togetherjava/tjbot/features/chaptgpt/ChatGptCommand.java

@@ -0,0 +1,86 @@
+package org.togetherjava.tjbot.features.chaptgpt;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import net.dv8tion.jda.api.events.interaction.ModalInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.components.Modal;
+import net.dv8tion.jda.api.interactions.components.text.TextInput;
+import net.dv8tion.jda.api.interactions.components.text.TextInputStyle;
+
+import org.togetherjava.tjbot.features.CommandVisibility;
+import org.togetherjava.tjbot.features.SlashCommandAdapter;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * The implemented command is {@code /chatgpt}, which allows users to ask ChatGPT a question, upon
+ * which it will respond with an AI generated answer.
+ */
+public final class ChatGptCommand extends SlashCommandAdapter {
+    private static final String QUESTION_INPUT = "question";
+    private static final int MAX_MESSAGE_INPUT_LENGTH = 200;
+    private static final int MIN_MESSAGE_INPUT_LENGTH = 4;
+    private static final Duration COMMAND_COOLDOWN = Duration.of(10, ChronoUnit.SECONDS);
+    private final ChatGptService chatGptService;
+
+    private final Cache<String, Instant> userIdToAskedAtCache =
+            Caffeine.newBuilder().maximumSize(1_000).expireAfterWrite(COMMAND_COOLDOWN).build();
+
+    /**
+     * Creates an instance of the chatgpt command.
+     *
+     * @param chatGptService ChatGptService - Needed to make calls to ChatGPT API
+     */
+    public ChatGptCommand(ChatGptService chatGptService) {
+        super("chatgpt", "Ask the ChatGPT AI a question!", CommandVisibility.GUILD);
+
+        this.chatGptService = chatGptService;
+    }
+
+    @Override
+    public void onSlashCommand(SlashCommandInteractionEvent event) {
+        Instant previousAskTime = userIdToAskedAtCache.getIfPresent(event.getMember().getId());
+        if (previousAskTime != null) {
+            long timeRemainingUntilNextAsk =
+                    COMMAND_COOLDOWN.minus(Duration.between(previousAskTime, Instant.now()))
+                        .toSeconds();
+
+            event
+                .reply("Sorry, you need to wait another " + timeRemainingUntilNextAsk
+                        + " second(s) before asking chatGPT another question.")
+                .setEphemeral(true)
+                .queue();
+            return;
+        }
+
+        TextInput body = TextInput
+            .create(QUESTION_INPUT, "Ask ChatGPT a question or get help with code",
+                    TextInputStyle.PARAGRAPH)
+            .setPlaceholder("Put your question for ChatGPT here")
+            .setRequiredRange(MIN_MESSAGE_INPUT_LENGTH, MAX_MESSAGE_INPUT_LENGTH)
+            .build();
+
+        Modal modal = Modal.create(generateComponentId(), "ChatGPT").addActionRow(body).build();
+        event.replyModal(modal).queue();
+    }
+
+    @Override
+    public void onModalSubmitted(ModalInteractionEvent event, List<String> args) {
+        event.deferReply().queue();
+
+        Optional<String> optional =
+                chatGptService.ask(event.getValue(QUESTION_INPUT).getAsString());
+        if (optional.isPresent()) {
+            userIdToAskedAtCache.put(event.getMember().getId(), Instant.now());
+        }
+
+        String response = optional.orElse(
+                "An error has occurred while trying to communicate with ChatGPT. Please try again later");
+        event.getHook().sendMessage(response).queue();
+    }
+}

application/src/main/java/org/togetherjava/tjbot/features/chaptgpt/ChatGptService.java

@@ -0,0 +1,82 @@
+package org.togetherjava.tjbot.features.chaptgpt;
+
+import com.theokanning.openai.OpenAiHttpException;
+import com.theokanning.openai.completion.chat.ChatCompletionRequest;
+import com.theokanning.openai.completion.chat.ChatMessage;
+import com.theokanning.openai.completion.chat.ChatMessageRole;
+import com.theokanning.openai.service.OpenAiService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.togetherjava.tjbot.config.Config;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Service used to communicate to OpenAI API to generate responses.
+ */
+public class ChatGptService {
+    private static final Logger logger = LoggerFactory.getLogger(ChatGptService.class);
+    private static final Duration TIMEOUT = Duration.ofSeconds(10);
+    private static final int MAX_TOKENS = 3_000;
+    private boolean isDisabled = false;
+    private final OpenAiService openAiService;
+
+    /**
+     * Creates instance of ChatGPTService
+     * 
+     * @param config needed for token to OpenAI API.
+     */
+    public ChatGptService(Config config) {
+        String apiKey = config.getOpenaiApiKey();
+        if (apiKey.isBlank()) {
+            isDisabled = true;
+        }
+
+        openAiService = new OpenAiService(apiKey, TIMEOUT);
+    }
+
+    /**
+     * Prompt ChatGPT with a question and receive a response.
+     * 
+     * @param question The question being asked of ChatGPT. Max is {@value MAX_TOKENS} tokens.
+     * @see <a href="https://platform.openai.com/docs/guides/chat/managing-tokens">ChatGPT
+     *      Tokens</a>.
+     * @return response from ChatGPT as a String.
+     */
+    public Optional<String> ask(String question) {
+        if (isDisabled) {
+            return Optional.empty();
+        }
+
+        try {
+            ChatMessage chatMessage =
+                    new ChatMessage(ChatMessageRole.USER.value(), Objects.requireNonNull(question));
+            ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder()
+                .model("gpt-3.5-turbo")
+                .messages(List.of(chatMessage))
+                .frequencyPenalty(0.5)
+                .temperature(0.7)
+                .maxTokens(MAX_TOKENS)
+                .n(1)
+                .build();
+            return Optional.ofNullable(openAiService.createChatCompletion(chatCompletionRequest)
+                .getChoices()
+                .get(0)
+                .getMessage()
+                .getContent());
+        } catch (OpenAiHttpException openAiHttpException) {
+            logger.warn(
+                    "There was an error using the OpenAI API: {} Code: {} Type: {} Status Code: {}",
+                    openAiHttpException.getMessage(), openAiHttpException.code,
+                    openAiHttpException.type, openAiHttpException.statusCode);
+        } catch (RuntimeException runtimeException) {
+            logger.warn("There was an error using the OpenAI API: {}",
+                    runtimeException.getMessage());
+        }
+        return Optional.empty();
+    }
+}

application/src/main/java/org/togetherjava/tjbot/features/chaptgpt/package-info.java

@@ -0,0 +1,10 @@
+/**
+ * This package contains the functionality to connect with ChatGPT via API calls.
+ */
+@MethodsReturnNonnullByDefault
+@ParametersAreNonnullByDefault
+package org.togetherjava.tjbot.features.chaptgpt;
+
+import org.togetherjava.tjbot.annotations.MethodsReturnNonnullByDefault;
+
+import javax.annotation.ParametersAreNonnullByDefault;