fixed chat window

Author: Jon Olick

aisearch.py

@@ -907,23 +907,45 @@ def chat_about_matches(matches: List[Dict[str, Any]],
 4. Clear, factual analysis based only on the provided code
 
 When referring to matches, ALWAYS use the FULL file path and line number (e.g., '/path/to/file.cpp:123') rather than match numbers or just the filename.
-Keep your responses concise and to the point."""
+Keep your responses concise and to the point.
+
+IMPORTANT: Always directly address the user's questions. If they ask a specific question about the code or results, make sure to answer that question directly rather than continuing your previous analysis.
+"""
 
     print(f"\nEntering chat mode. {len(matches)} matches found for: '{original_prompt}'")
     print("Ask questions about the search results or type 'exit' to quit.\n")
 
-    history = [{
-        "role": "user",
-        "content": f"These are code search results for: '{original_prompt}'\n\n{combined_contexts}\n\nPlease analyze these findings."
-    }]
+    # Store the initial search results as a fixed context that will always be included
+    search_context = f"These are code search results for: '{original_prompt}'\n\n{combined_contexts}"
+    
+    # Keep track of user-assistant exchanges separately from the fixed context
+    exchanges = []
 
+    # Initial analysis request
+    initial_prompt = "Please analyze these findings."
+    
     while True:
         user_input = input("\nYou: ")
         if user_input.lower() in {"exit", "quit"}:
             print("Exiting chat.")
             break
 
-        history.append({"role": "user", "content": user_input})
+        # Add user message to exchanges
+        exchanges.append({"role": "user", "content": user_input})
+        
+        # Limit exchanges to prevent context overflow
+        recent_exchanges = exchanges[-12:] if len(exchanges) > 12 else exchanges
+        
+        # Construct messages: first the context message, then recent exchanges
+        messages = [{"role": "user", "content": search_context}]
+        
+        # Add a separator if we have exchanges
+        if recent_exchanges:
+            messages.append({"role": "assistant", "content": "I'll analyze these code search results. What specific aspects would you like me to focus on?"})
+            messages.extend(recent_exchanges)
+        else:
+            # If this is the first exchange, add the initial analysis request
+            messages.append({"role": "user", "content": initial_prompt})
 
         if provider == "anthropic":
             # Use streaming API for Anthropic
@@ -939,7 +961,7 @@ def chat_about_matches(matches: List[Dict[str, Any]],
                     "type": "enabled",
                     "budget_tokens": 2048
                 },
-                messages=history[-10:]  # Send only the last 10 exchanges
+                messages=messages
             ) as stream:
                 for text in stream.text_stream:
                     print(text, end="", flush=True)
