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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.326
+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
@@ -100,6 +100,8 @@ uvx code-puppy -i
 
 ### UV (Recommended)
 
+#### macOS / Linux
+
 ```bash
 # Install UV if you don't have it
 curl -LsSf https://astral.sh/uv/install.sh | sh
@@ -112,6 +114,33 @@ source ~/.zshrc  # or ~/.bashrc
 uvx code-puppy -i
 ```
 
+#### Windows
+
+On Windows, we recommend installing code-puppy as a global tool for the best experience with keyboard shortcuts (Ctrl+C/Ctrl+X cancellation):
+
+```powershell
+# Install UV if you don't have it (run in PowerShell as Admin)
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+# Install code-puppy as a global tool
+uv tool install code-puppy
+
+# Run code-puppy
+code-puppy -i
+```
+
+**Why `uv tool install` on Windows?** Running with `uvx` creates an extra process layer that can interfere with keyboard signal handling (Ctrl+C, Ctrl+X). Installing as a tool runs code-puppy directly for reliable cancellation.
+
+#### Upgrading
+
+```bash
+# Upgrade code-puppy to the latest version
+uv tool upgrade code-puppy
+
+# Or upgrade all installed tools
+uv tool upgrade --all
+```
+
 UV will automatically download the latest compatible Python version (3.11+) if your system doesn't have one.
 
 ### pip (Alternative)

{code_puppy-0.0.326 → code_puppy-0.0.328}/README.md

@@ -61,6 +61,8 @@ uvx code-puppy -i
 
 ### UV (Recommended)
 
+#### macOS / Linux
+
 ```bash
 # Install UV if you don't have it
 curl -LsSf https://astral.sh/uv/install.sh | sh
@@ -73,6 +75,33 @@ source ~/.zshrc  # or ~/.bashrc
 uvx code-puppy -i
 ```
 
+#### Windows
+
+On Windows, we recommend installing code-puppy as a global tool for the best experience with keyboard shortcuts (Ctrl+C/Ctrl+X cancellation):
+
+```powershell
+# Install UV if you don't have it (run in PowerShell as Admin)
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+# Install code-puppy as a global tool
+uv tool install code-puppy
+
+# Run code-puppy
+code-puppy -i
+```
+
+**Why `uv tool install` on Windows?** Running with `uvx` creates an extra process layer that can interfere with keyboard signal handling (Ctrl+C, Ctrl+X). Installing as a tool runs code-puppy directly for reliable cancellation.
+
+#### Upgrading
+
+```bash
+# Upgrade code-puppy to the latest version
+uv tool upgrade code-puppy
+
+# Or upgrade all installed tools
+uv tool upgrade --all
+```
+
 UV will automatically download the latest compatible Python version (3.11+) if your system doesn't have one.
 
 ### pip (Alternative)

{code_puppy-0.0.326 → 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.326 → code_puppy-0.0.328}/code_puppy/command_line/config_commands.py

@@ -46,6 +46,7 @@ def handle_show_command(command: str) -> bool:
         get_use_dbos,
         get_yolo_mode,
     )
+    from code_puppy.keymap import get_cancel_agent_key, get_cancel_agent_display_name
     from code_puppy.messaging import emit_info
 
     puppy_name = get_puppy_name()
@@ -79,6 +80,7 @@ def handle_show_command(command: str) -> bool:
 [bold]reasoning_effort:[/bold]      [cyan]{get_openai_reasoning_effort()}[/cyan]
 [bold]verbosity:[/bold]             [cyan]{get_openai_verbosity()}[/cyan]
 [bold]temperature:[/bold]           [cyan]{effective_temperature if effective_temperature is not None else "(model default)"}[/cyan]{" (per-model)" if effective_temperature != global_temperature and effective_temperature is not None else ""}
+[bold]cancel_agent_key:[/bold]      [cyan]{get_cancel_agent_display_name()}[/cyan] (options: ctrl+c, ctrl+k, ctrl+q)
 
 """
     emit_info(Text.from_markup(status_msg))
@@ -200,9 +202,13 @@ def handle_set_command(command: str) -> bool:
             "\n[yellow]Session Management[/yellow]"
             "\n  [cyan]auto_save_session[/cyan]    Auto-save chat after every response (true/false)"
         )
+        keymap_help = (
+            "\n[yellow]Keyboard Shortcuts[/yellow]"
+            "\n  [cyan]cancel_agent_key[/cyan]     Key to cancel agent tasks (ctrl+c, ctrl+k, or ctrl+q)"
+        )
         emit_warning(
             Text.from_markup(
-                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(config_keys)}\n[dim]Note: compaction_strategy can be 'summarization' or 'truncation'[/dim]{session_help}"
+                f"Usage: /set KEY=VALUE or /set KEY VALUE\nConfig keys: {', '.join(config_keys)}\n[dim]Note: compaction_strategy can be 'summarization' or 'truncation'[/dim]{session_help}{keymap_help}"
             )
         )
         return True
@@ -215,6 +221,23 @@ def handle_set_command(command: str) -> bool:
                 )
             )
 
+        # Validate cancel_agent_key before setting
+        if key == "cancel_agent_key":
+            from code_puppy.keymap import VALID_CANCEL_KEYS
+
+            normalized_value = value.strip().lower()
+            if normalized_value not in VALID_CANCEL_KEYS:
+                emit_error(
+                    f"Invalid cancel_agent_key '{value}'. Valid options: {', '.join(sorted(VALID_CANCEL_KEYS))}"
+                )
+                return True
+            value = normalized_value  # Use normalized value
+            emit_info(
+                Text.from_markup(
+                    "[yellow]⚠️ cancel_agent_key changed. Please restart Code Puppy for this change to take effect.[/yellow]"
+                )
+            )
+
         set_config_value(key, value)
         emit_success(f'Set {key} = "{value}" in puppy.cfg!')
 

{code_puppy-0.0.326 → 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.326 → code_puppy-0.0.328}/pyproject.toml

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