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

Author: firasrg

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

@@ -41,7 +41,7 @@
 import org.togetherjava.tjbot.features.mathcommands.wolframalpha.WolframAlphaCommand;
 import org.togetherjava.tjbot.features.mediaonly.MediaOnlyChannelListener;
 import org.togetherjava.tjbot.features.messages.MessageCommand;
-import org.togetherjava.tjbot.features.messages.RewriteMsgCommand;
+import org.togetherjava.tjbot.features.messages.RewriteCommand;
 import org.togetherjava.tjbot.features.moderation.BanCommand;
 import org.togetherjava.tjbot.features.moderation.KickCommand;
 import org.togetherjava.tjbot.features.moderation.ModerationActionsStore;
@@ -208,7 +208,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new ChatGptCommand(chatGptService, helpSystemHelper));
         features.add(new JShellCommand(jshellEval));
         features.add(new MessageCommand());
-        features.add(new RewriteMsgCommand(chatGptService));
+        features.add(new RewriteCommand(chatGptService));
 
         FeatureBlacklist<Class<?>> blacklist = blacklistConfig.normal();
         return blacklist.filterStream(features.stream(), Object::getClass).toList();

…features/messages/RewriteMsgCommand.java …ot/features/messages/RewriteCommand.javaapplication/src/main/java/org/togetherjava/tjbot/features/messages/RewriteMsgCommand.java renamed to application/src/main/java/org/togetherjava/tjbot/features/messages/RewriteCommand.java application/src/main/java/org/togetherjava/tjbot/features/messages/RewriteMsgCommand.java renamed to application/src/main/java/org/togetherjava/tjbot/features/messages/RewriteCommand.java

@@ -1,5 +1,6 @@
 package org.togetherjava.tjbot.features.messages;
 
+import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.commands.OptionMapping;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
@@ -19,55 +20,62 @@
 
 /**
  * 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 ChatGPT AI.
+ * 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, making it perfect for getting quick writing improvements without cluttering the channel.
+ * command.
  * <p>
- * Users can optionally specify a tone/style for the rewrite. If not provided, defaults to CLEAR.
+ * Users can optionally specify a tone/style for the rewrite.
  */
