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

janito/cli/chat_mode/bindings.py

@@ -35,4 +35,30 @@ class KeyBindingsFactory:
             buf.text = "Do It"
             buf.validate_and_handle()
 
+        @bindings.add("enter", eager=True)
+        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()
+            
+            # 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
+                event.app.output.flush()
+                return
+            
+            # If no active request to cancel, let normal Enter behavior proceed
+
         return bindings

janito/cli/chat_mode/session.py

@@ -283,7 +283,13 @@ class ChatSession:
                 )
             )
 
-            self._prompt_handler.run_prompt(cmd_input)
+            try:
+                self._prompt_handler.run_prompt(cmd_input)
+            finally:
+                # 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/prompt_core.py

@@ -207,15 +207,25 @@ class PromptHandler:
         """
         try:
             self._print_verbose_debug("Calling agent.chat()...")
-            final_event = self.agent.chat(prompt=user_prompt)
-            if hasattr(self.agent, "set_latest_event"):
-                self.agent.set_latest_event(final_event)
-            self.agent.last_event = final_event
-            self._print_verbose_debug(f"agent.chat() returned: {final_event}")
-            self._print_verbose_final_event(final_event)
-            if on_event and final_event is not None:
-                on_event(final_event)
-                global_event_bus.publish(final_event)
+            
+            # 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"):
+                    self.agent.set_latest_event(final_event)
+                self.agent.last_event = final_event
+                self._print_verbose_debug(f"agent.chat() returned: {final_event}")
+                self._print_verbose_final_event(final_event)
+                if on_event and final_event is not None:
+                    on_event(final_event)
+                    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/llm/agent.py

@@ -318,23 +318,36 @@ class LLMAgent:
         loop_count = 1
         import threading
 
-        cancel_event = threading.Event()
-        while True:
-            self._print_verbose_chat_loop(loop_count)
-            driver_input = self._prepare_driver_input(config, cancel_event=cancel_event)
-            self.input_queue.put(driver_input)
-            try:
-                result, added_tool_results = self._process_next_response()
-            except KeyboardInterrupt:
-                cancel_event.set()
-                raise
-            if getattr(self, "verbose_agent", False):
-                print(
-                    f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
-                )
-            if self._should_exit_chat_loop(result, added_tool_results):
-                return result
-            loop_count += 1
+        # 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)
+                self.input_queue.put(driver_input)
+                try:
+                    result, added_tool_results = self._process_next_response()
+                except KeyboardInterrupt:
+                    cancel_manager.cancel_current_request()
+                    raise
+                if getattr(self, "verbose_agent", False):
+                    print(
+                        f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
+                    )
+                if self._should_exit_chat_loop(result, added_tool_results):
+                    return result
+                loop_count += 1
+        finally:
+            cancel_manager.clear_current_request()
+            # Clean up cancellation 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

@@ -0,0 +1,62 @@
+"""
+Global cancellation manager for LLM requests.
+Provides a centralized way to cancel ongoing requests.
+"""
+
+import threading
+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:
+            if self._current_cancel_event is not None:
+                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:
+            if self._keyboard_cancellation:
+                self._keyboard_cancellation.stop_monitoring()
+                self._keyboard_cancellation = None
+            self._current_cancel_event = None
+
+
+# Global cancellation manager instance
+_global_manager = None
+
+
+def get_cancellation_manager() -> CancellationManager:
+    """Get the global cancellation manager instance."""
+    global _global_manager
+    if _global_manager is None:
+        _global_manager = CancellationManager()
+    return _global_manager

janito/llm/driver.py

@@ -252,3 +252,10 @@ class LLMDriver(ABC):
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result. Subclasses must implement this."""
         raise NotImplementedError("Subclasses must implement _get_message_from_result.")
