Merge pull request #596 from devoxx/issue-595

stephanj · web-flow · commit 33d6aadf1d09 · 2025-03-30T10:41:13.000+02:00
Fix #595 : Increased default chat memory + Removed add user message '…
diff --git a/src/main/java/com/devoxx/genie/model/Constant.java b/src/main/java/com/devoxx/genie/model/Constant.java
@@ -54,7 +54,7 @@ private Constant() {
     public static final Integer MAX_OUTPUT_TOKENS = 4000;
     public static final Integer MAX_RETRIES = 1;
     public static final Integer TIMEOUT = 180;
-    public static final Integer MAX_MEMORY = 10;
+    public static final Integer MAX_MEMORY = 50;
 
     // Hide Search Button
     public static final Boolean ENABLE_WEB_SEARCH = false;
diff --git a/src/main/java/com/devoxx/genie/service/MessageCreationService.java b/src/main/java/com/devoxx/genie/service/MessageCreationService.java
@@ -70,6 +70,8 @@ public static MessageCreationService getInstance() {
      * @param chatMessageContext the chat message context
      */
     public void addUserMessageToContext(@NotNull ChatMessageContext chatMessageContext) {
+        log.debug("Adding user message to context: userPrompt={}", chatMessageContext.getUserPrompt());
+
         // Check if user message already exists to prevent duplicates
         if (chatMessageContext.getUserMessage() != null) {
             // Message already exists, skip creating another one
diff --git a/src/main/java/com/devoxx/genie/service/prompt/memory/ChatMemoryManager.java b/src/main/java/com/devoxx/genie/service/prompt/memory/ChatMemoryManager.java
@@ -14,7 +14,6 @@
 import dev.langchain4j.data.message.SystemMessage;
 import dev.langchain4j.data.message.UserMessage;
 import dev.langchain4j.memory.ChatMemory;
-import dev.langchain4j.model.bedrock.BedrockChatModel;
 import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
 
diff --git a/src/main/java/com/devoxx/genie/service/prompt/memory/ChatMemoryService.java b/src/main/java/com/devoxx/genie/service/prompt/memory/ChatMemoryService.java
@@ -23,6 +23,16 @@
 @Slf4j
 public class ChatMemoryService implements ChatMemoryProvider {
 
+    public static final String CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT = "Chat memory not initialized for project: ";
+    public static final String FAILED_TO_REMOVE_MESSAGES_FROM_MEMORY = "Failed to remove messages from memory";
+    public static final String FAILED_TO_GET_CHAT_MEMORY_FOR_PROJECT_HASH = "Failed to get chat memory for project hash: ";
+    public static final String FAILED_TO_INITIALIZE_CHAT_MEMORY_FOR_PROJECT = "Failed to initialize chat memory for project: ";
+    public static final String FAILED_TO_CLEAR_MEMORY = "Failed to clear memory";
+    public static final String FAILED_TO_ADD_MESSAGE_TO_MEMORY = "Failed to add message to memory";
+    public static final String FAILED_TO_GET_MESSAGES_FROM_MEMORY = "Failed to get messages from memory";
+    public static final String FAILED_TO_CHECK_IF_MEMORY_IS_EMPTY = "Failed to check if memory is empty";
+    public static final String FAILED_TO_REMOVE_LAST_MESSAGE_FROM_MEMORY = "Failed to remove last message from memory";
+
     private final Map<String, MessageWindowChatMemory> projectConversations = new ConcurrentHashMap<>();
     private final InMemoryChatMemoryStore inMemoryChatMemoryStore = new InMemoryChatMemoryStore();
 
@@ -48,7 +58,7 @@ public void initialize(@NotNull Project project, int chatMemorySize) {
 
             createChatMemory(projectHash, chatMemorySize);
         } catch (Exception e) {
-            throw new MemoryException("Failed to initialize chat memory for project: " + projectHash, e);
+            throw new MemoryException(FAILED_TO_INITIALIZE_CHAT_MEMORY_FOR_PROJECT + projectHash, e);
         }
     }
 
@@ -67,7 +77,7 @@ public void clearMemory(@NotNull Project project) {
                 log.warn("Attempted to clear memory for non-existent project: {}", projectHash);
             }
         } catch (Exception e) {
-            throw new MemoryException("Failed to clear memory", e);
+            throw new MemoryException(FAILED_TO_CLEAR_MEMORY, e);
         }
     }
 
@@ -101,11 +111,11 @@ public void addMessage(@NotNull Project project, ChatMessage chatMessage) {
                 memory.add(chatMessage);
                 log.debug("Successfully added message to project: {}, message type: {}", projectHash, chatMessage.getClass().getSimpleName());
             } else {
-                throw new MemoryException("Chat memory not initialized for project: " + projectHash);
+                throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);
             }
         } catch (Exception e) {
             if (!(e instanceof MemoryException)) {
-                throw new MemoryException("Failed to add message to memory", e);
+                throw new MemoryException(FAILED_TO_ADD_MESSAGE_TO_MEMORY, e);
             }
             throw e;
         }
