code-puppy 0.0.332__tar.gz → 0.0.333__tar.gz

{code_puppy-0.0.332 → code_puppy-0.0.333}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.332
+Version: 0.0.333
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.332 → code_puppy-0.0.333}/code_puppy/agents/base_agent.py

@@ -75,8 +75,6 @@ from code_puppy.model_factory import ModelFactory, make_model_settings
 from code_puppy.summarization_agent import run_summarization_sync
 from code_puppy.tools.agent_tools import _active_subagent_tasks
 from code_puppy.tools.command_runner import (
-    _add_windows_ctrl_handler,
-    _remove_windows_ctrl_handler,
     is_awaiting_user_input,
 )
 
@@ -1384,15 +1382,14 @@ class BaseAgent(ABC):
         def _print_thinking_banner() -> None:
             """Print the THINKING banner with spinner pause and line clear."""
             nonlocal did_stream_anything
-            import sys
             import time
 
             from code_puppy.config import get_banner_color
 
             pause_all_spinners()
             time.sleep(0.1)  # Delay to let spinner fully clear
-            sys.stdout.write("\r\x1b[K")  # Clear line
-            sys.stdout.flush()
+            # Clear line and print newline before banner
+            console.print(" " * 50, end="\r")
             console.print()  # Newline before banner
             # Bold banner with configurable color and lightning bolt
             thinking_color = get_banner_color("thinking")
@@ -1402,21 +1399,19 @@ class BaseAgent(ABC):
                 ),
                 end="",
             )
-            sys.stdout.flush()
             did_stream_anything = True
 
         def _print_response_banner() -> None:
             """Print the AGENT RESPONSE banner with spinner pause and line clear."""
             nonlocal did_stream_anything
-            import sys
             import time
 
             from code_puppy.config import get_banner_color
 
             pause_all_spinners()
             time.sleep(0.1)  # Delay to let spinner fully clear
-            sys.stdout.write("\r\x1b[K")  # Clear line
-            sys.stdout.flush()
+            # Clear line and print newline before banner
+            console.print(" " * 50, end="\r")
             console.print()  # Newline before banner
             response_color = get_banner_color("agent_response")
             console.print(
@@ -1424,7 +1419,6 @@ class BaseAgent(ABC):
                     f"[bold white on {response_color}] AGENT RESPONSE [/bold white on {response_color}]"
                 )
             )
-            sys.stdout.flush()
             did_stream_anything = True
 
         async for event in events:
@@ -1448,8 +1442,8 @@ class BaseAgent(ABC):
                     # Buffer initial content if present
                     if part.content and part.content.strip():
                         text_buffer[event.index].append(part.content)
-                        # Use len(content) / 3 for token estimation (more accurate than chunk counting)
-                        token_count[event.index] += len(part.content) // 3
+                        # Count chunks (each part counts as 1)
+                        token_count[event.index] += 1
                 elif isinstance(part, ToolCallPart):
                     streaming_parts.add(event.index)
                     tool_parts.add(event.index)
@@ -1467,24 +1461,20 @@ class BaseAgent(ABC):
                         if delta.content_delta:
                             # For text parts, show token counter then render at end
                             if event.index in text_parts:
-                                import sys
-
                                 # Print banner on first content
                                 if event.index not in banner_printed:
                                     _print_response_banner()
                                     banner_printed.add(event.index)
                                 # Accumulate text for final markdown render
                                 text_buffer[event.index].append(delta.content_delta)
-                                # Use len(content) / 3 for token estimation
-                                token_count[event.index] += (
-                                    len(delta.content_delta) // 3
-                                )
-                                # Update token counter in place (single line)
+                                # Count chunks received
+                                token_count[event.index] += 1
+                                # Update chunk counter in place (single line)
                                 count = token_count[event.index]
