feature "rewrite-msg command": applies changes due to Wazei's first review - Part 2;

Author: firasrg

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

@@ -39,9 +39,11 @@ public ChatGptService(Config config) {
         boolean keyIsDefaultDescription = apiKey.startsWith("<") && apiKey.endsWith(">");
         if (apiKey.isBlank() || keyIsDefaultDescription) {
             isDisabled = true;
+            logger.warn("ChatGPT service is disabled: API key is not configured");
             return;
         }
         openAIClient = OpenAIOkHttpClient.builder().apiKey(apiKey).timeout(TIMEOUT).build();
+        logger.info("ChatGPT service initialized successfully");
     }
 
     /**
@@ -56,10 +58,6 @@ public ChatGptService(Config config) {
      *      Tokens</a>.
      */
     public Optional<String> ask(String question, @Nullable String context, ChatGptModel chatModel) {
-        if (isDisabled) {
-            return Optional.empty();
-        }
-
         String contextText = context == null ? "" : ", Context: %s.".formatted(context);
         String inputPrompt = """
                 For code supplied for review, refer to the old code supplied rather than
@@ -71,35 +69,71 @@ public Optional<String> ask(String question, @Nullable String context, ChatGptMo
                 Question: %s
                 """.formatted(contextText, question);
 
-        logger.debug("ChatGpt request: {}", inputPrompt);
+        return sendPrompt(inputPrompt, chatModel);
+    }
+
+    /**
+     * Prompt ChatGPT with a raw prompt and receive a response without any prefix wrapping.
+     * <p>
+     * Use this method when you need full control over the prompt structure without the service's
+     * opinionated formatting (e.g., for iterative refinement or specialized use cases).
+     *
+     * @param inputPrompt The raw prompt to send to ChatGPT. Max is {@value MAX_TOKENS} tokens.
+     * @param chatModel The AI model to use for this request.
+     * @return response from ChatGPT as a String.
+     * @see <a href="https://platform.openai.com/docs/guides/chat/managing-tokens">ChatGPT
+     *      Tokens</a>.
+     */
+    public Optional<String> askRaw(String inputPrompt, ChatGptModel chatModel) {
+        return sendPrompt(inputPrompt, chatModel);
+    }
+
+    /**
+     * Sends a prompt to the ChatGPT API and returns the response.
+     *
+     * @param prompt The prompt to send to ChatGPT.
+     * @param chatModel The AI model to use for this request.
+     * @return response from ChatGPT as a String.
+     */
+    private Optional<String> sendPrompt(String prompt, ChatGptModel chatModel) {
+        if (isDisabled) {
+            logger.warn("ChatGPT request attempted but service is disabled");
+            return Optional.empty();
+        }
+
+        logger.debug("ChatGpt request: {}", prompt);
 
-        String response = null;
         try {
             ResponseCreateParams params = ResponseCreateParams.builder()
                 .model(chatModel.toChatModel())
-                .input(inputPrompt)
+                .input(prompt)
                 .maxOutputTokens(MAX_TOKENS)
                 .build();
 
             Response chatGptResponse = openAIClient.responses().create(params);
 
-            response = chatGptResponse.output()
+            String response = chatGptResponse.output()
                 .stream()
                 .flatMap(item -> item.message().stream())
                 .flatMap(message -> message.content().stream())
                 .flatMap(content -> content.outputText().stream())
                 .map(ResponseOutputText::text)
                 .collect(Collectors.joining("\n"));
-        } catch (RuntimeException runtimeException) {
-            logger.warn("There was an error using the OpenAI API: {}",
-                    runtimeException.getMessage());
-        }
 
-        logger.debug("ChatGpt Response: {}", response);
-        if (response == null) {
+            logger.debug("ChatGpt Response: {}", response);
+
+            if (response.isBlank()) {
+                logger.warn("ChatGPT returned an empty response");
+                return Optional.empty();
+            }
+
+            logger.debug("ChatGpt response received successfully, length: {} characters",
+                    response.length());
+            return Optional.of(response);
+        } catch (RuntimeException runtimeException) {
+            logger.error("Error communicating with OpenAI API: {}", runtimeException.getMessage(),
+                    runtimeException);
             return Optional.empty();
         }
-
-        return Optional.of(response);
     }
 }

application/src/main/java/org/togetherjava/tjbot/features/messages/RewriteCommand.java

@@ -15,12 +15,11 @@
 import org.togetherjava.tjbot.features.chatgpt.ChatGptService;
 
 import java.util.Arrays;
