code-puppy 0.0.327__tar.gz → 0.0.328__tar.gz

{code_puppy-0.0.327 → code_puppy-0.0.328}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.327
+Version: 0.0.328
 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.327 → code_puppy-0.0.328}/code_puppy/agents/base_agent.py

@@ -75,6 +75,8 @@ 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,
 )
 
@@ -1951,8 +1953,6 @@ 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)
-            import sys
-
             from code_puppy.keymap import get_cancel_agent_display_name
 
             cancel_key = get_cancel_agent_display_name()
@@ -1961,6 +1961,12 @@ 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():
@@ -1968,10 +1974,27 @@ 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(
@@ -2001,6 +2024,9 @@ 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

{code_puppy-0.0.327 → code_puppy-0.0.328}/code_puppy/tools/command_runner.py

@@ -44,9 +44,70 @@ def _truncate_line(line: str) -> str:
 if sys.platform.startswith("win"):
     import msvcrt
 
-    # Load kernel32 for PeekNamedPipe
+    # Load kernel32 for PeekNamedPipe and SetConsoleCtrlHandler
     _kernel32 = ctypes.windll.kernel32
 
+    # SetConsoleCtrlHandler types for Ctrl+C handling on Windows
+    # This is more reliable than signal.SIGINT when running under uvx
+    _CTRL_C_EVENT = 0
+    _CTRL_BREAK_EVENT = 1
+    _HANDLER_ROUTINE = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_ulong)
+
+    # Track registered handlers to prevent garbage collection
+    _registered_console_handlers: list = []
+
+    def _add_windows_ctrl_handler(callback: Callable[[], None]) -> Optional[Callable]:
+        """Register a Windows console control handler for Ctrl+C/Ctrl+Break.
+
+        Args:
+            callback: Function to call when Ctrl+C or Ctrl+Break is pressed.
+                      Should take no arguments.
+
+        Returns:
+            The wrapped handler function (needed for removal), or None if failed.
+        """
+
+        def handler(ctrl_type: int) -> int:
+            if ctrl_type in (_CTRL_C_EVENT, _CTRL_BREAK_EVENT):
+                try:
+                    callback()
+                except Exception:
+                    pass
+                return 1  # TRUE = we handled it, don't pass to next handler
+            return 0  # FALSE = let next handler deal with it
+
+        # Wrap in WINFUNCTYPE to make it callable from C
+        wrapped = _HANDLER_ROUTINE(handler)
+        # Keep reference to prevent GC
+        _registered_console_handlers.append(wrapped)
+
+        try:
+            if _kernel32.SetConsoleCtrlHandler(wrapped, True):
+                return wrapped
+        except Exception:
+            pass
+        return None
+
+    def _remove_windows_ctrl_handler(handler: Callable) -> bool:
+        """Remove a previously registered Windows console control handler.
+
+        Args:
+            handler: The handler returned by _add_windows_ctrl_handler.
+
+        Returns:
+            True if successfully removed, False otherwise.
+        """
+        if handler is None:
+            return False
+        try:
+            result = _kernel32.SetConsoleCtrlHandler(handler, False)
+            # Clean up our reference
+            if handler in _registered_console_handlers:
+                _registered_console_handlers.remove(handler)
+            return bool(result)
+        except Exception:
+            return False
+
     def _win32_pipe_has_data(pipe) -> bool:
         """Check if a Windows pipe has data available without blocking.
 
@@ -87,8 +148,15 @@ if sys.platform.startswith("win"):
         except (ValueError, OSError, ctypes.ArgumentError):
             # Handle closed, invalid, or other errors
             return False
+
 else:
-    # POSIX stub - not used, but keeps the code clean
+    # Non-Windows: provide no-op stubs
+    def _add_windows_ctrl_handler(callback: Callable[[], None]) -> Optional[Callable]:
+        return None
+
+    def _remove_windows_ctrl_handler(handler: Callable) -> bool:
+        return False
+
     def _win32_pipe_has_data(pipe) -> bool:
         return False
 
@@ -106,6 +174,7 @@ _USER_KILLED_PROCESSES = set()
 _SHELL_CTRL_X_STOP_EVENT: Optional[threading.Event] = None
 _SHELL_CTRL_X_THREAD: Optional[threading.Thread] = None
 _ORIGINAL_SIGINT_HANDLER = None
+_WINDOWS_CTRL_HANDLER = None  # For SetConsoleCtrlHandler on Windows
 
 # Stop event to signal reader threads to terminate
 _READER_STOP_EVENT: Optional[threading.Event] = None
@@ -435,8 +504,10 @@ def _shell_command_keyboard_context():
     1. Disables the agent's Ctrl-C handler (so it doesn't cancel the agent)
     2. Enables a Ctrl-X listener to kill the running shell process
     3. Restores the original Ctrl-C handler when done
+    4. On Windows, uses SetConsoleCtrlHandler for reliable Ctrl+C with uvx
     """
     global _SHELL_CTRL_X_STOP_EVENT, _SHELL_CTRL_X_THREAD, _ORIGINAL_SIGINT_HANDLER
