janito 3.0.0__tar.gz → 3.1.0__tar.gz

{janito-3.0.0 → janito-3.1.0}/PKG-INFO

@@ -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.1.0/janito/cli/chat_mode/bindings.py

@@ -0,0 +1,64 @@
+"""
+Key bindings for Janito Chat CLI.
+"""
+
+from prompt_toolkit.key_binding import KeyBindings
+from janito.tools.permissions import get_global_allowed_permissions
+
+
+class KeyBindingsFactory:
+    @staticmethod
+    def create():
+        bindings = KeyBindings()
+
+        @bindings.add("c-y")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Yes"
+            buf.validate_and_handle()
+
+        @bindings.add("c-n")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "No"
+            buf.validate_and_handle()
+
+        @bindings.add("f2")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "/restart"
+            buf.validate_and_handle()
+
+        @bindings.add("f12")
+        def _(event):
+            buf = event.app.current_buffer
+            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-3.0.0 → janito-3.1.0}/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-3.0.0 → janito-3.1.0}/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-3.0.0 → janito-3.1.0}/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-3.1.0/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-3.0.0 → janito-3.1.0}/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-3.1.0/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 → janito-3.1.0}/janito.egg-info/PKG-INFO

@@ -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 → janito-3.1.0}/janito.egg-info/SOURCES.txt

@@ -274,10 +274,12 @@ janito/llm/__init__.py
 janito/llm/agent.py
 janito/llm/auth.py
 janito/llm/auth_utils.py
+janito/llm/cancellation_manager.py
 janito/llm/driver.py
 janito/llm/driver_config.py
 janito/llm/driver_config_builder.py
 janito/llm/driver_input.py
+janito/llm/enter_cancellation.py
 janito/llm/message_parts.py
 janito/llm/model.py
 janito/llm/provider.py

janito-3.0.0/janito/cli/chat_mode/bindings.py

@@ -1,38 +0,0 @@
-"""
-Key bindings for Janito Chat CLI.
-"""
-
-from prompt_toolkit.key_binding import KeyBindings
-from janito.tools.permissions import get_global_allowed_permissions
-
-
-class KeyBindingsFactory:
-    @staticmethod
-    def create():
-        bindings = KeyBindings()
-
-        @bindings.add("c-y")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Yes"
-            buf.validate_and_handle()
-
-        @bindings.add("c-n")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "No"
-            buf.validate_and_handle()
-
-        @bindings.add("f2")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "/restart"
-            buf.validate_and_handle()
-
-        @bindings.add("f12")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Do It"
-            buf.validate_and_handle()
-
-        return bindings