-import java.util.Objects;
 import java.util.Optional;
 
 /**
- * The implemented command is {@code /rewrite-msg}, which allows users to have their message
- * rewritten in a clearer, more professional, or better structured form using AI.
+ * The implemented command is {@code /rewrite}, which allows users to have their message rewritten
+ * in a clearer, more professional, or better structured form using AI.
  * <p>
  * The rewritten message is shown as an ephemeral message visible only to the user who triggered the
  * command.
@@ -35,39 +34,33 @@ public final class RewriteCommand extends SlashCommandAdapter {
 
     private static final int MAX_MESSAGE_LENGTH = Message.MAX_CONTENT_LENGTH;
     private static final int MIN_MESSAGE_LENGTH = 3;
-    private static final ChatGptModel CHAT_GPT_MODEL = ChatGptModel.FASTEST;
 
     private final ChatGptService chatGptService;
 
-    private static String createAiPrompt(String userMessage, MessageTone tone) {
-        return """
-                Rewrite the following message to make it clearer, more professional, \
-                and better structured. Maintain the original meaning while improving the quality \
-                of the writing. Do NOT use em-dashes (—). %s
-
-                IMPORTANT: The rewritten text MUST be no more than 2000 characters. \
-                If needed, compress wording while preserving key details and intent.
-
-                If the message is already well-written, provide minor improvements.
-
-                Original message:
-                %s""".stripIndent().formatted(tone.description, userMessage);
+    private static ChatGptModel selectAiModel(MessageTone tone) {
+        return switch (tone) {
+            case CLEAR, PROFESSIONAL -> ChatGptModel.FASTEST;
+            case DETAILED, TECHNICAL -> ChatGptModel.HIGH_QUALITY;
+        };
     }
 
-    private static String buildOriginalMsgResponse(String userMessage, MessageTone tone) {
+    private static String createAiPrompt(String userMessage, MessageTone tone) {
         return """
-                **Original message (%s)**
+                You are rewriting a Discord text chat message for clarity and professionalism.
+                Keep it conversational and casual—NOT email or formal document format.
 
-                %s
-                """.stripIndent().formatted(tone.displayName, userMessage);
-    }
+                Tone: %s
 
-    private static String buildRewrittenMsgResponse(String aiMessage, MessageTone tone) {
-        return """
-                **Rewritten message (%s)**
+                Rewrite the message to:
+                - Improve clarity and structure
+                - Maintain the original meaning
+                - Avoid em-dashes (—)
+                - Stay under %d characters (strict limit)
+
+                If the message is already well-written, make only minor improvements.
 
-                %s
-                """.stripIndent().formatted(tone.displayName, aiMessage);
+                Message to rewrite:
+                %s""".stripIndent().formatted(tone.description, MAX_MESSAGE_LENGTH, userMessage);
     }
 
     /**
@@ -100,8 +93,13 @@ public RewriteCommand(ChatGptService chatGptService) {
     @Override
     public void onSlashCommand(SlashCommandInteractionEvent event) {
 
-        final String userMessage =
-                Objects.requireNonNull(event.getOption(MESSAGE_OPTION)).getAsString();
+        final OptionMapping messageOption = event.getOption(MESSAGE_OPTION);
+
+        if (messageOption == null) {
+            throw new IllegalStateException("Required option '" + MESSAGE_OPTION + "' is missing");
+        }
+
+        final String userMessage = messageOption.getAsString();
         final MessageTone tone = parseTone(event.getOption(TONE_OPTION));
 
         event.deferReply(true).queue();
@@ -124,15 +122,7 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
 
         logger.debug("Rewrite successful; rewritten message length: {}", rewrittenText.length());
 
-        event.getHook()
-            .sendMessage(buildOriginalMsgResponse(userMessage, tone))
-            .setEphemeral(true)
-            .queue();
-
-        event.getHook()
-            .sendMessage(buildRewrittenMsgResponse(rewrittenText, tone))
-            .setEphemeral(true)
-            .queue();
+        event.getHook().sendMessage(rewrittenText).setEphemeral(true).queue();
     }
 
     private MessageTone parseTone(@Nullable OptionMapping toneOption)
@@ -150,10 +140,11 @@ private MessageTone parseTone(@Nullable OptionMapping toneOption)
 
     private Optional<String> rewrite(String userMessage, MessageTone tone) {
 
+        final ChatGptModel aiModel = selectAiModel(tone);
+
         final String rewritePrompt = createAiPrompt(userMessage, tone);
 
-        Optional<String> attempt =
-                chatGptService.ask(rewritePrompt, tone.displayName, CHAT_GPT_MODEL);
+        Optional<String> attempt = chatGptService.askRaw(rewritePrompt, aiModel);
 
         if (attempt.isEmpty()) {
             return attempt;
@@ -166,20 +157,19 @@ private Optional<String> rewrite(String userMessage, MessageTone tone) {
         }
 
         logger.debug("Rewritten message exceeded {} characters; retrying with stricter constraint",
-                Message.MAX_CONTENT_LENGTH);
+                MAX_MESSAGE_LENGTH);
 
         final String shortenPrompt = rewritePrompt
-                + "\n\nConstraint reminder: Your previous rewrite exceeded "
-                + Message.MAX_CONTENT_LENGTH
-                + " characters. Provide a revised rewrite strictly under "
-                + Message.MAX_CONTENT_LENGTH + " characters while preserving meaning and tone.";
+                + "\n\nConstraint reminder: Your previous rewrite exceeded " + MAX_MESSAGE_LENGTH
+                + " characters. Provide a revised rewrite strictly under " + MAX_MESSAGE_LENGTH
+                + " characters while preserving meaning and tone.";
 
-        return chatGptService.ask(shortenPrompt, tone.displayName, CHAT_GPT_MODEL);
+        return chatGptService.askRaw(shortenPrompt, aiModel);
     }
 
     private enum MessageTone {
         CLEAR("Clear", "Make it clear and easy to understand."),
-        PRO("Pro", "Use a professional and polished tone."),
+        PROFESSIONAL("Professional", "Use a professional and polished tone."),
         DETAILED("Detailed", "Expand with more detail and explanation."),
         TECHNICAL("Technical", "Use technical and specialized language where appropriate.");