+    global _WINDOWS_CTRL_HANDLER
 
     # Handler for Ctrl-X: kill all running shell processes
     def handle_ctrl_x_press() -> None:
@@ -444,11 +515,15 @@ def _shell_command_keyboard_context():
         kill_all_running_shell_processes()
 
     # Handler for Ctrl-C during shell execution: just kill the shell process, don't cancel agent
-    def shell_sigint_handler(_sig, _frame):
+    def shell_ctrl_c_callback():
         """During shell execution, Ctrl-C kills the shell but doesn't cancel the agent."""
         emit_warning("\n🛑 Ctrl-C detected! Interrupting shell command...")
         kill_all_running_shell_processes()
 
+    def shell_sigint_handler(_sig, _frame):
+        """Signal handler wrapper for SIGINT."""
+        shell_ctrl_c_callback()
+
     # Set up Ctrl-X listener
     _SHELL_CTRL_X_STOP_EVENT = threading.Event()
     _SHELL_CTRL_X_THREAD = _spawn_ctrl_x_key_listener(
@@ -456,7 +531,12 @@ def _shell_command_keyboard_context():
         handle_ctrl_x_press,
     )
 
-    # Replace SIGINT handler temporarily
+    # On Windows, use SetConsoleCtrlHandler for reliable Ctrl+C handling
+    # This works even when running under uvx where SIGINT doesn't propagate properly
+    if sys.platform.startswith("win"):
+        _WINDOWS_CTRL_HANDLER = _add_windows_ctrl_handler(shell_ctrl_c_callback)
+
+    # Also set SIGINT handler (works on POSIX, may work on some Windows setups)
     try:
         _ORIGINAL_SIGINT_HANDLER = signal.signal(signal.SIGINT, shell_sigint_handler)
     except (ValueError, OSError):
@@ -476,6 +556,10 @@ def _shell_command_keyboard_context():
             except Exception:
                 pass
 
+        # Remove Windows console handler
+        if _WINDOWS_CTRL_HANDLER is not None:
+            _remove_windows_ctrl_handler(_WINDOWS_CTRL_HANDLER)
+
         # Restore original SIGINT handler
         if _ORIGINAL_SIGINT_HANDLER is not None:
             try:
@@ -487,6 +571,7 @@ def _shell_command_keyboard_context():
         _SHELL_CTRL_X_STOP_EVENT = None
         _SHELL_CTRL_X_THREAD = None
         _ORIGINAL_SIGINT_HANDLER = None
+        _WINDOWS_CTRL_HANDLER = None
 
 
 def run_shell_command_streaming(

{code_puppy-0.0.327 → code_puppy-0.0.328}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.327"
+version = "0.0.328"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"