janito 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

janito/README.md

@@ -106,6 +106,9 @@ janito --set model=kimi-k1-8k
 
 ## Advanced Features
 
+### 🚀 New in v3.1.0: Enter Key Cancellation
+**Chat Mode Enhancement**: Press **Enter** at any time to instantly cancel long-running requests in interactive chat mode. No more waiting for stuck requests!
+
 ### Tool Usage
 
 Janito includes powerful built-in tools for:

janito/cli/chat_mode/bindings.py

@@ -35,30 +35,30 @@ class KeyBindingsFactory:
             buf.text = "Do It"
             buf.validate_and_handle()
 
-        @bindings.add("enter", eager=True)
+        @bindings.add("c-c")
         def _(event):
-            """Handle Enter key to interrupt current request."""
-            import threading
-            
-            # Get the current session context
-            from prompt_toolkit.application import get_app
-            app = get_app()
-            
+            """Handle Ctrl+C to interrupt current request or exit chat."""
             # Use global cancellation manager for robust cancellation
             from janito.llm.cancellation_manager import get_cancellation_manager
+
             cancel_manager = get_cancellation_manager()
-            
+
             cancelled = cancel_manager.cancel_current_request()
             if cancelled:
                 # Provide user feedback
                 from rich.console import Console
+
                 console = Console()
-                console.print("[red]Request cancelled by Enter key[/red]")
-                
-                # Prevent the Enter key from being processed as input
+                console.print("[red]Request cancelled by Ctrl+C[/red]")
+
+                # Prevent the Ctrl+C from being processed as input
                 event.app.output.flush()
                 return
-            
-            # If no active request to cancel, let normal Enter behavior proceed
+            else:
+                # No active request to cancel, exit the chat
+                from rich.console import Console
+                console = Console()
+                console.print("[yellow]Goodbye![/yellow]")
+                event.app.exit()
 
         return bindings

janito/cli/chat_mode/session.py

@@ -22,6 +22,7 @@ import time
 
 # Shared prompt/agent factory
 from janito.cli.prompt_setup import setup_agent_and_prompt_handler
+from janito.llm.cancellation_manager import get_cancellation_manager
 
 import time
 
@@ -113,6 +114,10 @@ class ChatSession:
 
         # Check if multi-line mode should be enabled by default
         self.multi_line_mode = getattr(args, "multi", False) if args else False
+        
+        # Default to single-line mode (Enter submits) unless explicitly enabled
+        if not self.multi_line_mode:
+            self.multi_line_mode = False
 
     def _select_profile_and_role(self, args, role):
         profile, role_arg, python_profile, market_profile = self._extract_args(args)
@@ -289,7 +294,7 @@ class ChatSession:
                 # Ensure cancellation manager is cleared
                 cancel_manager = get_cancellation_manager()
                 cancel_manager.clear_current_request()
-                
+
             end_time = time.time()
             elapsed = end_time - start_time
             self.msg_count += 1

janito/cli/chat_mode/shell/commands/security/allowed_sites.py

@@ -59,39 +59,53 @@ Examples:
         command = args[0].lower()
         whitelist_manager = get_url_whitelist_manager()
 
-        if command == "list":
-            sites = whitelist_manager.get_allowed_sites()
-            if sites:
-                print("Allowed sites:")
-                for site in sites:
-                    print(f"  • {site}")
-            else:
-                print("No sites are whitelisted (all sites are allowed)")
-
-        elif command == "add":
-            if len(args) < 2:
-                print("Error: Please specify a site to add")
-                return
-            site = args[1]
-            if whitelist_manager.add_allowed_site(site):
-                print(f"✅ Added '{site}' to allowed sites")
-            else:
-                print(f"ℹ️ '{site}' is already in allowed sites")
-
-        elif command == "remove":
-            if len(args) < 2:
-                print("Error: Please specify a site to remove")
-                return
-            site = args[1]
-            if whitelist_manager.remove_allowed_site(site):
-                print(f"✅ Removed '{site}' from allowed sites")
-            else:
-                print(f"ℹ️ '{site}' was not in allowed sites")
-
-        elif command == "clear":
-            whitelist_manager.clear_whitelist()
-            print("✅ Cleared all allowed sites (all sites are now allowed)")
-
+        handlers = {
+            "list": self._handle_list,
+            "add": self._handle_add,
+            "remove": self._handle_remove,
+            "clear": self._handle_clear,
+        }
+
+        handler = handlers.get(command)
+        if handler:
+            handler(args, whitelist_manager)
         else:
             print(f"Error: Unknown command '{command}'")
             print(self.get_usage())