@@ -123,11 +133,11 @@ public List<ChatMessage> getMessages(@NotNull Project project) {
             if (memory != null) {
                 return memory.messages();
             } else {
-                throw new MemoryException("Chat memory not initialized for project: " + projectHash);
+                throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);
             }
         } catch (Exception e) {
             if (!(e instanceof MemoryException)) {
-                throw new MemoryException("Failed to get messages from memory", e);
+                throw new MemoryException(FAILED_TO_GET_MESSAGES_FROM_MEMORY, e);
             }
             throw e;
         }
@@ -149,7 +159,7 @@ public boolean isEmpty(@NotNull Project project) {
                 return true;
             }
         } catch (Exception e) {
-            throw new MemoryException("Failed to check if memory is empty", e);
+            throw new MemoryException(FAILED_TO_CHECK_IF_MEMORY_IS_EMPTY, e);
         }
     }
 
@@ -176,11 +186,11 @@ public void removeLastMessage(@NotNull Project project) {
                             lastMessage.getClass().getSimpleName(), projectHash);
                 }
             } else {
-                throw new MemoryException("Chat memory not initialized for project: " + projectHash);
+                throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);
             }
         } catch (Exception e) {
             if (!(e instanceof MemoryException)) {
-                throw new MemoryException("Failed to remove last message from memory", e);
+                throw new MemoryException(FAILED_TO_REMOVE_LAST_MESSAGE_FROM_MEMORY, e);
             }
             throw e;
         }
@@ -212,11 +222,11 @@ public void removeMessages(@NotNull Project project, List<ChatMessage> messagesT
                             messagesToRemove.size(), projectHash);
                 }
             } else {
-                throw new MemoryException("Chat memory not initialized for project: " + projectHash);
+                throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);
             }
         } catch (Exception e) {
             if (!(e instanceof MemoryException)) {
-                throw new MemoryException("Failed to remove messages from memory", e);
+                throw new MemoryException(FAILED_TO_REMOVE_MESSAGES_FROM_MEMORY, e);
             }
             throw e;
         }
@@ -242,7 +252,7 @@ public ChatMemory get(Object projectHash) {
         try {
             return projectConversations.get(projectHash.toString());
         } catch (Exception e) {
-            throw new MemoryException("Failed to get chat memory for project hash: " + projectHash, e);
+            throw new MemoryException(FAILED_TO_GET_CHAT_MEMORY_FOR_PROJECT_HASH + projectHash, e);
         }
     }
 }
diff --git a/src/main/java/com/devoxx/genie/service/prompt/strategy/AbstractPromptExecutionStrategy.java b/src/main/java/com/devoxx/genie/service/prompt/strategy/AbstractPromptExecutionStrategy.java
@@ -5,11 +5,13 @@
 import com.devoxx.genie.service.prompt.error.ExecutionException;
 import com.devoxx.genie.service.prompt.error.PromptErrorHandler;
 import com.devoxx.genie.service.prompt.memory.ChatMemoryManager;
+import com.devoxx.genie.service.prompt.memory.ChatMemoryService;
 import com.devoxx.genie.service.prompt.result.PromptResult;
 import com.devoxx.genie.service.prompt.threading.PromptTask;
 import com.devoxx.genie.service.prompt.threading.ThreadPoolManager;
 import com.devoxx.genie.ui.panel.PromptOutputPanel;
 import com.intellij.openapi.project.Project;
+import dev.langchain4j.data.message.UserMessage;
 import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
 
