Fix: Restore reasoning display with visual improvements (v0.2.8)

Author: Mage212

supercoder/repl.py

@@ -153,21 +153,56 @@ def run(self):
         self.console.print("[green]Goodbye![/]")
 
     def _handle_chat(self, message):
-        """Handle chat interaction with clean output (no streaming)."""
+        """Handle chat interaction with clean, incremental output."""
         # User message is already displayed by the main loop with styling
 
-        # Collect full response first, then display
-        response_text = ""
-        tool_calls = []
-        tool_results = []
+        # State tracking
+        current_block_type = None  # 'reasoning', 'response', or None
+        current_buffer = ""
+        
+        # Accumulators for logging/final processing, NOT for display (display is immediate)
+        full_response_text = ""
+        full_reasoning_text = ""  # Just for internal consistency if needed
+        # We still collect tool calls/results for logging logic if needed, but display them immediately
+
         errors = []
         was_aborted = False
         rollback_info = None
 
         # Track active files (files touched by tools)
         touched_files = set()
 
-        # Show spinner while processing
+        # Helper to flush current text buffer to display
+        def flush_buffer():
+            nonlocal current_block_type, current_buffer
+            if not current_buffer or not current_buffer.strip():
+                return
+            
+            content_to_print = current_buffer.strip()
+                
+            if current_block_type == 'reasoning':
+                self.console.print(Panel(
+                    Markdown(content_to_print),
+                    title="[bold magenta]💭 Reasoning[/]",
+                    border_style="magenta",
+                    box=self._get_box_style(),
+                    padding=(0, 1)
+                ))
+            elif current_block_type == 'response':
+                clean_text = self._filter_special_tokens(content_to_print)
+                if clean_text:
+                    self.console.print(Panel(
+                        Markdown(clean_text),
+                        title="[bold blue]SuperCoder[/]",
+                        border_style="blue",
+                        box=self._get_box_style(),
+                        padding=(0, 1)
+                    ))
+            
+            # Reset buffer
+            current_buffer = ""
+            current_block_type = None
+
         # Show spinner while processing
         with self.console.status("[bold blue]SuperCoder is thinking...[/]", spinner="dots") as status:
             # Start keyboard listener for abort
@@ -179,27 +214,66 @@ def _handle_chat(self, message):
                     event_type = event.get("type")
                     content = event.get("content")
 
-                    if event_type == "token":
-                        response_text += content
+                    # Handle state transitions
+                    if event_type == "reasoning":
+                        # If we were doing something else (e.g. response), flush it
+                        if current_block_type != 'reasoning':
+                            flush_buffer()
+                            current_block_type = 'reasoning'
+                        current_buffer += content
+                        full_reasoning_text += content
+
+                    elif event_type == "token":
+                        # If we were doing reasoning, flush it
+                        if current_block_type != 'response':
+                            flush_buffer()
+                            current_block_type = 'response'
+                        current_buffer += content
+                        full_response_text += content
+
                     elif event_type == "tool_call":
-                        tool_calls.append(content)
-                        # Track files from tool args
+                        # Tool call interrupts any text generation
+                        flush_buffer()
+                        
+                        # Display tool call immediately
+                        # We might want to clear spinner, print, resume spinner - 
+                        # but Rich handles prints during active spinner gracefully usually.
+                        status.stop()
+                        self._display_tool_call(content)
+                        status.start()
+                        
+                        # Track files
                         self._track_files(content, touched_files)
+
                     elif event_type == "tool_result":
-                        tool_results.append(content)
+                        # Tool result interrupts
+                        flush_buffer()
+                        self._display_tool_result(content)
+
                     elif event_type == "error":
+                        flush_buffer()
                         errors.append(content)
+                        self.console.print(Panel(f"[red]{content}[/]", title="[bold red]Error[/]", border_style="red"))
+
                     elif event_type == "aborted":
+                        flush_buffer()
                         was_aborted = True
                         status.stop()
+
                     elif event_type == "rollback":
                         rollback_info = content
+
                     elif event_type == "command_waiting":
-                        # Process is waiting - need user interaction
-                        status.stop()  # Stop spinner to allow interaction
+                        # Need user interaction
+                        flush_buffer()
+                        status.stop()
                         self._handle_command_waiting(event)
-                        # Continue iteration - the process has been handled
+                        # Process handled, maybe loops back
+                        
             finally:
+                # Ensure pending buffer is printed
+                flush_buffer()
+                
                 # Stop keyboard listener
                 if hasattr(self, 'keyboard_listener'):
                     self.keyboard_listener.stop()
@@ -224,30 +298,7 @@ def _handle_chat(self, message):
                 border_style="cyan",
                 box=self._get_box_style()
             ))
-        
-        # 1. Display Tool Calls & Results first (Implementation Detail)
-        if tool_calls:
-            self.console.print() # Spacer
-            for i, tc in enumerate(tool_calls):
-                self._display_tool_call(tc)
-                if i < len(tool_results):
-                    self._display_tool_result(tool_results[i])
-            self.console.print() # Spacer
-
-        # 2. Display Errors
-        for error in errors:
-            self.console.print(Panel(f"[red]{error}[/]", title="[bold red]Error[/]", border_style="red"))
-        
-        # 3. Display Assistant Response
-        clean_text = self._filter_special_tokens(response_text)
-        if clean_text:
-            self.console.print(Panel(
-                Markdown(clean_text),
-                title="[bold blue]SuperCoder[/]",
-                border_style="blue",
-                box=self._get_box_style()
-            ))
-        
+
         # 4. Display Status Footer (Tokens & Files)
         self._display_status_footer(touched_files)
 
@@ -407,10 +458,11 @@ def _display_tool_call(self, tool_call):
             args_str = json.dumps(args, indent=2)
 
         self.console.print(Panel(
-            Syntax(args_str, "json", theme="monokai", word_wrap=True),
+            Syntax(args_str.strip(), "json", theme="monokai", word_wrap=True, padding=0),
             title=f"[bold yellow]🔧 Tool Call: {name}[/]",
             border_style="yellow",
-            box=self._get_box_style()
+            box=self._get_box_style(),
+            padding=(0, 1)
         ))
 
     def _display_tool_result(self, result_data):
@@ -427,10 +479,11 @@ def _display_tool_result(self, result_data):
         display_result = result[:500] + "..." if len(result) > 500 else result
 
         self.console.print(Panel(
-            f"[dim]{display_result}[/]",
+            f"[dim]{display_result.strip()}[/]",
             title=f"[bold green]✔ Result: {name}[/]",
             border_style="green",
-            box=self._get_box_style()
+            box=self._get_box_style(),
+            padding=(0, 1)
         ))
 
     def _is_diff_result(self, result: str) -> bool:
@@ -471,12 +524,13 @@ def _display_diff_result(self, name: str, result: str):
         # Display diff with syntax highlighting
         if diff_lines:
             diff_text = "\n".join(diff_lines)
-            syntax = Syntax(diff_text, "diff", theme="monokai", line_numbers=False)
+            syntax = Syntax(diff_text, "diff", theme="monokai", line_numbers=False, padding=0)
             self.console.print(Panel(
                 syntax, 
                 title="[bold cyan]Changes[/]", 
                 border_style="cyan",
-                box=self._get_box_style()
+                box=self._get_box_style(),
+                padding=(0, 1)
             ))