+
+    def _handle_list(self, args, whitelist_manager):
+        """Handle list command."""
+        sites = whitelist_manager.get_allowed_sites()
+        if sites:
+            print("Allowed sites:")
+            for site in sites:
+                print(f"  • {site}")
+        else:
+            print("No sites are whitelisted (all sites are allowed)")
+
+    def _handle_add(self, args, whitelist_manager):
+        """Handle add command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to add")
+            return
+        site = args[1]
+        if whitelist_manager.add_allowed_site(site):
+            print(f"✅ Added '{site}' to allowed sites")
+        else:
+            print(f"ℹ️ '{site}' is already in allowed sites")
+
+    def _handle_remove(self, args, whitelist_manager):
+        """Handle remove command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to remove")
+            return
+        site = args[1]
+        if whitelist_manager.remove_allowed_site(site):
+            print(f"✅ Removed '{site}' from allowed sites")
+        else:
+            print(f"ℹ️ '{site}' was not in allowed sites")
+
+    def _handle_clear(self, args, whitelist_manager):
+        """Handle clear command."""
+        whitelist_manager.clear_whitelist()
+        print("✅ Cleared all allowed sites (all sites are now allowed)")

janito/cli/core/model_guesser.py

@@ -21,34 +21,50 @@ def guess_provider_from_model(model_name: str) -> str:
     model_name = model_name.lower()
 
     # Check each provider's models
+    return _find_provider_for_model(model_name)
+
+
+def _find_provider_for_model(model_name: str) -> str:
+    """Find provider for given model name."""
     for provider_name in LLMProviderRegistry.list_providers():
         provider_class = LLMProviderRegistry.get(provider_name)
         if not provider_class:
             continue
 
-        # Get model specs for this provider
-        try:
-            if hasattr(provider_class, "MODEL_SPECS"):
-                model_specs = provider_class.MODEL_SPECS
-                for spec_model_name in model_specs.keys():
-                    if spec_model_name.lower() == model_name:
-                        return provider_name
-
-            # Handle special cases like moonshot
-            if provider_name == "moonshot":
-                try:
-                    from janito.providers.moonshot.model_info import (
-                        MOONSHOT_MODEL_SPECS,
-                    )
-
-                    for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
-                        if spec_model_name.lower() == model_name:
-                            return "moonshot"
-                except ImportError:
-                    pass
-
-        except Exception:
-            # Skip providers that have issues accessing model specs
-            continue
+        if _check_provider_models(provider_name, provider_class, model_name):
+            return provider_name
 
     return None
+
+
+def _check_provider_models(provider_name: str, provider_class, model_name: str) -> bool:
+    """Check if provider has matching model."""
+    try:
+        if hasattr(provider_class, "MODEL_SPECS"):
+            model_specs = provider_class.MODEL_SPECS
+            for spec_model_name in model_specs.keys():
+                if spec_model_name.lower() == model_name:
+                    return True
+
+        # Handle special cases like moonshot
+        if provider_name == "moonshot":
+            return _check_moonshot_models(model_name)
+
+    except Exception:
+        # Skip providers that have issues accessing model specs
+        pass
+
+    return False
+
+
+def _check_moonshot_models(model_name: str) -> bool:
+    """Check moonshot models specifically."""
+    try:
+        from janito.providers.moonshot.model_info import MOONSHOT_MODEL_SPECS
+
+        for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
+            if spec_model_name.lower() == model_name:
+                return True
+    except ImportError:
+        pass
+    return False

janito/cli/prompt_core.py