@@ -126,11 +128,18 @@ protected abstract void executeStrategySpecific(ChatMessageContext context,
     public void prepareMemory(ChatMessageContext context) {
         // Prepare memory with system message if needed and add user message
         log.debug("Before memory preparation - context ID: {}", context.getId());
+
         chatMemoryManager.prepareMemory(context);
+
         // Add context information to the user message before adding to memory
         messageCreationService.addUserMessageToContext(context);
-        // Now add the enriched user message to chat memory
-        chatMemoryManager.addUserMessage(context);
+
+        // Check if user message was properly created
+        if (context.getUserMessage() == null) {
+            log.error("Failed to create user message for context ID: {}", context.getId());
+            // Create a fallback user message if needed
+            context.setUserMessage(UserMessage.from(context.getUserPrompt()));
+        }
     }
     
     /**
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
@@ -40,6 +40,7 @@
             <Li>Feat #586 : Added Gemini 2.5 Pro model by @stephanj</LI>
             <LI>Fix #588 : [Regression] Fix streaming responses by @stephanj</LI>
             <LI>Feat #590 : User can now configure which keys to use for newline by @stephanj</LI>
+            <LI>Fix #595 : At least one message is required by @stephanj</LI>
         </UL>
         <h2>v0.5.2</h2>
         <UL>
diff --git a/src/test/java/com/devoxx/genie/service/prompt/strategy/AbstractPromptExecutionStrategyTest.java b/src/test/java/com/devoxx/genie/service/prompt/strategy/AbstractPromptExecutionStrategyTest.java
@@ -83,21 +83,6 @@ private void mockStaticDependencies() {
         }
     }
 
-    @Test
-    void prepareMemory_shouldCallMessageCreationServiceBeforeChatMemoryManager() {
-        // Arrange
-        when(mockProject.getName()).thenReturn("TestProject");
-        
-        // Act
-        testStrategy.prepareMemory(mockChatMessageContext);
-        
-        // Assert - verify correct order of operations
-        InOrder inOrder = inOrder(mockChatMemoryManager, mockMessageCreationService);
-        inOrder.verify(mockChatMemoryManager).prepareMemory(mockChatMessageContext);
-        inOrder.verify(mockMessageCreationService).addUserMessageToContext(mockChatMessageContext);
-        inOrder.verify(mockChatMemoryManager).addUserMessage(mockChatMessageContext);
-    }
-    
     /**
      * Test implementation of the abstract class
      */
diff --git a/src/test/java/com/devoxx/genie/service/prompt/strategy/NonStreamingPromptStrategyTest.java b/src/test/java/com/devoxx/genie/service/prompt/strategy/NonStreamingPromptStrategyTest.java
@@ -155,30 +155,6 @@ void setUp() {
         );
     }
 