-                                sys.stdout.write(
-                                    f"\r\x1b[K  ⏳ Receiving... {count} tokens"
+                                console.print(
+                                    f"  ⏳ Receiving... {count} chunks   ",
+                                    end="\r",
                                 )
-                                sys.stdout.flush()
                             else:
                                 # For thinking parts, stream immediately (dim)
                                 if event.index not in banner_printed:
@@ -1493,34 +1483,30 @@ class BaseAgent(ABC):
                                 escaped = escape(delta.content_delta)
                                 console.print(f"[dim]{escaped}[/dim]", end="")
                     elif isinstance(delta, ToolCallPartDelta):
-                        import sys
-
-                        # For tool calls, show token counter (use string repr for estimation)
-                        token_count[event.index] += len(str(delta)) // 3
+                        # For tool calls, count chunks received
+                        token_count[event.index] += 1
                         # Get tool name if available
                         tool_name = getattr(delta, "tool_name_delta", "")
                         count = token_count[event.index]
                         # Display with tool wrench icon and tool name
                         if tool_name:
-                            sys.stdout.write(
-                                f"\r\x1b[K  🔧 Calling {tool_name}... {count} tokens"
+                            console.print(
+                                f"  🔧 Calling {tool_name}... {count} chunks   ",
+                                end="\r",
                             )
                         else:
-                            sys.stdout.write(
-                                f"\r\x1b[K  🔧 Calling tool... {count} tokens"
+                            console.print(
+                                f"  🔧 Calling tool... {count} chunks   ",
+                                end="\r",
                             )
-                        sys.stdout.flush()
 
             # PartEndEvent - finish the streaming with a newline
             elif isinstance(event, PartEndEvent):
                 if event.index in streaming_parts:
-                    import sys
-
                     # For text parts, clear counter line and render markdown
                     if event.index in text_parts:
-                        # Clear the token counter line
-                        sys.stdout.write("\r\x1b[K")
-                        sys.stdout.flush()
+                        # Clear the chunk counter line by printing spaces and returning
+                        console.print(" " * 50, end="\r")
                         # Render the final markdown nicely
                         if event.index in text_buffer:
                             try:
@@ -1530,11 +1516,10 @@ class BaseAgent(ABC):
                             except Exception:
                                 pass
                             del text_buffer[event.index]
-                    # For tool parts, clear the token counter line
+                    # For tool parts, clear the chunk counter line
                     elif event.index in tool_parts:
-                        # Clear the token counter line
-                        sys.stdout.write("\r\x1b[K")
-                        sys.stdout.flush()
+                        # Clear the chunk counter line by printing spaces and returning
+                        console.print(" " * 50, end="\r")
                     # For thinking parts, just print newline
                     elif event.index in banner_printed:
                         console.print()  # Final newline after streaming
@@ -1953,7 +1938,12 @@ class BaseAgent(ABC):
         def graceful_sigint_handler(_sig, _frame):
             # When using keyboard-based cancel, SIGINT should be a no-op
             # (just show a hint to user about the configured cancel key)
+            # Also reset terminal to prevent bricking on Windows+uvx
             from code_puppy.keymap import get_cancel_agent_display_name
+            from code_puppy.terminal_utils import reset_windows_terminal_full
+
+            # Reset terminal state first to prevent bricking
+            reset_windows_terminal_full()
 
             cancel_key = get_cancel_agent_display_name()
             emit_info(f"Use {cancel_key} to cancel the agent task.")
@@ -1961,12 +1951,6 @@ class BaseAgent(ABC):
         original_handler = None
         key_listener_stop_event = None
         _key_listener_thread = None
-        windows_ctrl_handler = None
-
-        # Check if we're on Windows
-        import sys
-
-        is_windows = sys.platform.startswith("win")
 
         try:
             if cancel_agent_uses_signal():
@@ -1974,27 +1958,10 @@ class BaseAgent(ABC):
                 original_handler = signal.signal(
                     signal.SIGINT, keyboard_interrupt_handler
                 )
-                # On Windows, also use SetConsoleCtrlHandler for reliable Ctrl+C with uvx
-                if is_windows:
-                    windows_ctrl_handler = _add_windows_ctrl_handler(
-                        schedule_agent_cancel
-                    )
             else:
                 # Use keyboard listener for agent cancellation
                 # Set a graceful SIGINT handler that shows a hint
                 original_handler = signal.signal(signal.SIGINT, graceful_sigint_handler)
-                # On Windows, SetConsoleCtrlHandler should also show the hint
-                if is_windows:
-
-                    def graceful_ctrl_handler():
-                        from code_puppy.keymap import get_cancel_agent_display_name
-
-                        cancel_key = get_cancel_agent_display_name()
-                        emit_info(f"Use {cancel_key} to cancel the agent task.")
-
-                    windows_ctrl_handler = _add_windows_ctrl_handler(
-                        graceful_ctrl_handler
-                    )
                 # Spawn keyboard listener with the cancel agent callback
                 key_listener_stop_event = threading.Event()
                 _key_listener_thread = self._spawn_ctrl_x_key_listener(
@@ -2024,17 +1991,8 @@ class BaseAgent(ABC):
             # Stop keyboard listener if it was started
             if key_listener_stop_event is not None:
                 key_listener_stop_event.set()
-            # Remove Windows console handler
-            if windows_ctrl_handler is not None:
-                _remove_windows_ctrl_handler(windows_ctrl_handler)
             # Restore original signal handler
             if (
                 original_handler is not None
             ):  # Explicit None check - SIG_DFL can be 0/falsy!
                 signal.signal(signal.SIGINT, original_handler)
-            # Windows-specific: Reset terminal after Ctrl+C to prevent corruption
-            # This fixes the issue where Enter key shows as 'm' after interrupting with uvx
-            if is_windows:
-                from code_puppy.terminal_utils import reset_windows_terminal_full
-
-                reset_windows_terminal_full()

{code_puppy-0.0.332 → code_puppy-0.0.333}/code_puppy/cli_runner.py

@@ -171,6 +171,45 @@ async def main():
         emit_error(str(e))
         sys.exit(1)
 
+    # Show uvx detection notice if we're on Windows + uvx
+    # Also disable Ctrl+C at the console level to prevent terminal bricking
+    try:
+        from code_puppy.uvx_detection import should_use_alternate_cancel_key
+
+        if should_use_alternate_cancel_key():
+            from code_puppy.terminal_utils import (
+                disable_windows_ctrl_c,
+                set_keep_ctrl_c_disabled,
+            )
+
+            # Disable Ctrl+C at the console input level
+            # This prevents Ctrl+C from being processed as a signal at all
+            disable_windows_ctrl_c()
+
+            # Set flag to keep it disabled (prompt_toolkit may re-enable it)
+            set_keep_ctrl_c_disabled(True)
+
+            # Use print directly - emit_system_message can get cleared by ANSI codes
+            print(
+                "🔧 Detected uvx launch on Windows - using Ctrl+K for cancellation "
+                "(Ctrl+C is disabled to prevent terminal issues)"
+            )
+
+            # Also install a SIGINT handler as backup
+            import signal
+
+            from code_puppy.terminal_utils import reset_windows_terminal_full
+
+            def _uvx_protective_sigint_handler(_sig, _frame):
+                """Protective SIGINT handler for Windows+uvx."""
+                reset_windows_terminal_full()
+                # Re-disable Ctrl+C in case something re-enabled it
+                disable_windows_ctrl_c()
+
+            signal.signal(signal.SIGINT, _uvx_protective_sigint_handler)
+    except ImportError:
+        pass  # uvx_detection module not available, ignore
+
     # Load API keys from puppy.cfg into environment variables
     from code_puppy.config import load_api_keys_to_environment
 
@@ -421,10 +460,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     current_agent_task = None
 
     while True:
-        # Windows-specific: Aggressively reset terminal at the start of every loop
-        # This fixes terminal corruption after Ctrl+C, especially when running via uvx
-        reset_windows_terminal_full()
-
         from code_puppy.agents.agent_manager import get_current_agent
         from code_puppy.messaging import emit_info
 
@@ -444,6 +479,15 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 task = await get_input_with_combined_completion(
                     get_prompt_with_active_model(), history_file=COMMAND_HISTORY_FILE
                 )
+
+                # Windows+uvx: Re-disable Ctrl+C after prompt_toolkit
+                # (prompt_toolkit restores console mode which re-enables Ctrl+C)
+                try:
+                    from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+
+                    ensure_ctrl_c_disabled()
+                except ImportError:
+                    pass
             except ImportError:
                 # Fall back to basic input if prompt_toolkit is not available
                 task = input(">>> ")
@@ -608,8 +652,14 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 # Check if the task was cancelled (but don't show message if we just killed processes)
                 if result is None:
                     # Windows-specific: Reset terminal state after cancellation
-                    # Use full reset (ANSI + console mode) to fix stdin after Ctrl+C
-                    reset_windows_terminal_full()
+                    reset_windows_terminal_ansi()
+                    # Re-disable Ctrl+C if needed (uvx mode)
+                    try:
+                        from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+
+                        ensure_ctrl_c_disabled()
+                    except ImportError:
+                        pass
                     continue
                 # Get the structured response
                 agent_response = result.output
@@ -650,6 +700,15 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
             auto_save_session_if_enabled()
 
+            # Re-disable Ctrl+C if needed (uvx mode) - must be done after
+            # each iteration as various operations may restore console mode
+            try:
+                from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+
+                ensure_ctrl_c_disabled()
+            except ImportError:
+                pass
+
 
 def prettier_code_blocks():
     """Configure Rich to use prettier code block rendering."""

{code_puppy-0.0.332 → code_puppy-0.0.333}/code_puppy/keymap.py

@@ -55,11 +55,19 @@ class KeymapError(Exception):
 def get_cancel_agent_key() -> str:
     """Get the configured cancel agent key from config.
 
+    On Windows when launched via uvx, this automatically returns "ctrl+k"
+    to work around uvx capturing Ctrl+C before it reaches Python.
+
     Returns:
         The key name (e.g., "ctrl+c", "ctrl+k") from config,
         or the default if not configured.
     """
     from code_puppy.config import get_value
+    from code_puppy.uvx_detection import should_use_alternate_cancel_key
+
+    # On Windows + uvx, force ctrl+k to bypass uvx's SIGINT capture
+    if should_use_alternate_cancel_key():
+        return "ctrl+k"
 
     key = get_value("cancel_agent_key")
     if key is None or key.strip() == "":

code_puppy-0.0.333/code_puppy/terminal_utils.py

@@ -0,0 +1,291 @@
+"""Terminal utilities for cross-platform terminal state management.
+
+Handles Windows console mode resets and Unix terminal sanity restoration.
+"""
+
+import platform
+import subprocess
+import sys
+from typing import Callable, Optional
+
+# Store the original console ctrl handler so we can restore it if needed
+_original_ctrl_handler: Optional[Callable] = None
+
+
+def reset_windows_terminal_ansi() -> None:
+    """Reset ANSI formatting on Windows stdout/stderr.
+
+    This is a lightweight reset that just clears ANSI escape sequences.
+    Use this for quick resets after output operations.
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        sys.stdout.write("\x1b[0m")  # Reset ANSI formatting
+        sys.stdout.flush()
+        sys.stderr.write("\x1b[0m")
+        sys.stderr.flush()
+    except Exception:
+        pass  # Silently ignore errors - best effort reset
+
+
+def reset_windows_console_mode() -> None:
+    """Full Windows console mode reset using ctypes.
+
+    This resets both stdout and stdin console modes to restore proper
+    terminal behavior after interrupts (Ctrl+C, Ctrl+D). Without this,
+    the terminal can become unresponsive (can't type characters).
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Reset stdout
+        STD_OUTPUT_HANDLE = -11
+        handle = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+
+        # Enable virtual terminal processing and line input
+        mode = ctypes.c_ulong()
+        kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+
+        # Console mode flags for stdout
+        ENABLE_PROCESSED_OUTPUT = 0x0001
+        ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+        ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+        new_mode = (
+            mode.value
+            | ENABLE_PROCESSED_OUTPUT
+            | ENABLE_WRAP_AT_EOL_OUTPUT
+            | ENABLE_VIRTUAL_TERMINAL_PROCESSING
+        )
+        kernel32.SetConsoleMode(handle, new_mode)
+
+        # Reset stdin
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Console mode flags for stdin
+        ENABLE_LINE_INPUT = 0x0002
+        ENABLE_ECHO_INPUT = 0x0004
+        ENABLE_PROCESSED_INPUT = 0x0001
+
+        stdin_mode = ctypes.c_ulong()
+        kernel32.GetConsoleMode(stdin_handle, ctypes.byref(stdin_mode))
+
+        new_stdin_mode = (
+            stdin_mode.value
+            | ENABLE_LINE_INPUT
+            | ENABLE_ECHO_INPUT
+            | ENABLE_PROCESSED_INPUT
+        )
+        kernel32.SetConsoleMode(stdin_handle, new_stdin_mode)
+
+    except Exception:
+        pass  # Silently ignore errors - best effort reset
+
+
+def flush_windows_keyboard_buffer() -> None:
+    """Flush the Windows keyboard buffer.
+
+    Clears any pending keyboard input that could interfere with
+    subsequent input operations after an interrupt.
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        import msvcrt
+
+        while msvcrt.kbhit():
+            msvcrt.getch()
+    except Exception:
+        pass  # Silently ignore errors - best effort flush
+
+
+def reset_windows_terminal_full() -> None:
+    """Perform a full Windows terminal reset (ANSI + console mode + keyboard buffer).
+
+    Combines ANSI reset, console mode reset, and keyboard buffer flush
+    for complete terminal state restoration after interrupts.
+    """
+    if platform.system() != "Windows":
+        return
+
+    reset_windows_terminal_ansi()
+    reset_windows_console_mode()
+    flush_windows_keyboard_buffer()
+
+
+def reset_unix_terminal() -> None:
+    """Reset Unix/Linux/macOS terminal to sane state.
+
+    Uses the `reset` command to restore terminal sanity.
+    Silently fails if the command isn't available.
+    """
+    if platform.system() == "Windows":
+        return
+
+    try:
+        subprocess.run(["reset"], check=True, capture_output=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass  # Silently fail if reset command isn't available
+
+
+def reset_terminal() -> None:
+    """Cross-platform terminal reset.
+
+    Automatically detects the platform and performs the appropriate
+    terminal reset operation.
+    """
+    if platform.system() == "Windows":
+        reset_windows_terminal_full()
+    else:
+        reset_unix_terminal()
+
+
+def disable_windows_ctrl_c() -> bool:
+    """Disable Ctrl+C processing at the Windows console input level.
+
+    This removes ENABLE_PROCESSED_INPUT from stdin, which prevents
+    Ctrl+C from being interpreted as a signal at all. Instead, it
+    becomes just a regular character (^C) that gets ignored.
+
+    This is more reliable than SetConsoleCtrlHandler because it
+    prevents Ctrl+C from being processed before it reaches any handler.
+
+    Returns:
+        True if successfully disabled, False otherwise.
+    """
+    global _original_ctrl_handler
+
+    if platform.system() != "Windows":
+        return False
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Get current console mode
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+
+        # Save original mode for potential restoration
+        _original_ctrl_handler = mode.value
+
+        # Console mode flags
+        ENABLE_PROCESSED_INPUT = 0x0001  # This makes Ctrl+C generate signals
+
+        # Remove ENABLE_PROCESSED_INPUT to disable Ctrl+C signal generation
+        new_mode = mode.value & ~ENABLE_PROCESSED_INPUT
+
+        if kernel32.SetConsoleMode(stdin_handle, new_mode):
+            return True
+        return False
+
+    except Exception:
+        return False
+
+
+def enable_windows_ctrl_c() -> bool:
+    """Re-enable Ctrl+C at the Windows console level.
+
+    Restores the original console mode saved by disable_windows_ctrl_c().
+
+    Returns:
+        True if successfully re-enabled, False otherwise.
+    """
+    global _original_ctrl_handler
+
+    if platform.system() != "Windows":
+        return False
+
+    if _original_ctrl_handler is None:
+        return True  # Nothing to restore
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Restore original mode
+        if kernel32.SetConsoleMode(stdin_handle, _original_ctrl_handler):
+            _original_ctrl_handler = None
+            return True
+        return False
+
+    except Exception:
+        return False
+
+
+# Flag to track if we should keep Ctrl+C disabled
+_keep_ctrl_c_disabled: bool = False
+
+
+def set_keep_ctrl_c_disabled(value: bool) -> None:
+    """Set whether Ctrl+C should be kept disabled.
+
+    When True, ensure_ctrl_c_disabled() will re-disable Ctrl+C
+    even if something else (like prompt_toolkit) re-enables it.
+    """
+    global _keep_ctrl_c_disabled
+    _keep_ctrl_c_disabled = value
+
+
+def ensure_ctrl_c_disabled() -> bool:
+    """Ensure Ctrl+C is disabled if it should be.
+
+    Call this after operations that might restore console mode
+    (like prompt_toolkit input).
+
+    Returns:
+        True if Ctrl+C is now disabled (or wasn't needed), False on error.
+    """
+    if not _keep_ctrl_c_disabled:
+        return True
+
+    if platform.system() != "Windows":
+        return True
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Get current console mode
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+
+        # Console mode flags
+        ENABLE_PROCESSED_INPUT = 0x0001
+
+        # Check if Ctrl+C processing is enabled
+        if mode.value & ENABLE_PROCESSED_INPUT:
+            # Disable it
+            new_mode = mode.value & ~ENABLE_PROCESSED_INPUT
+            return bool(kernel32.SetConsoleMode(stdin_handle, new_mode))
+
+        return True  # Already disabled
+
+    except Exception:
+        return False