-public final class RewriteMsgCommand extends SlashCommandAdapter {
-    private static final Logger logger = LoggerFactory.getLogger(RewriteMsgCommand.class);
-    public static final String COMMAND_NAME = "rewrite-msg";
+public final class RewriteCommand extends SlashCommandAdapter {
+    private static final Logger logger = LoggerFactory.getLogger(RewriteCommand.class);
+    private static final String COMMAND_NAME = "rewrite";
     private static final String MESSAGE_OPTION = "message";
     private static final String TONE_OPTION = "tone";
-    private static final int MAX_MESSAGE_LENGTH = 500;
+
+    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.HIGH_QUALITY;
+    private static final ChatGptModel CHAT_GPT_MODEL = ChatGptModel.FASTEST;
 
     private final ChatGptService chatGptService;
 
-    private static String buildResponse(String userMessage, String rewrittenMessage, MsgTone tone) {
-        final String toneLabel = tone.displayName;
-
+    private static String createAiPrompt(String userMessage, MessageTone tone) {
         return """
-                **Rewritten message (%s)**
+                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
 
-                **Original:**
-                %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.
 
-                **Rewritten:**
-                %s""".formatted(toneLabel, userMessage, rewrittenMessage);
+                Original message:
+                %s""".stripIndent().formatted(tone.description, userMessage);
     }
 
-    private static String buildChatGptPrompt(String userMessage, MsgTone tone) {
+    private static String buildOriginalMsgResponse(String userMessage, MessageTone tone) {
         return """
-                Please 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
+                **Original message (%s)**
 
-                If the message is already well-written, provide minor improvements.
+                %s
+                """.stripIndent().formatted(tone.displayName, userMessage);
+    }
 
-                Original message:
-                %s""".formatted(tone.description, userMessage);
+    private static String buildRewrittenMsgResponse(String aiMessage, MessageTone tone) {
+        return """
+                **Rewritten message (%s)**
+
+                %s
+                """.stripIndent().formatted(tone.displayName, aiMessage);
     }
 
     /**
      * Creates the slash command definition and configures available options for rewriting messages.
      *
      * @param chatGptService service for interacting with ChatGPT
      */
-    public RewriteMsgCommand(ChatGptService chatGptService) {
+    public RewriteCommand(ChatGptService chatGptService) {
         super(COMMAND_NAME, "Let AI rephrase and improve your message", CommandVisibility.GUILD);
 
         this.chatGptService = chatGptService;
@@ -79,64 +87,97 @@ public RewriteMsgCommand(ChatGptService chatGptService) {
                     .setMaxLength(MAX_MESSAGE_LENGTH);
 
         final OptionData toneOption = new OptionData(OptionType.STRING, TONE_OPTION,
-                "The tone/style for the rewritten message (default: " + MsgTone.CLEAR.displayName
-                        + ")",
+                "The tone/style for the rewritten message (default: "
+                        + MessageTone.CLEAR.displayName + ")",
                 false);
 
-        Arrays.stream(MsgTone.values())
+        Arrays.stream(MessageTone.values())
             .forEach(tone -> toneOption.addChoice(tone.displayName, tone.name()));
 
         getData().addOptions(messageOption, toneOption);
     }
 
     @Override
     public void onSlashCommand(SlashCommandInteractionEvent event) {
+
         final String userMessage =
                 Objects.requireNonNull(event.getOption(MESSAGE_OPTION)).getAsString();
-
-        final MsgTone tone = parseTone(event.getOption(TONE_OPTION), event.getUser().getId());
+        final MessageTone tone = parseTone(event.getOption(TONE_OPTION));
 
         event.deferReply(true).queue();
 
-        final Optional<String> rewrittenMessage = this.rewrite(userMessage, tone);
+        Optional<String> rewrittenMessage = rewrite(userMessage, tone);
 
         if (rewrittenMessage.isEmpty()) {
-            logger.debug("Failed to obtain a response for /rewrite-msg, original message: '{}'",
-                    userMessage);
+            logger.debug("Failed to obtain a response for /{}, original message: '{}'",
+                    COMMAND_NAME, userMessage);
+
             event.getHook()
                 .editOriginal(
                         "An error occurred while processing your request. Please try again later.")
                 .queue();
+
             return;
         }
 
-        final String response = buildResponse(userMessage, rewrittenMessage.orElseThrow(), tone);
+        final String rewrittenText = rewrittenMessage.orElseThrow();
 
-        event.getHook().editOriginal(response).queue();
+        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();
     }
 
-    private MsgTone parseTone(@Nullable OptionMapping toneOption, String userId)
+    private MessageTone parseTone(@Nullable OptionMapping toneOption)
             throws IllegalArgumentException {
+
         if (toneOption == null) {
-            logger.debug("Tone option not provided for user: {}, using default CLEAR", userId);
-            return MsgTone.CLEAR;
+            logger.debug("Tone option not provided, using default '{}'", MessageTone.CLEAR.name());
+            return MessageTone.CLEAR;
         }
 
         final String toneValue = toneOption.getAsString();
-        final MsgTone tone = MsgTone.valueOf(toneValue);
-
-        logger.debug("Parsed tone '{}' for user: {}", tone.displayName, userId);
 
-        return tone;
+        return MessageTone.valueOf(toneValue);
     }
 
-    private Optional<String> rewrite(String userMessage, MsgTone tone) {
-        final String rewritePrompt = buildChatGptPrompt(userMessage, tone);
+    private Optional<String> rewrite(String userMessage, MessageTone tone) {
+
+        final String rewritePrompt = createAiPrompt(userMessage, tone);
+
+        Optional<String> attempt =
+                chatGptService.ask(rewritePrompt, tone.displayName, CHAT_GPT_MODEL);
+
+        if (attempt.isEmpty()) {
+            return attempt;
+        }
+
+        final String response = attempt.get();
+
+        if (response.length() <= Message.MAX_CONTENT_LENGTH) {
+            return attempt;
+        }
+
+        logger.debug("Rewritten message exceeded {} characters; retrying with stricter constraint",
+                Message.MAX_CONTENT_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.";
 
-        return chatGptService.ask(rewritePrompt, tone.displayName, CHAT_GPT_MODEL);
+        return chatGptService.ask(shortenPrompt, tone.displayName, CHAT_GPT_MODEL);
     }
 
-    private enum MsgTone {
+    private enum MessageTone {
         CLEAR("Clear", "Make it clear and easy to understand."),
         PRO("Pro", "Use a professional and polished tone."),
         DETAILED("Detailed", "Expand with more detail and explanation."),
@@ -145,7 +186,7 @@ private enum MsgTone {
         private final String displayName;
         private final String description;
 
-        MsgTone(String displayName, String description) {
+        MessageTone(String displayName, String description) {
             this.displayName = displayName;
             this.description = description;
         }