-
-    @Test
-    void executeStrategySpecific_shouldNotCallAddUserMessageToContextAgain() {
-        // Arrange
-        // Setup to execute the actual prepareMemory method which will call addUserMessageToContext
-        doCallRealMethod().when(mockChatMemoryManager).prepareMemory(any());
-
-        // Act
-        strategy.executeStrategySpecific(mockChatMessageContext, mockPanel, mockResultTask);
-
-        // Assert - verify addUserMessageToContext is called exactly once (by the parent class's prepareMemory method)
-        // The NonStreamingPromptExecutionService should not call it again
-        verify(mockMessageCreationService, times(1)).addUserMessageToContext(mockChatMessageContext);
-    }
-
-    @Test
-    void executeStrategySpecific_shouldUseChatMemoryManagerToAddUserMessage() {
-        // Act
-        strategy.executeStrategySpecific(mockChatMessageContext, mockPanel, mockResultTask);
-
-        // Assert - verify prepareMemory is called, which internally handles addUserMessage
-        verify(mockChatMemoryManager).prepareMemory(mockChatMessageContext);
-    }
-    
     @org.junit.jupiter.api.AfterEach
     void tearDown() {
         // Close all static mocks to prevent memory leaks
diff --git a/src/test/java/com/devoxx/genie/service/prompt/strategy/StreamingPromptStrategyTest.java b/src/test/java/com/devoxx/genie/service/prompt/strategy/StreamingPromptStrategyTest.java
@@ -105,7 +105,7 @@ void setUp() {
         // Setup services in the application
         when(mockApplication.getService(ChatMemoryManager.class)).thenReturn(mockChatMemoryManager);
         when(mockApplication.getService(ThreadPoolManager.class)).thenReturn(mockThreadPoolManager);
-        when(mockApplication.getService(MessageCreationService.class)).thenReturn(mockMessageCreationService);
+        // when(mockApplication.getService(MessageCreationService.class)).thenReturn(mockMessageCreationService);
         when(mockApplication.getService(ChatMemoryService.class)).thenReturn(mockChatMemoryService);
         
         // Setup static getInstance methods
@@ -122,6 +122,16 @@ void setUp() {
         when(mockThreadPoolManager.getPromptExecutionPool()).thenReturn(mockExecutor);
         when(mockChatMessageContext.getProject()).thenReturn(mockProject);
         when(mockChatMessageContext.getStreamingChatLanguageModel()).thenReturn(mockStreamingModel);
+        // Mock userPrompt to prevent "text cannot be null or blank" exception
+        when(mockChatMessageContext.getUserPrompt()).thenReturn("Test user prompt");
+        
+        // Mock the behavior of addUserMessageToContext to set a user message on the context
+        doAnswer(invocation -> {
+            ChatMessageContext ctx = invocation.getArgument(0);
+            when(ctx.getUserMessage()).thenReturn(dev.langchain4j.data.message.UserMessage.from("Test user prompt"));
+            return null;
+        }).when(mockMessageCreationService).addUserMessageToContext(any(ChatMessageContext.class));
+
         List<ChatMessage> messages = new ArrayList<>();
         when(mockChatMemoryService.getMessages(any(Project.class))).thenReturn(messages);
         
@@ -150,7 +160,7 @@ void setUp() {
     void executeStrategySpecific_shouldFollowCorrectMessageFlowOrder() {
         // Arrange
         // Use inOrder to verify the exact sequence of method calls
-        org.mockito.InOrder inOrder = inOrder(mockChatMemoryManager, mockMessageCreationService);
+        org.mockito.InOrder inOrder = inOrder(mockChatMemoryManager);
         
         // Act
         strategy.executeStrategySpecific(mockChatMessageContext, mockPanel, mockResultTask);

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,16 @@`
`23`	`23`	`@Slf4j`
`24`	`24`	`public class ChatMemoryService implements ChatMemoryProvider {`
`25`	`25`
	`26`	`+ public static final String CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT = "Chat memory not initialized for project: ";`
	`27`	`+ public static final String FAILED_TO_REMOVE_MESSAGES_FROM_MEMORY = "Failed to remove messages from memory";`
	`28`	`+ public static final String FAILED_TO_GET_CHAT_MEMORY_FOR_PROJECT_HASH = "Failed to get chat memory for project hash: ";`
	`29`	`+ public static final String FAILED_TO_INITIALIZE_CHAT_MEMORY_FOR_PROJECT = "Failed to initialize chat memory for project: ";`
	`30`	`+ public static final String FAILED_TO_CLEAR_MEMORY = "Failed to clear memory";`
	`31`	`+ public static final String FAILED_TO_ADD_MESSAGE_TO_MEMORY = "Failed to add message to memory";`
	`32`	`+ public static final String FAILED_TO_GET_MESSAGES_FROM_MEMORY = "Failed to get messages from memory";`
	`33`	`+ public static final String FAILED_TO_CHECK_IF_MEMORY_IS_EMPTY = "Failed to check if memory is empty";`
	`34`	`+ public static final String FAILED_TO_REMOVE_LAST_MESSAGE_FROM_MEMORY = "Failed to remove last message from memory";`
	`35`	`+`
`26`	`36`	`private final Map<String, MessageWindowChatMemory> projectConversations = new ConcurrentHashMap<>();`
`27`	`37`	`private final InMemoryChatMemoryStore inMemoryChatMemoryStore = new InMemoryChatMemoryStore();`
`28`	`38`
`@@ -48,7 +58,7 @@ public void initialize(@NotNull Project project, int chatMemorySize) {`
`48`	`58`
`49`	`59`	`createChatMemory(projectHash, chatMemorySize);`
`50`	`60`	`} catch (Exception e) {`
`51`		`- throw new MemoryException("Failed to initialize chat memory for project: " + projectHash, e);`
	`61`	`+ throw new MemoryException(FAILED_TO_INITIALIZE_CHAT_MEMORY_FOR_PROJECT + projectHash, e);`
`52`	`62`	`}`
`53`	`63`	`}`
`54`	`64`
`@@ -67,7 +77,7 @@ public void clearMemory(@NotNull Project project) {`
`67`	`77`	`log.warn("Attempted to clear memory for non-existent project: {}", projectHash);`
`68`	`78`	`}`
`69`	`79`	`} catch (Exception e) {`
`70`		`- throw new MemoryException("Failed to clear memory", e);`
	`80`	`+ throw new MemoryException(FAILED_TO_CLEAR_MEMORY, e);`
`71`	`81`	`}`
`72`	`82`	`}`
`73`	`83`
`@@ -101,11 +111,11 @@ public void addMessage(@NotNull Project project, ChatMessage chatMessage) {`
`101`	`111`	`memory.add(chatMessage);`
`102`	`112`	`log.debug("Successfully added message to project: {}, message type: {}", projectHash, chatMessage.getClass().getSimpleName());`
`103`	`113`	`} else {`
`104`		`- throw new MemoryException("Chat memory not initialized for project: " + projectHash);`
	`114`	`+ throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);`
`105`	`115`	`}`
`106`	`116`	`} catch (Exception e) {`
`107`	`117`	`if (!(e instanceof MemoryException)) {`
`108`		`- throw new MemoryException("Failed to add message to memory", e);`
	`118`	`+ throw new MemoryException(FAILED_TO_ADD_MESSAGE_TO_MEMORY, e);`
`109`	`119`	`}`
`110`	`120`	`throw e;`
`111`	`121`	`}`
`@@ -123,11 +133,11 @@ public List<ChatMessage> getMessages(@NotNull Project project) {`
`123`	`133`	`if (memory != null) {`
`124`	`134`	`return memory.messages();`
`125`	`135`	`} else {`
`126`		`- throw new MemoryException("Chat memory not initialized for project: " + projectHash);`
	`136`	`+ throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);`
`127`	`137`	`}`
`128`	`138`	`} catch (Exception e) {`
`129`	`139`	`if (!(e instanceof MemoryException)) {`
`130`		`- throw new MemoryException("Failed to get messages from memory", e);`
	`140`	`+ throw new MemoryException(FAILED_TO_GET_MESSAGES_FROM_MEMORY, e);`
`131`	`141`	`}`
`132`	`142`	`throw e;`
`133`	`143`	`}`
`@@ -149,7 +159,7 @@ public boolean isEmpty(@NotNull Project project) {`
`149`	`159`	`return true;`
`150`	`160`	`}`
`151`	`161`	`} catch (Exception e) {`
`152`		`- throw new MemoryException("Failed to check if memory is empty", e);`
	`162`	`+ throw new MemoryException(FAILED_TO_CHECK_IF_MEMORY_IS_EMPTY, e);`
`153`	`163`	`}`
`154`	`164`	`}`
`155`	`165`
`@@ -176,11 +186,11 @@ public void removeLastMessage(@NotNull Project project) {`
`176`	`186`	`lastMessage.getClass().getSimpleName(), projectHash);`
`177`	`187`	`}`
`178`	`188`	`} else {`
`179`		`- throw new MemoryException("Chat memory not initialized for project: " + projectHash);`
	`189`	`+ throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);`
`180`	`190`	`}`
`181`	`191`	`} catch (Exception e) {`
`182`	`192`	`if (!(e instanceof MemoryException)) {`
`183`		`- throw new MemoryException("Failed to remove last message from memory", e);`
	`193`	`+ throw new MemoryException(FAILED_TO_REMOVE_LAST_MESSAGE_FROM_MEMORY, e);`
`184`	`194`	`}`
`185`	`195`	`throw e;`
`186`	`196`	`}`
`@@ -212,11 +222,11 @@ public void removeMessages(@NotNull Project project, List<ChatMessage> messagesT`
`212`	`222`	`messagesToRemove.size(), projectHash);`
`213`	`223`	`}`
`214`	`224`	`} else {`
`215`		`- throw new MemoryException("Chat memory not initialized for project: " + projectHash);`
	`225`	`+ throw new MemoryException(CHAT_MEMORY_NOT_INITIALIZED_FOR_PROJECT + projectHash);`
`216`	`226`	`}`
`217`	`227`	`} catch (Exception e) {`
`218`	`228`	`if (!(e instanceof MemoryException)) {`
`219`		`- throw new MemoryException("Failed to remove messages from memory", e);`
	`229`	`+ throw new MemoryException(FAILED_TO_REMOVE_MESSAGES_FROM_MEMORY, e);`
`220`	`230`	`}`
`221`	`231`	`throw e;`
`222`	`232`	`}`
`@@ -242,7 +252,7 @@ public ChatMemory get(Object projectHash) {`
`242`	`252`	`try {`
`243`	`253`	`return projectConversations.get(projectHash.toString());`
`244`	`254`	`} catch (Exception e) {`
`245`		`- throw new MemoryException("Failed to get chat memory for project hash: " + projectHash, e);`
	`255`	`+ throw new MemoryException(FAILED_TO_GET_CHAT_MEMORY_FOR_PROJECT_HASH + projectHash, e);`
`246`	`256`	`}`
`247`	`257`	`}`
`248`	`258`	`}`