Fix: Revert REPL to v0.2.7 stable version

Author: Mage212

supercoder/repl.py

@@ -153,56 +153,21 @@ def run(self):
         self.console.print("[green]Goodbye![/]")
 
     def _handle_chat(self, message):
-        """Handle chat interaction with clean, incremental output."""
+        """Handle chat interaction with clean output (no streaming)."""
         # User message is already displayed by the main loop with styling
 
-        # 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
-
+        # Collect full response first, then display
+        response_text = ""
+        tool_calls = []
+        tool_results = []
         errors = []
         was_aborted = False
         rollback_info = None
 
         # Track active files (files touched by tools)
         touched_files = set()
 
-        # 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
         # Show spinner while processing
         with self.console.status("[bold blue]SuperCoder is thinking...[/]", spinner="dots") as status:
             # Start keyboard listener for abort
@@ -214,66 +179,27 @@ def flush_buffer():
                     event_type = event.get("type")
                     content = event.get("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
-
+                    if event_type == "token":
+                        response_text += content
                     elif event_type == "tool_call":
-                        # 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
+                        tool_calls.append(content)
+                        # Track files from tool args
                         self._track_files(content, touched_files)
-
                     elif event_type == "tool_result":
-                        # Tool result interrupts
-                        flush_buffer()
-                        self._display_tool_result(content)
-
+                        tool_results.append(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":
-                        # Need user interaction
-                        flush_buffer()
-                        status.stop()
+                        # Process is waiting - need user interaction
+                        status.stop()  # Stop spinner to allow interaction
                         self._handle_command_waiting(event)
-                        # Process handled, maybe loops back
-                        
+                        # Continue iteration - the process has been handled
             finally:
-                # Ensure pending buffer is printed
-                flush_buffer()
-                
                 # Stop keyboard listener
                 if hasattr(self, 'keyboard_listener'):
                     self.keyboard_listener.stop()
@@ -298,7 +224,30 @@ def flush_buffer():
                 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)
 
@@ -348,6 +297,11 @@ def _display_status_footer(self, touched_files):
             files_str = ", ".join(sorted(touched_files))
             parts.append(f"[dim]Active Files: {files_str}[/]")
 
+        # Cost estimate (rough approximation)
+        # Assuming generic pricing, just to show we can
+        # cost = (stats.used_tokens / 1000) * 0.002 # Example
+        # parts.append(f"[dim]Est. Cost: ${cost:.4f}[/]")
+
         self.console.print(" | ".join(parts), justify="right")
 
     def _get_box_style(self):
@@ -359,13 +313,15 @@ def _handle_command_waiting(self, event):
         """Handle a command that appears to be waiting for input."""
         content = event.get("content", "")
         process = event.get("process")
+        tool_name = event.get("tool_name", "command-exec")
 
         # Display warning
         self.console.print(Panel(
             f"[yellow]{content}[/]",
             title="[bold yellow]⚠️ Process Stalled[/]",
             border_style="yellow",
             box=self._get_box_style()
+
         ))
 
         # Simple stdin-based menu (most reliable across terminals)
@@ -403,6 +359,10 @@ def _handle_command_waiting(self, event):
                 except Exception:
                     pass
             return "killed"
+
+
+
+
 
     def _filter_special_tokens(self, text: str) -> str:
         """Remove special tokens from display text while preserving normal content."""
@@ -447,11 +407,10 @@ def _display_tool_call(self, tool_call):
             args_str = json.dumps(args, indent=2)
 
         self.console.print(Panel(
-            Syntax(args_str.strip(), "json", theme="monokai", word_wrap=True, padding=0),
+            Syntax(args_str, "json", theme="monokai", word_wrap=True),
             title=f"[bold yellow]🔧 Tool Call: {name}[/]",
             border_style="yellow",
-            box=self._get_box_style(),
-            padding=(0, 1)
+            box=self._get_box_style()
         ))
 
     def _display_tool_result(self, result_data):
@@ -468,11 +427,10 @@ 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.strip()}[/]",
+            f"[dim]{display_result}[/]",
             title=f"[bold green]✔ Result: {name}[/]",
             border_style="green",
-            box=self._get_box_style(),
-            padding=(0, 1)
+            box=self._get_box_style()
         ))
 
     def _is_diff_result(self, result: str) -> bool:
@@ -493,28 +451,32 @@ def _display_diff_result(self, name: str, result: str):
         in_diff = False
 
         for line in lines:
+            # Check for unified diff markers to start capturing diff
+            # --- file header, +++ file header, @@ hunk header
             if line.startswith("--- ") or line.startswith("+++ ") or line.startswith("@@"):
                 in_diff = True
 
             if in_diff:
+                # Once in diff mode, capture all lines (including +/- content lines)
                 diff_lines.append(line)
             else:
                 message_lines.append(line)
 
+        # Display message part (success message)
         if message_lines:
             message = "\n".join(message_lines).strip()
             if message:
                 self.console.print(f"[bold green]✔ {name}[/]: {message}")
 
+        # Display diff with syntax highlighting
         if diff_lines:
             diff_text = "\n".join(diff_lines)
-            syntax = Syntax(diff_text, "diff", theme="monokai", line_numbers=False, padding=0)
+            syntax = Syntax(diff_text, "diff", theme="monokai", line_numbers=False)
             self.console.print(Panel(
                 syntax, 
                 title="[bold cyan]Changes[/]", 
                 border_style="cyan",
-                box=self._get_box_style(),
-                padding=(0, 1)
+                box=self._get_box_style()
             ))