ChatGPT attempts new questions from the questions channel

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

@@ -72,9 +72,9 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         ModerationActionsStore actionsStore = new ModerationActionsStore(database);
         ModAuditLogWriter modAuditLogWriter = new ModAuditLogWriter(config);
         ScamHistoryStore scamHistoryStore = new ScamHistoryStore(database);
-        HelpSystemHelper helpSystemHelper = new HelpSystemHelper(config, database);
-        CodeMessageHandler codeMessageHandler = new CodeMessageHandler();
         ChatGptService chatGptService = new ChatGptService(config);
+        HelpSystemHelper helpSystemHelper = new HelpSystemHelper(config, database, chatGptService);
+        CodeMessageHandler codeMessageHandler = new CodeMessageHandler();
 
         // 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

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

@@ -0,0 +1,88 @@
+package org.togetherjava.tjbot.features.chaptgpt;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class AIResponseParser {
+
+    private AIResponseParser() {}
+
+    private static final Logger logger = LoggerFactory.getLogger(AIResponseParser.class);
+    private static final int RESPONSE_LENGTH_LIMIT = 2_000;
+
+    public static Optional<String[]> parse(String response) {
+        String[] aiResponses;
+        if (response.length() > RESPONSE_LENGTH_LIMIT) {
+            logger.warn(
+                    "Response from AI was longer than allowed limit. "
+                            + "The answer was cut up to max {} characters length messages",
+                    RESPONSE_LENGTH_LIMIT);
+            aiResponses = breakupAiResponse(response);
+        } else {
+            aiResponses = new String[] {response};
+        }
+
+        return Optional.of(aiResponses);
+    }
+
+    private static String[] breakupAiResponse(String response) {
+        List<CodeBlockIndexPair> codeMarkIndexPairs = new ArrayList<>();
+
+        int firstCodeBlockMarkIndex;
+        while ((firstCodeBlockMarkIndex = response.indexOf("```")) != -1) {
+            // Assuming that code marks come in pairs...
+            int secondCodeBlockMarkIndex = response.indexOf("```");
+            codeMarkIndexPairs
+                .add(new CodeBlockIndexPair(firstCodeBlockMarkIndex, secondCodeBlockMarkIndex));
+        }
+
+        List<String> brokenUpAiResponse = new ArrayList<>();
+        if (codeMarkIndexPairs.stream()
+            .mapToInt(CodeBlockIndexPair::getLength)
+            .allMatch(i -> i < 2000)) {
+
+            int begin = 0;
+            for (CodeBlockIndexPair codeBlockIndexPair : codeMarkIndexPairs) {
+                int end = codeBlockIndexPair.getBeginIndex();
+                brokenUpAiResponse.add(response.substring(begin, end));
+
+                begin = end;
+                // Add three because index only really captures first `.
+                end = codeBlockIndexPair.getEndIndex() + 3;
+                brokenUpAiResponse.add(response.substring(begin, end));
+
+                begin = end;
+            }
+        } else {
+            //
+        }
+
+        return brokenUpAiResponse.toArray(new String[0]);
+    }
+
+    static class CodeBlockIndexPair {
+        private final int beginIndex;
+        private final int endIndex;
+
+        public CodeBlockIndexPair(int beginIndex, int endIndex) {
+            this.beginIndex = beginIndex;
+            this.endIndex = endIndex;
+        }
+
+        public int getBeginIndex() {
+            return beginIndex;
+        }
+
+        public int getEndIndex() {
+            return endIndex;
+        }
+
+        public int getLength() {
+            return endIndex - beginIndex;
+        }
+    }
+}

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