+
+    def cancel_current_request(self):
+        """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

@@ -0,0 +1,93 @@
+"""
+Enter key cancellation for LLM requests.
+Allows pressing Enter to cancel ongoing requests.
+"""
+
+import threading
+import sys
+import time
+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)
+                
+        except Exception:
+            # Silently handle any errors
+            pass
+
+
+# Global instance
+_global_enter_cancellation = None
+
+
+def get_enter_cancellation() -> EnterCancellation:
+    """Get the global Enter cancellation instance."""
+    global _global_enter_cancellation
+    if _global_enter_cancellation is None:
+        _global_enter_cancellation = EnterCancellation()
+    return _global_enter_cancellation

{janito-3.0.0.dist-info → janito-3.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.0.0
+Version: 3.1.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-3.0.0.dist-info → janito-3.1.0.dist-info}/RECORD

@@ -30,17 +30,17 @@ janito/cli/config.py,sha256=HkZ14701HzIqrvaNyDcDhGlVHfpX_uHlLp2rHmhRm_k,872
 janito/cli/console.py,sha256=gJolqzWL7jEPLxeuH-CwBDRFpXt976KdZOEAB2tdBDs,64
 janito/cli/main.py,sha256=s5odou0txf8pzTf1ADk2yV7T5m8B6cejJ81e7iu776U,312
 janito/cli/main_cli.py,sha256=_OOQqeLiqvmYeB_928Av920Gk43rbXecMIOTL6JeT0Y,16674
-janito/cli/prompt_core.py,sha256=F68J4Xl6jZMYFN4oBBYZFj15Jp-HTYoLub4bw2XpNRU,11648
+janito/cli/prompt_core.py,sha256=RRDhmiZTF1X-sxeGag2ODT9DSgtVDlqVwBlzl2voIIo,12082
 janito/cli/prompt_handler.py,sha256=SnPTlL64noeAMGlI08VBDD5IDD8jlVMIYA4-fS8zVLg,215
 janito/cli/prompt_setup.py,sha256=s48gvNfZhKjsEhf4EzL1tKIGm4wDidPMDvlM6TAPYes,2116
 janito/cli/rich_terminal_reporter.py,sha256=Hitf5U13gncad4GPVAcDMfdSwlfzQzOn9KdeX4TjTWU,6806
 janito/cli/utils.py,sha256=plCQiDKIf3V8mFhhX5H9-MF2W86i-xRdWf8Xi117Z0w,677
 janito/cli/verbose_output.py,sha256=wY_B4of5e8Vv7w1fRwOZzNGU2JqbMdcFnGjtEr4hLus,7686
-janito/cli/chat_mode/bindings.py,sha256=odjc5_-YW1t2FRhBUNRNoBMoQIg5sMz3ktV7xG0ADFU,975
+janito/cli/chat_mode/bindings.py,sha256=m2KA-0TKMPpmfaYF3XQ9qsAIfDRJ40a1FGVoPs8FaHo,2074
 janito/cli/chat_mode/chat_entry.py,sha256=RFdPd23jsA2DMHRacpjAdwI_1dFBaWrtnwyQEgb2fHA,475
 janito/cli/chat_mode/prompt_style.py,sha256=vsqQ9xxmrYjj1pWuVe9CayQf39fo2EIXrkKPkflSVn4,805
 janito/cli/chat_mode/script_runner.py,sha256=WFTFVWzg_VQrD2Ujj02XWjscfGgHwmjBeRxaEjWw9ps,6505
-janito/cli/chat_mode/session.py,sha256=1mCET4V9u1FGEMnr8HJGOc6X8lhTNkhAYlZ3cvIvefw,18540
+janito/cli/chat_mode/session.py,sha256=7RSFM6VccZLEHPaZTmZCpyEUe0JArto9DoHQCiYkUDg,18777
 janito/cli/chat_mode/toolbar.py,sha256=SzdWAJdcY1g2rTPZCPL6G5X8jO6ZQYjwko2-nw54_nU,3397
 janito/cli/chat_mode/shell/autocomplete.py,sha256=lE68MaVaodbA2VfUM0_YLqQVLBJAE_BJsd5cMtwuD-g,793
 janito/cli/chat_mode/shell/commands.bak.zip,sha256=I7GFjXg2ORT5NzFpicH1vQ3kchhduQsZinzqo0xO8wU,74238
@@ -122,13 +122,15 @@ janito/i18n/messages.py,sha256=fBuwOTFoygyHPkYphm6Y0r1iE8497Z4iryVAmPhMEkg,1851
 janito/i18n/pt.py,sha256=NlTgpDSftUfFG7FGbs7TK54vQlJVMyaZDHGcWjelwMc,4168
 janito/llm/README.md,sha256=6GRqCu_a9va5HCB1YqNqbshyWKFyAGlnXugrjom-xj8,1213
 janito/llm/__init__.py,sha256=dpyVH51qVRCw-PDyAFLAxq0zd4jl5MDcuV6Cri0D-dQ,134
-janito/llm/agent.py,sha256=T0JfeMoOudTWsHwWCcaocrHyq9k0TvkL4_YePlXvZfo,21269
+janito/llm/agent.py,sha256=zUmax9uJCvfNMfzDLQjGDdCZMFmmXzaRz2M_cG0HdMo,21914
 janito/llm/auth.py,sha256=8Dl_orUEPhn2X6XjkO2Nr-j1HFT2YDxk1qJl9hSFI88,2286
 janito/llm/auth_utils.py,sha256=mcPWT2p2kGMhvR9QsHqk84utDejPJh3uyjrDOJ0dKYA,1068
-janito/llm/driver.py,sha256=stiicPe_MXTuWW4q6MSwK7PCj8UZcA_30pGACu6xYUQ,10039
+janito/llm/cancellation_manager.py,sha256=lkMFIqXEc1PjU2a96rOIcxcHVRx4WvSr3gk_L9oumi4,2238
+janito/llm/driver.py,sha256=i6CIA4yEaMfsVJ0TIfwwO5S9gHn0IYyDxB9GjVa67og,10392
 janito/llm/driver_config.py,sha256=OW0ae49EfgKDqaThuDjZBiaN78voNzwiZ6szERMqJos,1406
 janito/llm/driver_config_builder.py,sha256=BvWGx7vaBR5NyvPY1XNAP3lAgo1uf-T25CSsIo2kkCU,1401
 janito/llm/driver_input.py,sha256=Zq7IO4KdQPUraeIo6XoOaRy1IdQAyYY15RQw4JU30uA,389
+janito/llm/enter_cancellation.py,sha256=NrySoeXM8M6PO6rMUPd9atW49GjPGF30YsTWIcAuZ7M,3393
 janito/llm/message_parts.py,sha256=QY_0kDjaxdoErDgKPRPv1dNkkYJuXIBmHWNLiOEKAH4,1365
 janito/llm/model.py,sha256=EioBkdgn8hJ0iQaKN-0KbXlsrk3YKmwR9IbvoEbdVTE,1159
 janito/llm/provider.py,sha256=3FbhQPrWBSEoIdIi-5DWIh0DD_CM570EFf1NcuGyGko,7961
@@ -323,9 +325,9 @@ janito/tools/url_whitelist.py,sha256=0CPLkHTp5HgnwgjxwgXnJmwPeZQ30q4j3YjW59hiUUE
 janito/tools/adapters/__init__.py,sha256=H25uYM2ETMLKpKPPEPAu9-AFjxkKfSyfx3pnoXSQlVA,255
 janito/tools/adapters/local/__init__.py,sha256=1DVnka4iEQp8Xrs7rJVVx45fPpuVahjTFmuJhv-gN8s,249
 janito/tools/adapters/local/adapter.py,sha256=u4nLHTaYdwZXMi1J8lsKvlG6rOmdq9xjey_3zeyCG4k,8707
-janito-3.0.0.dist-info/licenses/LICENSE,sha256=dXV4fOF2ZErugtN8l_Nrj5tsRTYgtjE3cgiya0UfBio,11356
-janito-3.0.0.dist-info/METADATA,sha256=JLYLflkFEBonYah38ghiqq0OP4HzA1wYCNyXSQ0FRC4,2265
-janito-3.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-janito-3.0.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
-janito-3.0.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
-janito-3.0.0.dist-info/RECORD,,
+janito-3.1.0.dist-info/licenses/LICENSE,sha256=dXV4fOF2ZErugtN8l_Nrj5tsRTYgtjE3cgiya0UfBio,11356
+janito-3.1.0.dist-info/METADATA,sha256=lbkmz3Msw06EXZzWwc_Ur9At-zlyvSVNGqRv8tkp0eI,2265
+janito-3.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+janito-3.1.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-3.1.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
+janito-3.1.0.dist-info/RECORD,,