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

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

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

@@ -4,7 +4,6 @@ import asyncio
 import json
 import math
 import signal
-import sys
 import threading
 import uuid
 from abc import ABC, abstractmethod
@@ -1957,69 +1956,27 @@ class BaseAgent(ABC):
             from code_puppy.keymap import get_cancel_agent_display_name
 
             cancel_key = get_cancel_agent_display_name()
-            if sys.platform == "win32":
-                # On Windows, we use keyboard listener, so SIGINT might still fire
-                # but we handle cancellation via the key listener
-                pass  # Silent on Windows - the key listener handles it
-            else:
-                emit_info(f"Use {cancel_key} to cancel the agent task.")
+            emit_info(f"Use {cancel_key} to cancel the agent task.")
 
         original_handler = None
         key_listener_stop_event = None
         _key_listener_thread = None
-        _windows_ctrl_handler = None  # Store reference to prevent garbage collection
 
         try:
-            if sys.platform == "win32":
-                # Windows: Use SetConsoleCtrlHandler for reliable Ctrl+C handling
-                import ctypes
-
-                # Define the handler function type
-                HANDLER_ROUTINE = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_ulong)
-
-                def windows_ctrl_handler(ctrl_type):
-                    """Handle Windows console control events."""
-                    CTRL_C_EVENT = 0
-                    CTRL_BREAK_EVENT = 1
-
-                    if ctrl_type in (CTRL_C_EVENT, CTRL_BREAK_EVENT):
-                        # Check if we're awaiting user input
-                        if is_awaiting_user_input():
-                            return False  # Let default handler run
-
-                        # Schedule agent cancellation
-                        schedule_agent_cancel()
-                        return True  # We handled it, don't terminate
-
-                    return False  # Let other handlers process it
-
-                # Create the callback - must keep reference alive!
-                _windows_ctrl_handler = HANDLER_ROUTINE(windows_ctrl_handler)
-
-                # Register the handler
-                kernel32 = ctypes.windll.kernel32
-                if not kernel32.SetConsoleCtrlHandler(_windows_ctrl_handler, True):
-                    emit_warning("Failed to set Windows Ctrl+C handler")
-
-                # Also spawn keyboard listener for Ctrl+X (shell cancel) and other keys
-                key_listener_stop_event = threading.Event()
-                _key_listener_thread = self._spawn_ctrl_x_key_listener(
-                    key_listener_stop_event,
-                    on_escape=lambda: None,  # Ctrl+X handled by command_runner
-                    on_cancel_agent=None,  # Ctrl+C handled by SetConsoleCtrlHandler above
-                )
-            elif cancel_agent_uses_signal():
-                # Unix with Ctrl+C: Use SIGINT-based cancellation
+            if cancel_agent_uses_signal():
+                # Use SIGINT-based cancellation (default Ctrl+C behavior)
                 original_handler = signal.signal(
                     signal.SIGINT, keyboard_interrupt_handler
                 )
             else:
-                # Unix with different cancel key: Use keyboard listener
+                # Use keyboard listener for agent cancellation
+                # Set a graceful SIGINT handler that shows a hint
                 original_handler = signal.signal(signal.SIGINT, graceful_sigint_handler)
+                # Spawn keyboard listener with the cancel agent callback
                 key_listener_stop_event = threading.Event()
                 _key_listener_thread = self._spawn_ctrl_x_key_listener(
                     key_listener_stop_event,
-                    on_escape=lambda: None,
+                    on_escape=lambda: None,  # Ctrl+X handled by command_runner
                     on_cancel_agent=schedule_agent_cancel,
                 )
 
@@ -2044,17 +2001,8 @@ class BaseAgent(ABC):
             # Stop keyboard listener if it was started
             if key_listener_stop_event is not None:
                 key_listener_stop_event.set()
-
-            # Unregister Windows Ctrl handler
-            if sys.platform == "win32" and _windows_ctrl_handler is not None:
-                try:
-                    import ctypes
-
-                    kernel32 = ctypes.windll.kernel32
-                    kernel32.SetConsoleCtrlHandler(_windows_ctrl_handler, False)
-                except Exception:
-                    pass  # Best effort cleanup
-
-            # Restore original signal handler (Unix)
-            if original_handler is not None:
+            # 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)