@@ -951,7 +973,7 @@ def chat_about_matches(matches: List[Dict[str, Any]],
 
             stream = client.chat.completions.create(
                 model="o3-mini",
-                messages=[{"role": "system", "content": system_message}] + history[-10:],
+                messages=[{"role": "system", "content": system_message}] + messages,
                 temperature=1,
                 max_completion_tokens=4096,
                 stream=True
@@ -964,7 +986,9 @@ def chat_about_matches(matches: List[Dict[str, Any]],
                     full_response += text
 
         print()  # Add a newline after the streamed response
-        history.append({"role": "assistant", "content": full_response})
+        
+        # Add assistant response to exchanges
+        exchanges.append({"role": "assistant", "content": full_response})
 
 
 def clear_file_cache() -> None:

aisearch_gui.py

@@ -151,13 +151,14 @@ def stop(self):
         self.stop_requested = True
 
 class ChatThread(threading.Thread):
-    def __init__(self, parent, matches, prompt, question):
+    def __init__(self, parent, matches, prompt, question, chat_history=None):
         super().__init__()
         self.parent = parent
         self.matches = matches
         self.prompt = prompt
         self.question = question
         self.provider = parent.provider_combo.currentText()
+        self.chat_history = chat_history or []
 
     def run(self):
         try:
@@ -181,16 +182,35 @@ def run(self):
             4. Clear, factual analysis based only on the provided code
 
             When referring to matches, ALWAYS use the file path and line number (e.g., 'In file.cpp:123') rather than match numbers.
-            Keep your responses concise and to the point."""
+            Keep your responses concise and to the point.
             
-            messages = [
-                {"role": "user", "content": f"These are code search results for: '{self.prompt}'\n\n{combined_contexts}"}
-            ]
+            IMPORTANT: Always directly address the user's questions. If they ask a specific question about the code or results,
+            make sure to answer that question directly rather than continuing your previous analysis."""
 
-            if self.question:
-                messages.append({"role": "user", "content": self.question})
+            # Prepare messages
+            if not self.chat_history:
+                # First message in the conversation
+                messages = [
+                    {"role": "user", "content": f"These are code search results for: '{self.prompt}'\n\n{combined_contexts}"}
+                ]
+                
+                if self.question:
+                    messages.append({"role": "user", "content": self.question})
+                else:
+                    messages.append({"role": "user", "content": "Please analyze these findings."})
             else:
-                messages.append({"role": "user", "content": "Please analyze these findings."})
+                # We have existing chat history
+                # First message always contains the search context
+                messages = [
+                    {"role": "user", "content": f"These are code search results for: '{self.prompt}'\n\n{combined_contexts}"}
+                ]
+                # Add a separator message
+                messages.append({"role": "assistant", "content": "I'll analyze these code search results. What would you like to know?"})
+                # Add the conversation history (limited to last 10 exchanges to prevent context overflow)
+                messages.extend(self.chat_history[-10:])
+                # Add the new question
+                if self.question:
+                    messages.append({"role": "user", "content": self.question})
 
             if self.provider == "anthropic":
                 response = client.messages.create(
@@ -210,7 +230,19 @@ def run(self):
                 )
                 response_text = response.choices[0].message.content
 
-            self.parent.signal_chat_response.emit(response_text)
+            # Save question and response to history
+            if self.question:
+                new_history = self.chat_history + [
+                    {"role": "user", "content": self.question},
+                    {"role": "assistant", "content": response_text}
+                ]
+            else:
+                new_history = self.chat_history + [
+                    {"role": "assistant", "content": response_text}
+                ]
+            
+            # Use tuple to send both response and history
+            self.parent.signal_chat_response.emit((response_text, new_history))
 
         except Exception as e:
             self.parent.signal_error.emit(str(e))
@@ -1099,13 +1131,14 @@ class AISearchGUI(QMainWindow):
     signal_update_terms = Signal(str)
     signal_search_complete = Signal(int)
     signal_error = Signal(str)
-    signal_chat_response = Signal(str)
+    signal_chat_response = Signal(object)  # Changed to object to support tuple
 
     def __init__(self):
         super().__init__()
         self.matches = []
         self.search_thread = None
         self.chat_thread = None
+        self.chat_history = []  # Add chat history
         self.settings = QSettings("AICodeSearch", "AISearchGUI")
         self.results_buffer = ResultsBuffer()
         self.update_timer = QTimer(self)
@@ -1917,6 +1950,7 @@ def clear_results(self):
         self.chat_input.clear()
         self.file_list.clear()
         self.matches = []
+        self.chat_history = []  # Clear chat history
         self.chat_button.setEnabled(False)
         self.chat_action.setEnabled(False)
         self.refine_button.setEnabled(False)
@@ -1939,16 +1973,37 @@ def start_chat(self):
         # Switch to chat tab
         self.tabs.setCurrentIndex(1)
 
-        # Start chat thread
-        self.chat_thread = ChatThread(self, self.matches, prompt, question)
+        # Start chat thread with history
+        self.chat_thread = ChatThread(self, self.matches, prompt, question, self.chat_history)
         self.chat_thread.start()
 
-    @Slot(str)
-    def update_chat(self, response):
+    @Slot(object)
+    def update_chat(self, response_data):
         """Update chat output with AI response"""
+        # Unpack response and history
+        if isinstance(response_data, tuple):
+            response, self.chat_history = response_data
+        else:
+            # For backward compatibility
+            response = response_data
+        
         # Store original markdown for copy functionality
         self.chat_output.markdown_content = response
 
+        # Clear previous content and show only the latest exchange
+        self.chat_output.clear()
+        
+        # Add user question to the display if it exists
+        if self.chat_input.toPlainText().strip():
+            # Format with user question and AI response
+            content = f"**You:** {self.chat_input.toPlainText().strip()}\n\n**AI:**\n\n{response}"
+            self.chat_output.setMarkdown(content)
+            # Clear input after sending
+            self.chat_input.clear()
+        else:
+            # Initial analysis (no user question)
+            self.chat_output.setMarkdown(response)
+            
         # Convert markdown to HTML
         try:
             # Set up extensions based on available libraries
@@ -1972,7 +2027,7 @@ def update_chat(self, response):
                 self.chat_output.document().setDefaultStyleSheet(current_css + pygments_css)
 
             html_content = markdown.markdown(
-                response, 
+                self.chat_output.toMarkdown(), 
                 extensions=extensions,
                 extension_configs=extension_configs
             )
@@ -1986,15 +2041,11 @@ def update_chat(self, response):
 
             # Set the HTML content
             self.chat_output.setHtml(html_content)
-        except Exception as e:
-            # Fallback to plain text if markdown conversion fails
-            self.chat_output.setPlainText(response)
-            self.statusBar().showMessage(f"Markdown rendering error: {str(e)}")
-            
-        self.progress_bar.setVisible(False)
-        self.chat_button.setEnabled(True)
-        # Remove chat_action reference
-        self.statusBar().showMessage("Chat response received")
+        
+        # Hide progress and enable chat button
+        finally:
+            self.progress_bar.setVisible(False)
+            self.chat_button.setEnabled(True)
 
     def loadSettings(self):
         """Load saved settings"""