code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/messaging/spinner/__init__.py

@@ -1,12 +1,11 @@
 """
-Shared spinner implementation for both TUI and CLI modes.
+Shared spinner implementation for CLI mode.
 
 This module provides consistent spinner animations across different UI modes.
 """
 
 from .console_spinner import ConsoleSpinner
 from .spinner_base import SpinnerBase
-from .textual_spinner import TextualSpinner
 
 # Keep track of all active spinners to manage them globally
 _active_spinners = []
@@ -25,7 +24,16 @@ def unregister_spinner(spinner):
 
 
 def pause_all_spinners():
-    """Pause all active spinners."""
+    """Pause all active spinners.
+
+    No-op when called from a sub-agent context to prevent
+    parallel sub-agents from interfering with the main spinner.
+    """
+    # Lazy import to avoid circular dependency
+    from code_puppy.tools.subagent_context import is_subagent
+
+    if is_subagent():
+        return  # Sub-agents don't control the main spinner
     for spinner in _active_spinners:
         try:
             spinner.pause()
@@ -35,7 +43,16 @@ def pause_all_spinners():
 
 
 def resume_all_spinners():
-    """Resume all active spinners."""
+    """Resume all active spinners.
+
+    No-op when called from a sub-agent context to prevent
+    parallel sub-agents from interfering with the main spinner.
+    """
+    # Lazy import to avoid circular dependency
+    from code_puppy.tools.subagent_context import is_subagent
+
+    if is_subagent():
+        return  # Sub-agents don't control the main spinner
     for spinner in _active_spinners:
         try:
             spinner.resume()