{code_puppy-0.0.325 → code_puppy-0.0.327}/code_puppy/cli_runner.py

@@ -790,6 +790,5 @@ def main_entry():
             DBOS.destroy()
         return 0
     finally:
-        # Reset terminal on all platforms for clean state
-        reset_windows_terminal_full()  # Safe no-op on non-Windows
+        # Reset terminal on Unix-like systems (not Windows)
         reset_unix_terminal()

{code_puppy-0.0.325 → code_puppy-0.0.327}/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.325 → code_puppy-0.0.327}/code_puppy/keymap.py

@@ -86,15 +86,9 @@ def cancel_agent_uses_signal() -> bool:
     """Check if the cancel agent key uses SIGINT (Ctrl+C).
 
     Returns:
-        True if the cancel key is ctrl+c AND we're not on Windows
-        (uses SIGINT handler), False if it uses keyboard listener approach.
+        True if the cancel key is ctrl+c (uses SIGINT handler),
+        False if it uses keyboard listener approach.
     """
-    import sys
-
-    # On Windows, always use keyboard listener - SIGINT is unreliable
-    if sys.platform == "win32":
-        return False
-
     return get_cancel_agent_key() == "ctrl+c"
 
 

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

@@ -192,11 +192,6 @@ def kill_all_running_shell_processes() -> int:
     """Kill all currently tracked running shell processes and stop reader threads.
 
     Returns the number of processes signaled.
-
-    Implementation notes:
-    - Atomically snapshot and clear the registry to prevent race conditions
-    - Deduplicate by PID to ensure each process is killed at most once
-    - Let exceptions from _kill_process_group propagate (tests expect this)
     """
     global _READER_STOP_EVENT
 
@@ -204,52 +199,30 @@ def kill_all_running_shell_processes() -> int:
     if _READER_STOP_EVENT:
         _READER_STOP_EVENT.set()
 
-    # Atomically take snapshot and clear registry
-    # This prevents other threads from seeing/processing the same processes
+    procs: list[subprocess.Popen]
     with _RUNNING_PROCESSES_LOCK:
-        procs_snapshot = list(_RUNNING_PROCESSES)
-        _RUNNING_PROCESSES.clear()
-
-    # Deduplicate by pid to ensure at-most-one kill per process
-    seen_pids: set = set()
-    killed_count = 0
-
-    for proc in procs_snapshot:
-        if proc is None:
-            continue
-
-        pid = getattr(proc, "pid", None)
-        key = pid if pid is not None else id(proc)
-
-        if key in seen_pids:
-            continue
-        seen_pids.add(key)
-
-        # Close pipes first to unblock readline()
+        procs = list(_RUNNING_PROCESSES)
+    count = 0
+    for p in procs:
         try:
-            if proc.stdout and not proc.stdout.closed:
-                proc.stdout.close()
-            if proc.stderr and not proc.stderr.closed:
-                proc.stderr.close()
-            if proc.stdin and not proc.stdin.closed:
-                proc.stdin.close()
-        except (OSError, ValueError):
-            pass
-
-        # Only attempt to kill processes that are still running
-        if proc.poll() is None:
-            # Let exceptions bubble up (tests expect this behavior)
-            _kill_process_group(proc)
-            killed_count += 1
-
-            # Track user-killed PIDs
-            if pid is not None:
-                try:
-                    _USER_KILLED_PROCESSES.add(pid)
-                except Exception:
-                    pass  # Non-fatal bookkeeping
+            # Close pipes first to unblock readline()
+            try:
+                if p.stdout and not p.stdout.closed:
+                    p.stdout.close()
+                if p.stderr and not p.stderr.closed:
+                    p.stderr.close()
+                if p.stdin and not p.stdin.closed:
+                    p.stdin.close()
+            except (OSError, ValueError):
+                pass
 
-    return killed_count
+            if p.poll() is None:
+                _kill_process_group(p)
+                count += 1
+                _USER_KILLED_PROCESSES.add(p.pid)
+        finally:
+            _unregister_process(p)
+    return count
 
 
 def get_running_shell_process_count() -> int:

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

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