code-puppy 0.0.169__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()
@@ -44,12 +61,23 @@ def resume_all_spinners():
             pass
 
 
+def update_spinner_context(info: str) -> None:
+    """Update the shared context information displayed beside active spinners."""
+    SpinnerBase.set_context_info(info)
+
+
+def clear_spinner_context() -> None:
+    """Clear any context information displayed beside active spinners."""
+    SpinnerBase.clear_context_info()
+
+
 __all__ = [
     "SpinnerBase",
-    "TextualSpinner",
     "ConsoleSpinner",
     "register_spinner",
     "unregister_spinner",
     "pause_all_spinners",
     "resume_all_spinners",
+    "update_spinner_context",
+    "clear_spinner_context",
 ]

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=10,
-            transient=True,
+            refresh_per_second=20,
+            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,23 +117,23 @@ 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()
+        if context_info:
+            text.append(" ")
+            text.append(context_info, style="bold white")
+
         # Return a simple Text object instead of a Panel for a cleaner look
         return text
 
@@ -127,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."""
@@ -171,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."""

code_puppy/messaging/spinner/spinner_base.py

@@ -3,6 +3,7 @@ Base spinner implementation to be extended for different UI modes.
 """
 
 from abc import ABC, abstractmethod
+from threading import Lock
 
 from code_puppy.config import get_puppy_name
 
@@ -33,6 +34,9 @@ class SpinnerBase(ABC):
     # Current message - starts with thinking by default
     MESSAGE = THINKING_MESSAGE
 
+    _context_info: str = ""
+    _context_lock: Lock = Lock()
+
     def __init__(self):
         """Initialize the spinner."""
         self._is_spinning = False
@@ -64,3 +68,28 @@ class SpinnerBase(ABC):
     def is_spinning(self):
         """Check if the spinner is currently spinning."""
         return self._is_spinning
+
+    @classmethod
+    def set_context_info(cls, info: str) -> None:
+        """Set shared context information displayed beside the spinner."""
+        with cls._context_lock:
+            cls._context_info = info
+
+    @classmethod
+    def clear_context_info(cls) -> None:
+        """Clear any context information displayed beside the spinner."""
+        cls.set_context_info("")
+
+    @classmethod
+    def get_context_info(cls) -> str:
+        """Return the current spinner context information."""
+        with cls._context_lock:
+            return cls._context_info
+
+    @staticmethod
+    def format_context_info(total_tokens: int, capacity: int, proportion: float) -> str:
+        """Create a concise context summary for spinner display."""
+        if capacity <= 0:
+            return ""
+        proportion_pct = proportion * 100
+        return f"Tokens: {total_tokens:,}/{capacity:,} ({proportion_pct:.1f}% used)"