@@ -22,6 +22,7 @@
  * which it will respond with an AI generated answer.
  */
 public final class ChatGptCommand extends SlashCommandAdapter {
+    public static final String COMMAND_NAME = "chatgpt";
     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;
@@ -37,7 +38,7 @@ public final class ChatGptCommand extends SlashCommandAdapter {
      * @param chatGptService ChatGptService - Needed to make calls to ChatGPT API
      */
     public ChatGptCommand(ChatGptService chatGptService) {
-        super("chatgpt", "Ask the ChatGPT AI a question!", CommandVisibility.GUILD);
+        super(COMMAND_NAME, "Ask the ChatGPT AI a question!", CommandVisibility.GUILD);
 
         this.chatGptService = chatGptService;
     }
@@ -73,14 +74,20 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
     public void onModalSubmitted(ModalInteractionEvent event, List<String> args) {
         event.deferReply().queue();
 
-        Optional<String> optional =
+        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();
+        String[] errorResponse = {"""
+                    An error has occurred while trying to communicate with ChatGPT.
+                    Please try again later.
+                """};
+
+        String[] response = optional.orElse(errorResponse);
+        for (String message : response) {
+            event.getHook().sendMessage(message).queue();
+        }
     }
 }

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

@@ -20,14 +20,14 @@
  */
 public class ChatGptService {
     private static final Logger logger = LoggerFactory.getLogger(ChatGptService.class);
-    private static final Duration TIMEOUT = Duration.ofSeconds(10);
+    private static final Duration TIMEOUT = Duration.ofSeconds(120);
     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) {
@@ -37,17 +37,34 @@ public ChatGptService(Config config) {
         }
 
         openAiService = new OpenAiService(apiKey, TIMEOUT);
+
+        ChatMessage setupMessage = new ChatMessage(ChatMessageRole.SYSTEM.value(),
+                """
+                        Please answer questions in 1500 characters or less. Remember to count spaces in the
+                        character limit. For code supplied for review, refer to the old code supplied rather than
+                        rewriting the code. Don't supply a corrected version of the code.\s""");
+        ChatCompletionRequest systemSetupRequest = ChatCompletionRequest.builder()
+            .model("gpt-3.5-turbo")
+            .messages(List.of(setupMessage))
+            .frequencyPenalty(0.5)
+            .temperature(0.3)
+            .maxTokens(50)
+            .n(1)
+            .build();
+
+        // Sending the system setup message to ChatGPT.
+        openAiService.createChatCompletion(systemSetupRequest);
     }
 
     /**
      * Prompt ChatGPT with a question and receive a response.
-     * 
+     *
      * @param question The question being asked of ChatGPT. Max is {@value MAX_TOKENS} tokens.
+     * @return response from ChatGPT as a String.
      * @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) {
+    public Optional<String[]> ask(String question) {
         if (isDisabled) {
             return Optional.empty();
         }
@@ -59,15 +76,18 @@ public Optional<String> ask(String question) {
                 .model("gpt-3.5-turbo")
                 .messages(List.of(chatMessage))
                 .frequencyPenalty(0.5)
-                .temperature(0.7)
+                .temperature(0.3)
                 .maxTokens(MAX_TOKENS)
                 .n(1)
                 .build();
-            return Optional.ofNullable(openAiService.createChatCompletion(chatCompletionRequest)
+
+            String response = openAiService.createChatCompletion(chatCompletionRequest)
                 .getChoices()
                 .get(0)
                 .getMessage()
-                .getContent());
+                .getContent();
+
+            return AIResponseParser.parse(response);
         } catch (OpenAiHttpException openAiHttpException) {
             logger.warn(
                     "There was an error using the OpenAI API: {} Code: {} Type: {} Status Code: {}",

application/src/main/java/org/togetherjava/tjbot/features/help/HelpSystemHelper.java

@@ -24,20 +24,33 @@
 import org.togetherjava.tjbot.db.Database;
 import org.togetherjava.tjbot.db.generated.tables.HelpThreads;
 import org.togetherjava.tjbot.db.generated.tables.records.HelpThreadsRecord;
+import org.togetherjava.tjbot.features.chaptgpt.ChatGptCommand;
+import org.togetherjava.tjbot.features.chaptgpt.ChatGptService;
 import org.togetherjava.tjbot.features.utils.MessageUtils;
 
 import javax.annotation.Nullable;
 
-import java.awt.Color;
+import java.awt.*;
 import java.io.InputStream;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+import static org.togetherjava.tjbot.features.utils.MessageUtils.mentionGuildSlashCommand;
+
 /**
  * Helper class offering certain methods used by the help system.
  */
@@ -59,15 +72,22 @@ public final class HelpSystemHelper {
     private final Set<String> threadActivityTagNames;
     private final String categoryRoleSuffix;
     private final Database database;
+    private final ChatGptService chatGptService;
+    private static final int MAX_QUESTION_LENGTH = 200;
+    private static final int MIN_QUESTION_LENGTH = 10;
+    private static final String CHATGPT_FAILURE_MESSAGE =
+            "You can use %s to ask ChatGPT about your question while you wait for a human to respond.";
 
     /**
      * Creates a new instance.
      *
      * @param config the config to use
      * @param database the database to store help thread metadata in
+     * @param chatGptService the access point to the ChatGPT API
      */
-    public HelpSystemHelper(Config config, Database database) {
+    public HelpSystemHelper(Config config, Database database, ChatGptService chatGptService) {
         HelpSystemConfig helpConfig = config.getHelpSystem();
+        this.chatGptService = chatGptService;
         this.database = database;
 
         helpForumPattern = helpConfig.getHelpForumPattern();
@@ -131,6 +151,90 @@ private RestAction<Message> sendExplanationMessage(GuildMessageChannel threadCha
         return action.setEmbeds(embeds);
     }
 
+    /**
+     * Determine between the title of the thread and the first message which to send to the AI. It
+     * uses a simple heuristic of length to determine if enough context exists in a question. If the
+     * title is used, it must also include a question mark since the title is often used more as an
+     * indicator of topic versus a question.
+     * 
+     * @param originalQuestion The first message of the thread which originates from the question
+     *        asker.
+     * @param threadChannel The thread in which the question was asked.
+     * @return An answer for the user from the AI service or a message indicating either an error or
+     *         why the message wasn't used.
+     */
+    RestAction<Message> constructChatGptAttempt(ThreadChannel threadChannel,
+            String originalQuestion) {
+        Optional<String> questionOptional = prepareChatGptQuestion(threadChannel, originalQuestion);
+        Optional<String[]> chatGPTAnswer;
+
+        String question = questionOptional.orElseThrow();
+        logger.debug("The final question sent to chatGPT: {}", question);
+        chatGPTAnswer = chatGptService.ask(question);
+
+        if (chatGPTAnswer.isEmpty()) {
+            logger.warn("Something went wrong while trying to communicate with the ChatGpt API");
+            return useChatGptFallbackMessage(threadChannel);
+        }
+
+        UnaryOperator<String> preambleResponse = """
+                Here is an AI assisted attempt to answer your question 🤖. Maybe it helps! \
+                In any case, a human is on the way 👍. To continue talking to the AI, you can use \
+                %s.
+                """::formatted;
+
+        RestAction<Message> message =
+                mentionGuildSlashCommand(threadChannel.getGuild(), ChatGptCommand.COMMAND_NAME)
+                    .map(preambleResponse)
+                    .flatMap(threadChannel::sendMessage);
+
+        for (String aiResponse : chatGPTAnswer.get()) {
+            message = message.map(aiResponse::formatted).flatMap(threadChannel::sendMessage);
+        }
+
+        return message;
+    }
+
+    private Optional<String> prepareChatGptQuestion(ThreadChannel threadChannel,
+            String originalQuestion) {
+        String questionTitle = threadChannel.getName();
+        StringBuilder questionBuilder = new StringBuilder(MAX_QUESTION_LENGTH);
+
+        if (originalQuestion.length() < MIN_QUESTION_LENGTH
+                && questionTitle.length() < MIN_QUESTION_LENGTH) {
+            return Optional.empty();
+        }
+
+        questionBuilder.append(questionTitle).append(" ");
+        if (originalQuestion.length() > MAX_QUESTION_LENGTH - questionBuilder.length()) {
+            originalQuestion =
+                    originalQuestion.substring(0, MAX_QUESTION_LENGTH - questionBuilder.length());
+        }
+
+        questionBuilder.append(originalQuestion);
+
+        StringBuilder tagBuilder = new StringBuilder();
+        int stringLength = questionBuilder.length();
+        for (ForumTag tag : threadChannel.getAppliedTags()) {
+            String tagName = tag.getName();
+            stringLength += tagName.length();
+            if (stringLength > MAX_QUESTION_LENGTH) {
+                break;
+            }
+            tagBuilder.append(String.format("%s ", tagName));
+        }
+
+        questionBuilder.insert(0, tagBuilder);
+
+        return Optional.of(questionBuilder.toString());
+    }
+
+    private RestAction<Message> useChatGptFallbackMessage(ThreadChannel threadChannel) {
+        return mentionGuildSlashCommand(threadChannel.getGuild(), ChatGptCommand.COMMAND_NAME)
+            .map(CHATGPT_FAILURE_MESSAGE::formatted)
+            .flatMap(threadChannel::sendMessage);
+    }
+
     void writeHelpThreadToDatabase(long authorId, ThreadChannel threadChannel) {
         database.write(content -> {
             HelpThreadsRecord helpThreadsRecord = content.newRecord(HelpThreads.HELP_THREADS)

application/src/main/java/org/togetherjava/tjbot/features/help/HelpThreadCreatedListener.java

@@ -77,6 +77,7 @@ private void handleHelpThreadCreated(ThreadChannel threadChannel) {
         Runnable createMessages = () -> {
             try {
                 createMessages(threadChannel).queue();
+                createAIResponse(threadChannel).queue();
             } catch (Exception e) {
                 logger.error(
                         "Unknown error while creating messages after help-thread ({}) creation",
@@ -90,9 +91,17 @@ private void handleHelpThreadCreated(ThreadChannel threadChannel) {
         SERVICE.schedule(createMessages, 5, TimeUnit.SECONDS);
     }
 
+    private RestAction<Message> createAIResponse(ThreadChannel threadChannel) {
+        RestAction<Message> originalQuestion =
+                threadChannel.retrieveMessageById(threadChannel.getIdLong());
+        return originalQuestion.flatMap(
+                message -> helper.constructChatGptAttempt(threadChannel, message.getContentRaw()));
+    }
+
     private RestAction<Message> createMessages(ThreadChannel threadChannel) {
         return sendHelperHeadsUp(threadChannel).flatMap(Message::pin)
-            .flatMap(any -> helper.sendExplanationMessage(threadChannel));
+            .flatMap(any -> helper.sendExplanationMessage(threadChannel))
+            .flatMap(any -> threadChannel.retrieveMessageById(threadChannel.getIdLong()));
     }
 
     private RestAction<Message> sendHelperHeadsUp(ThreadChannel threadChannel) {