@@ -207,12 +207,13 @@ class PromptHandler:
         """
         try:
             self._print_verbose_debug("Calling agent.chat()...")
-            
+
             # Use global cancellation manager
             from janito.llm.cancellation_manager import get_cancellation_manager
+
             cancel_manager = get_cancellation_manager()
             driver_cancel_event = cancel_manager.start_new_request()
-            
+
             try:
                 final_event = self.agent.chat(prompt=user_prompt)
                 if hasattr(self.agent, "set_latest_event"):
@@ -225,7 +226,7 @@ class PromptHandler:
                     global_event_bus.publish(final_event)
             finally:
                 cancel_manager.clear_current_request()
-                
+
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")

janito/i18n/it.py

@@ -1,46 +1,46 @@
-# pragma: allowlist secret
-translations = {
-    "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Avvio del server web...",
-    "70a0d194687568a47aa617fd85036ace1e69a982": "Vuoi davvero uscire? (s/n): ",
-    "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Azione Rapida (segue l'azione raccomandata)",
-    "fe21121e2934234b68d19b2757532117d440c1e3": "Chiave API non trovata. Si prega di configurare 'api_key' nel file di configurazione.",
-    "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Ciao, {name}!",
-    "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nessun prompt fornito nei messaggi",
-    "f7449d23d0c500ae2a0b31e04f92b47a4d8ae845": "max_tokens deve essere un intero, ricevuto: {resolved_max_tokens!r}",
-    "70a9ed8edb6da12e208431a31aa16ba54419b26f": "Risposta non valida/malformed da OpenAI (tentativo {attempt}/{max_retries}). Riprovo tra {wait_time} secondi...",
-    "a873085e3b06184fb5d27e842f97b06b6190976d": "Numero massimo di tentativi per risposta non valida raggiunto. Generazione errore.",
-    "66a34568bbe846bb1bde3619eb4d6dfa10211104": "L'API non supporta l'uso degli strumenti.",
-    "09b81476b75586da4116b83f8be70d77b174cec3": "Limite di richieste API OpenAI (429) (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
-    "5717a35dd2a1533fb7e15edc8c9329cb69f3410b": "Errore server API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
-    "02e760ba15ed863176c1290ac8a9b923963103cd": "Errore client API OpenAI {status_code}: {e}. Nessun nuovo tentativo.",
-    "2e52b0bbc8f16226b70e3e20f95c9245d2bcdb47": "Errore API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
-    "012cc970e039fdd79c452fc676202c814ffc76ae": "Numero massimo di tentativi per errore API OpenAI raggiunto. Generazione errore.",
-    "d0438e45667d31e0022b2497b5901cd4300f084b": "QueuedMessageHandler.handle_message si aspetta un dizionario con 'type' e 'message', ricevuto {msg_type}: {msg!r}",
-    "9d3460187ffa19c7c8a4020157072b1087e1bd2f": "[QueuedMessageHandler] {msg_type}: {msg}",
-    "3813833343430e8afa8fce33385c5e39fb24dd60": "[QueuedMessageHandler] {msg_type}: {message}",
-    "0be9a22226e16a40797010d23a0f581542dca40e": "[ToolExecutor] {tool_name} chiamato con argomenti: {args}",
-    "42c68edcb25442f518b1af77c6a2ddc07461aae0": "[ToolExecutor] Motivo chiamata: {tool_call_reason}",
-    "002ff598115d84595ffeee6219cb5c03d3a1d4a6": "Domanda",
-    "35747d13dcd91e8e8790c7f767d5ed764f541b9e": "procedi",
-    "33dde3a1afbc418768a69fa53168d9b0638fe1aa": "avanti",
-    "eee0bbba4ff92adbeb038a77df0466d660f15716": "continua",
-    "edee9402d198b04ac77dcf5dc9cc3dac44573782": "prossimo",
-    "8fdb7e2fa84f4faf0d9b92f466df424ec47a165b": "ok",
-    "5f8f924671cda79b5205a6bf1b776f347c4a7a07": "Opzioni di configurazione disponibili:\n",
-    "cef780a309cd234750764d42697882c24168ddab": "{key:15} {desc} (predefinito: {default})",
-    "68c2cc7f0ceaa3e499ecb4db331feb4debbbcc23": "Modello",
-    "c3f104d1365744b538bfde9f4adb6a6df4b80355": "Funzione",
-    "99a0efc6cfd85d8ff2732a6718140f822cb90472": "Stile",
-    "f1702b4686278becffc88baabe6f4b7a8355532c": "Messaggi",
-    "c38c6c1f3a2743f8626703abb302e403d20ff81c": "Token",
-    "a817d7eb8e0f1dab755ab5203a082e5c3c094fce": "Prompt",
-    "2ff255684a2277f806fcebf3fe338ed27857f350": "Completamento",
-    "b25928c69902557b0ef0a628490a3a1768d7b82f": "Totale",
-    "76e63d65c883ed50df40ac3aeef0c2d6a1c4ad60": "Azione Rapida",
-    "5397e0583f14f6c88de06b1ef28f460a1fb5b0ae": "Sì",
-    "816c52fd2bdd94a63cd0944823a6c0aa9384c103": "No",
-    "c47ae15370cfe1ed2781eedc1dc2547d12d9e972": "Aiuto",
-    "cc3dbd47e1cf9003a55d3366b3adbcd72275e525": "Nuovo Task",
-    "efa5a8b84e1afe65c81ecfce28c398c48f19ddc2": "Benvenuto su Janito{version_str}! Modalità chat attiva. Digita /exit per uscire.",
-    "b314d6e1460f86e0f21abc5aceb7935a2a0667e8": "Benvenuto su Janito{version_str} in modalità [white on magenta]VANILLA[/white on magenta]! Strumenti, prompt di sistema e temperatura sono disattivati, a meno che non siano sovrascritti.",
-}
+# pragma: allowlist secret
+translations = {
+    "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Avvio del server web...",
+    "70a0d194687568a47aa617fd85036ace1e69a982": "Vuoi davvero uscire? (s/n): ",
+    "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Azione Rapida (segue l'azione raccomandata)",
+    "fe21121e2934234b68d19b2757532117d440c1e3": "Chiave API non trovata. Si prega di configurare 'api_key' nel file di configurazione.",
+    "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Ciao, {name}!",
+    "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nessun prompt fornito nei messaggi",
+    "f7449d23d0c500ae2a0b31e04f92b47a4d8ae845": "max_tokens deve essere un intero, ricevuto: {resolved_max_tokens!r}",
+    "70a9ed8edb6da12e208431a31aa16ba54419b26f": "Risposta non valida/malformed da OpenAI (tentativo {attempt}/{max_retries}). Riprovo tra {wait_time} secondi...",
+    "a873085e3b06184fb5d27e842f97b06b6190976d": "Numero massimo di tentativi per risposta non valida raggiunto. Generazione errore.",
+    "66a34568bbe846bb1bde3619eb4d6dfa10211104": "L'API non supporta l'uso degli strumenti.",
+    "09b81476b75586da4116b83f8be70d77b174cec3": "Limit di richieste API OpenAI (429) (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "5717a35dd2a1533fb7e15edc8c9329cb69f3410b": "Errore server API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "02e760ba15ed863176c1290ac8a9b923963103cd": "Errore client API OpenAI {status_code}: {e}. Nessun nuovo tentativo.",
+    "2e52b0bbc8f16226b70e3e20f95c9245d2bcdb47": "Errore API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "012cc970e039fdd79c452fc676202c814ffc76ae": "Numero massimo di tentativi per errore API OpenAI raggiunto. Generazione errore.",
+    "d0438e45667d31e0022b2497b5901cd4300f084b": "QueuedMessageHandler.handle_message si aspetta un dizionario con 'type' e 'message', ricevuto {msg_type}: {msg!r}",
+    "9d3460187ffa19c7c8a4020157072b1087e1bd2f": "[QueuedMessageHandler] {msg_type}: {msg}",
+    "3813833343430e8afa8fce33385c5e39fb24dd60": "[QueuedMessageHandler] {msg_type}: {message}",
+    "0be9a22226e16a40797010d23a0f581542dca40e": "[ToolExecutor] {tool_name} chiamato con argomenti: {args}",
+    "42c68edcb25442f518b1af77c6a2ddc07461aae0": "[ToolExecutor] Motivo chiamata: {tool_call_reason}",
+    "002ff598115d84595ffeee6219cb5c03d3a1d4a6": "Domanda",
+    "35747d13dcd91e8e8790c7f767d5ed764f541b9e": "procedi",
+    "33dde3a1afbc418768a69fa53168d9b0638fe1aa": "avanti",
+    "eee0bbba4ff92adbeb038a77df0466d660f15716": "continua",
+    "edee9402d198b04ac77dcf5dc9cc3dac44573782": "prossimo",
+    "8fdb7e2fa84f4faf0d9b92f466df424ec47a165b": "ok",
+    "5f8f924671cda79b5205a6bf1b776f347c4a7a07": "Opzioni di configurazione disponibili:\n",
+    "cef780a309cd234750764d42697882c24168ddab": "{key:15} {desc} (predefinito: {default})",
+    "68c2cc7f0ceaa3e499ecb4db331feb4debbbcc23": "Modello",
+    "c3f104d1365744b538bfde9f4adb6a6df4b80355": "Funzione",
+    "99a0efc6cfd85d8ff2732a6718140f822cb90472": "Stile",
+    "f1702b4686278becffc88baabe6f4b7a8355532c": "Messaggi",
+    "c38c6c1f3a2743f8626703abb302e403d20ff81c": "Token",
+    "a817d7eb8e0f1dab755ab5203a082e5c3c094fce": "Prompt",
+    "2ff255684a2277f806fcebf3fe338ed27857f350": "Completamento",
+    "b25928c69902557b0ef0a628490a3a1768d7b82f": "Totale",
+    "76e63d65c883ed50df40ac3aeef0c2d6a1c4ad60": "Azione Rapida",
+    "5397e0583f14f6c88de06b1ef28f460a1fb5b0ae": "Sì",
+    "816c52fd2bdd94a63cd0944823a6c0aa9384c103": "No",
+    "c47ae15370cfe1ed2781eedc1dc2547d12d9e972": "Aiuto",
+    "cc3dbd47e1cf9003a55d3366b3adbcd72275e525": "Nuovo Task",
+    "efa5a8b84e1afe65c81ecfce28c398c48f19ddc2": "Benvenuto su Janito{version_str}! Modalità chat attiva. Digita /exit per uscire.",
+    "b314d6e1460f86e0f21abc5aceb7935a2a0667e8": "Benvenuto su Janito{version_str} in modalità [white on magenta]VANILLA[/white on magenta]! Strumenti, prompt di sistema e temperatura sono disattivati, a meno che non siano sovrascritti.",
+}

janito/llm/agent.py

@@ -320,16 +320,19 @@ class LLMAgent:
 
         # Use global cancellation manager
         from janito.llm.cancellation_manager import get_cancellation_manager
+
         cancel_manager = get_cancellation_manager()
         driver_cancel_event = cancel_manager.start_new_request()
-        
+
         # Store cancellation event on agent for external access
         self.cancel_event = driver_cancel_event
-        
+
         try:
             while True:
                 self._print_verbose_chat_loop(loop_count)
-                driver_input = self._prepare_driver_input(config, cancel_event=driver_cancel_event)
+                driver_input = self._prepare_driver_input(
+                    config, cancel_event=driver_cancel_event
+                )
                 self.input_queue.put(driver_input)
                 try:
                     result, added_tool_results = self._process_next_response()
@@ -346,8 +349,8 @@ class LLMAgent:
         finally:
             cancel_manager.clear_current_request()
             # Clean up cancellation event
-            if hasattr(self, 'cancel_event'):
-                delattr(self, 'cancel_event')
+            if hasattr(self, "cancel_event"):
+                delattr(self, "cancel_event")
 
     def _clear_driver_queues(self):
         if hasattr(self, "driver") and self.driver:

janito/llm/cancellation_manager.py

@@ -9,25 +9,26 @@ from typing import Optional
 
 class CancellationManager:
     """Manages cancellation of LLM requests across the application."""
-    
+
     def __init__(self):
         self._current_cancel_event: Optional[threading.Event] = None
         self._lock = threading.Lock()
         self._keyboard_cancellation = None
-        
+
     def start_new_request(self) -> threading.Event:
         """Start a new request and return its cancellation event."""
         with self._lock:
             # Create new cancellation event for this request
             self._current_cancel_event = threading.Event()
-            
+
             # Start keyboard monitoring
             from janito.llm.enter_cancellation import get_enter_cancellation
+
             self._keyboard_cancellation = get_enter_cancellation()
             self._keyboard_cancellation.start_monitoring(self._current_cancel_event)
-            
+
             return self._current_cancel_event
-    
+
     def cancel_current_request(self) -> bool:
         """Cancel the current request if one is active."""
         with self._lock:
@@ -35,12 +36,12 @@ class CancellationManager:
                 self._current_cancel_event.set()
                 return True
             return False
-    
+
     def get_current_cancel_event(self) -> Optional[threading.Event]:
         """Get the current cancellation event."""
         with self._lock:
             return self._current_cancel_event
-    
+
     def clear_current_request(self):
         """Clear the current request cancellation event."""
         with self._lock:
@@ -59,4 +60,4 @@ def get_cancellation_manager() -> CancellationManager:
     global _global_manager
     if _global_manager is None:
         _global_manager = CancellationManager()
-    return _global_manager
+    return _global_manager

janito/llm/driver.py

@@ -257,5 +257,6 @@ class LLMDriver(ABC):
         """Cancel the current request being processed."""
         # Use global cancellation manager to cancel the current request
         from janito.llm.cancellation_manager import get_cancellation_manager
+
         cancel_manager = get_cancellation_manager()
         cancel_manager.cancel_current_request()

janito/llm/enter_cancellation.py

@@ -11,75 +11,89 @@ from typing import Optional
 
 class EnterCancellation:
     """Handles Enter key cancellation of LLM requests."""
-    
+
     def __init__(self):
         self._cancel_event: Optional[threading.Event] = None
         self._listener_thread: Optional[threading.Thread] = None
         self._listening = False
-        
+
     def start_monitoring(self, cancel_event: threading.Event):
         """Start monitoring for Enter key to cancel the request."""
         if self._listening:
             return
-            
+
         self._cancel_event = cancel_event
         self._listening = True
-        
+
         self._listener_thread = threading.Thread(
             target=self._monitor_enter_key, daemon=True
         )
         self._listener_thread.start()
-    
+
     def stop_monitoring(self):
         """Stop monitoring for keyboard input."""
         self._listening = False
         if self._listener_thread and self._listener_thread.is_alive():
             self._listener_thread.join(timeout=0.1)
-    
+
     def _monitor_enter_key(self):
         """Monitor for Enter key press."""
         try:
-            import sys
-            import select
-            import msvcrt  # Windows-specific keyboard input
-            
-            # Monitor for Enter key (Windows-specific implementation)
-            while self._listening and self._cancel_event and not self._cancel_event.is_set():
-                try:
-                    # Windows-specific: check if key is available
-                    if msvcrt.kbhit():
-                        char = msvcrt.getch()
-                        # Check for Enter key (carriage return or newline)
-                        if char in [b'\r', b'\n']:
-                            if self._cancel_event:
-                                self._cancel_event.set()
-                            break
-                        else:
-                            # Discard any other input
-                            pass
-                    else:
-                        # Small delay to prevent high CPU usage
-                        time.sleep(0.05)
-                        
-                except (IOError, OSError):
-                    break
-                except Exception:
-                    # Fallback to select-based approach for non-Windows
-                    try:
-                        if sys.stdin in select.select([sys.stdin], [], [], 0.05)[0]:
-                            char = sys.stdin.read(1)
-                            if char in ['\r', '\n']:  # Enter key
-                                if self._cancel_event:
-                                    self._cancel_event.set()
-                                break
-                    except:
-                        pass
-                    time.sleep(0.05)
-                
+            self._handle_key_monitoring()
         except Exception:
             # Silently handle any errors
             pass
 
+    def _handle_key_monitoring(self):
+        """Handle the actual key monitoring logic."""
+        import sys
+        import select
+
+        try:
+            import msvcrt  # Windows-specific keyboard input
+
+            self._monitor_windows_keys()
+        except ImportError:
+            self._monitor_unix_keys()
+
+    def _monitor_windows_keys(self):
+        """Monitor keys on Windows systems."""
+        import msvcrt
+
+        while (
+            self._listening and self._cancel_event and not self._cancel_event.is_set()
+        ):
+            try:
+                if msvcrt.kbhit():
+                    char = msvcrt.getch()
+                    if char in [b"\r", b"\n"]:
+                        if self._cancel_event:
+                            self._cancel_event.set()
+                        break
+                else:
+                    time.sleep(0.05)
+            except (IOError, OSError):
+                break
+
+    def _monitor_unix_keys(self):
+        """Monitor keys on Unix-like systems."""
+        import sys
+        import select
+
+        while (
+            self._listening and self._cancel_event and not self._cancel_event.is_set()
+        ):
+            try:
+                if sys.stdin in select.select([sys.stdin], [], [], 0.05)[0]:
+                    char = sys.stdin.read(1)
+                    if char in ["\r", "\n"]:
+                        if self._cancel_event:
+                            self._cancel_event.set()
+                        break
+                time.sleep(0.05)
+            except:
+                time.sleep(0.05)
+
 
 # Global instance
 _global_enter_cancellation = None
@@ -90,4 +104,4 @@ def get_enter_cancellation() -> EnterCancellation:
     global _global_enter_cancellation
     if _global_enter_cancellation is None:
         _global_enter_cancellation = EnterCancellation()
-    return _global_enter_cancellation
+    return _global_enter_cancellation