@@ -56,7 +73,6 @@ def clear_spinner_context() -> None:
 
 __all__ = [
     "SpinnerBase",
-    "TextualSpinner",
     "ConsoleSpinner",
     "register_spinner",
     "unregister_spinner",

code_puppy/messaging/spinner/console_spinner.py

@@ -2,6 +2,7 @@
 Console spinner implementation for CLI mode using Rich's Live Display.
 """
 
+import platform
 import threading
 import time
 
@@ -43,12 +44,15 @@ class ConsoleSpinner(SpinnerBase):
         if self._thread and self._thread.is_alive():
             return
 
+        # Print blank line before spinner for visual separation from content
+        self.console.print()
+
         # Create a Live display for the spinner
         self._live = Live(
             self._generate_spinner_panel(),
             console=self.console,
             refresh_per_second=20,
-            transient=True,
+            transient=True,  # Clear the spinner line when stopped (no puppy litter!)
             auto_refresh=False,  # Don't auto-refresh to avoid wiping out user input
         )
         self._live.start()
@@ -75,6 +79,33 @@ class ConsoleSpinner(SpinnerBase):
 
         self._thread = None
 
+        # Windows-specific cleanup: Rich's Live display can leave terminal in corrupted state
+        if platform.system() == "Windows":
+            import sys
+
+            try:
+                # Reset ANSI formatting for both stdout and stderr
+                sys.stdout.write("\x1b[0m")  # Reset all attributes
+                sys.stdout.flush()
+                sys.stderr.write("\x1b[0m")
+                sys.stderr.flush()
+
+                # Clear the line and reposition cursor
+                sys.stdout.write("\r")  # Return to start of line
+                sys.stdout.write("\x1b[K")  # Clear to end of line
+                sys.stdout.flush()
+
+                # Flush keyboard input buffer to clear any stuck keys
+                try:
+                    import msvcrt
+
+                    while msvcrt.kbhit():
+                        msvcrt.getch()
+                except ImportError:
+                    pass  # msvcrt not available (not Windows or different Python impl)
+            except Exception:
+                pass  # Fail silently if cleanup doesn't work
+
         # Unregister this spinner from global management
         from . import unregister_spinner
 
@@ -86,21 +117,16 @@ class ConsoleSpinner(SpinnerBase):
 
     def _generate_spinner_panel(self):
         """Generate a Rich panel containing the spinner text."""
-        if self._paused:
+        # Check if we're awaiting user input - show nothing during input prompts
+        from code_puppy.tools.command_runner import is_awaiting_user_input
+
+        if self._paused or is_awaiting_user_input():
             return Text("")
 
         text = Text()
 
-        # Check if we're awaiting user input to determine which message to show
-        from code_puppy.tools.command_runner import is_awaiting_user_input
-
-        if is_awaiting_user_input():
-            # Show waiting message when waiting for user input
-            text.append(SpinnerBase.WAITING_MESSAGE, style="bold cyan")
-        else:
-            # Show thinking message during normal processing
-            text.append(SpinnerBase.THINKING_MESSAGE, style="bold cyan")
-
+        # Show thinking message during normal processing
+        text.append(SpinnerBase.THINKING_MESSAGE, style="bold cyan")
         text.append(self.current_frame, style="bold cyan")
 
         context_info = SpinnerBase.get_context_info()
@@ -132,39 +158,29 @@ class ConsoleSpinner(SpinnerBase):
                 # Short sleep to control animation speed
                 time.sleep(0.05)
         except Exception as e:
-            print(f"\nSpinner error: {e}")
+            # Note: Using sys.stderr - can't use messaging during spinner
+            import sys
+
+            sys.stderr.write(f"\nSpinner error: {e}\n")
             self._is_spinning = False
 
     def pause(self):
         """Pause the spinner animation."""
         if self._is_spinning:
             self._paused = True
-            # Update the live display to hide the spinner immediately
+            # Stop the live display completely to restore terminal echo during input
             if self._live:
                 try:
-                    # When pausing, first update with the waiting message
-                    # so it's visible briefly before disappearing
-                    from code_puppy.tools.command_runner import is_awaiting_user_input
-
-                    if is_awaiting_user_input():
-                        text = Text()
-                        text.append(SpinnerBase.WAITING_MESSAGE, style="bold cyan")
-                        text.append(self.current_frame, style="bold cyan")
-                        self._live.update(text)
-                        self._live.refresh()
-                        # Allow a moment for the waiting message to be visible
-                        import time
-
-                        time.sleep(0.1)
-
-                    # Then clear the display
-                    self._live.update(Text(""))
+                    self._live.stop()
+                    self._live = None
+                    # Clear the line to remove any artifacts
+                    import sys
+
+                    sys.stdout.write("\r")  # Return to start of line
+                    sys.stdout.write("\x1b[K")  # Clear to end of line
+                    sys.stdout.flush()
                 except Exception:
-                    # If update fails, try stopping it completely
-                    try:
-                        self._live.stop()
-                    except Exception:
-                        pass
+                    pass
 
     def resume(self):
         """Resume the spinner animation."""
@@ -176,24 +192,43 @@ class ConsoleSpinner(SpinnerBase):
 
         if self._is_spinning and self._paused:
             self._paused = False
-            # Force an immediate update to show the spinner again
-            if self._live:
+            # Restart the live display if it was stopped during pause
+            if not self._live:
                 try:
+                    # Clear any leftover artifacts before starting
+                    import sys
+
+                    sys.stdout.write("\r")  # Return to start of line
+                    sys.stdout.write("\x1b[K")  # Clear to end of line
+                    sys.stdout.flush()
+
+                    # Print blank line before spinner for visual separation
+                    self.console.print()
+
+                    self._live = Live(
+                        self._generate_spinner_panel(),
+                        console=self.console,
+                        refresh_per_second=20,
+                        transient=True,  # Clear spinner line when stopped
+                        auto_refresh=False,
+                    )
+                    self._live.start()
+                except Exception:
+                    pass
+            else:
+                # If live display still exists, clear console state first
+                try:
+                    # Force Rich to reset any cached console state
+                    if hasattr(self.console, "_buffer"):
+                        # Clear Rich's internal buffer to prevent artifacts
+                        self.console.file.write("\r")  # Return to start
+                        self.console.file.write("\x1b[K")  # Clear line
+                        self.console.file.flush()
+
                     self._live.update(self._generate_spinner_panel())
+                    self._live.refresh()
                 except Exception:
-                    # If update fails, the live display might have been stopped
-                    # Try to restart it
-                    try:
-                        self._live = Live(
-                            self._generate_spinner_panel(),
-                            console=self.console,
-                            refresh_per_second=10,
-                            transient=True,
-                            auto_refresh=False,  # Don't auto-refresh to avoid wiping out user input
-                        )
-                        self._live.start()
-                    except Exception:
-                        pass
+                    pass
 
     def __enter__(self):
         """Support for context manager."""