agentcrew-ai 0.8.12__py3-none-any.whl → 0.9.0__py3-none-any.whl

AgentCrew/modules/command_execution/constants.py

@@ -10,7 +10,7 @@ definitions for the CommandExecutionService.
 # ==============================================================================
 
 # Maximum number of commands that can run concurrently (application-wide)
-MAX_CONCURRENT_COMMANDS = 3
+MAX_CONCURRENT_COMMANDS = 10
 
 # Maximum lifetime for a single command execution (seconds)
 MAX_COMMAND_LIFETIME = 600
@@ -19,7 +19,7 @@ MAX_COMMAND_LIFETIME = 600
 MAX_OUTPUT_LINES = 300
 
 # Maximum number of commands allowed per minute (application-wide rate limit)
-MAX_COMMANDS_PER_MINUTE = 10
+MAX_COMMANDS_PER_MINUTE = 50
 
 # Default timeout for command execution (seconds)
 DEFAULT_TIMEOUT = 5

AgentCrew/modules/console/completers.py

@@ -174,7 +174,7 @@ class ChatCompleter(Completer):
             ),
             (
                 "/debug",
-                "Show debug information (agent history and streamline messages)",
+                "Show debug info (usage: /debug [agent|chat])",
             ),
             ("/think", "Set thinking budget (usage: /think <budget>)"),
             (

AgentCrew/modules/console/confirmation_handler.py

@@ -125,7 +125,7 @@ class ConfirmationHandler:
 
         self.input_handler._start_input_thread()
 
-    def _display_write_or_edit_file_diff(self, tool_use, file_path, blocks_text):
+    def _display_write_or_edit_file_diff(self, tool_use, file_path, blocks):
         """Display split diff view for write_or_edit_file tool."""
         header = Text("📝 File Edit ", style=RICH_STYLE_YELLOW)
         header.append(file_path, style=RICH_STYLE_BLUE_BOLD)
@@ -135,15 +135,15 @@ class ConfirmationHandler:
             Panel(header, box=HORIZONTALS, border_style=RICH_STYLE_YELLOW)
         )
 
-        blocks = DiffDisplay.parse_search_replace_blocks(blocks_text)
+        parsed_blocks = DiffDisplay.parse_search_replace_blocks(blocks)
 
-        if not blocks:
+        if not parsed_blocks:
             self.console.print(
                 Text("No valid search/replace blocks found", style=RICH_STYLE_RED)
             )
             return
 
-        for block in blocks:
+        for block in parsed_blocks:
             diff_table = DiffDisplay.create_split_diff_table(
                 block["search"], block["replace"], max_width=self.console.width - 4
             )

AgentCrew/modules/console/console_ui.py

@@ -215,8 +215,10 @@ class ConsoleUI(Observer):
             )
         elif event == "conversations_listed":
             self.display_handlers.display_conversations(
-                data
-            )  # data is list of conversation metadata
+                data,
+                get_history_callback=self.conversation_handler.get_conversation_history,
+                delete_callback=self.conversation_handler.delete_conversations,
+            )
             self.conversation_handler.update_cached_conversations(data)
         elif event == "conversation_loaded":
             loaded_text = Text("Loaded conversation: ", style=RICH_STYLE_YELLOW)
@@ -454,7 +456,19 @@ class ConsoleUI(Observer):
                         self.conversation_handler.update_cached_conversations(
                             conversations
                         )
-                        self.display_handlers.display_conversations(conversations)
+                        self.input_handler._stop_input_thread()
+                        try:
+                            selected_id = self.display_handlers.display_conversations(
+                                conversations,
+                                get_history_callback=self.conversation_handler.get_conversation_history,
+                                delete_callback=self.conversation_handler.delete_conversations,
+                            )
+                            if selected_id:
+                                self.conversation_handler.handle_load_conversation(
+                                    selected_id, self.message_handler
+                                )
+                        finally:
+                            self.input_handler._start_input_thread()
                         continue
 
                     # Handle load command directly

AgentCrew/modules/console/conversation_browser/__init__.py

@@ -0,0 +1,9 @@
+from .browser import ConversationBrowser
+from .browser_ui import ConversationBrowserUI
+from .browser_input_handler import ConversationBrowserInputHandler
+
+__all__ = [
+    "ConversationBrowser",
+    "ConversationBrowserUI",
+    "ConversationBrowserInputHandler",
+]

AgentCrew/modules/console/conversation_browser/browser.py

@@ -0,0 +1,84 @@
+"""Conversation browser with split-panel interface.
+
+Provides Rich-based UI for listing and loading conversations with preview.
+"""
+
+from __future__ import annotations
+
+from typing import List, Dict, Any, Optional, Callable
+
+from rich.console import Console
+from rich.text import Text
+
+from ..constants import RICH_STYLE_YELLOW
+from .browser_ui import ConversationBrowserUI
+from .browser_input_handler import ConversationBrowserInputHandler
+
+
+class ConversationBrowser:
+    """Interactive conversation browser with split-panel layout.
+
+    This class orchestrates the UI rendering and input handling components
+    to provide a complete interactive conversation browsing experience.
+    """
+
+    def __init__(
+        self,
+        console: Console,
+        get_conversation_history: Optional[
+            Callable[[str], List[Dict[str, Any]]]
+        ] = None,
+        on_delete: Optional[Callable[[List[str]], bool]] = None,
+    ):
+        """Initialize the conversation browser.
+
+        Args:
+            console: Rich console for rendering
+            get_conversation_history: Optional callback to fetch full conversation history
+            on_delete: Optional callback to delete conversations by IDs. Returns True if successful.
+        """
+        self._console = console
+        self._ui = ConversationBrowserUI(
+            console=console,
+            get_conversation_history=get_conversation_history,
+        )
+        self._input_handler = ConversationBrowserInputHandler(
+            ui=self._ui,
+            on_delete=on_delete,
+        )
+
+    def set_conversations(self, conversations: List[Dict[str, Any]]):
+        """Set the conversations list to browse."""
+        self._ui.set_conversations(conversations)
+
+    def get_selected_conversation_id(self) -> Optional[str]:
+        """Get the ID of the currently selected conversation."""
+        return self._ui.get_selected_conversation_id()
+
+    def get_selected_conversation_index(self) -> int:
+        """Get the 1-based index of the currently selected conversation."""
+        return self._ui.get_selected_conversation_index()
+
+    @property
+    def ui(self) -> ConversationBrowserUI:
+        """Access the UI component directly."""
+        return self._ui
+
+    @property
+    def input_handler(self) -> ConversationBrowserInputHandler:
+        """Access the input handler component directly."""
+        return self._input_handler
+
+    def show(self) -> Optional[str]:
+        """Show the interactive conversation browser.
+
+        Returns:
+            The ID of the selected conversation, or None if cancelled.
+        """
+        if not self._ui.conversations:
+            self._console.print(
+                Text("No conversations available.", style=RICH_STYLE_YELLOW)
+            )
+            return None
+
+        return self._input_handler.run()

AgentCrew/modules/console/conversation_browser/browser_input_handler.py

@@ -0,0 +1,279 @@
+"""Conversation browser input handling."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Callable, List
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.keys import Keys
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from .browser_ui import ConversationBrowserUI
+
+
+class ConversationBrowserInputHandler:
+    """Handles keyboard input for the conversation browser."""
+
+    def __init__(
+        self,
+        ui: ConversationBrowserUI,
+        on_select: Optional[Callable[[str], None]] = None,
+        on_cancel: Optional[Callable[[], None]] = None,
+        on_delete: Optional[Callable[[List[str]], bool]] = None,
+    ):
+        self._ui = ui
+        self._running = False
+        self._g_pressed = False
+        self._d_pressed = False
+        self._selected_id: Optional[str] = None
+        self._on_select = on_select
+        self._on_cancel = on_cancel
+        self._on_delete = on_delete
+
+    def _create_key_bindings(self) -> KeyBindings:
+        """Create and configure key bindings for the browser."""
+        kb = KeyBindings()
+
+        @kb.add(Keys.Up)
+        @kb.add("k")
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("up"):
+                self._ui.render()
+
+        @kb.add(Keys.Down)
+        @kb.add("j")
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("down"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlP)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("up"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlN)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("down"):
+                self._ui.render()
+
+        @kb.add("g")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("g")
+                self._ui.render()
+                return
+            self._d_pressed = False
+            if self._g_pressed:
+                self._g_pressed = False
+                if self._ui.handle_navigation("top"):
+                    self._ui.render()
+            else:
+                self._g_pressed = True
+
+        @kb.add("G")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("G")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("bottom"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlU)
+        @kb.add(Keys.PageUp)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("page_up"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlD)
+        @kb.add(Keys.PageDown)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("page_down"):
+                self._ui.render()
+
+        @kb.add("v")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("v")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.toggle_selection():
+                self._ui.render()
+
+        @kb.add("d")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("d")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._d_pressed:
+                self._d_pressed = False
+                self._handle_delete()
+            else:
+                self._d_pressed = True
+
+        @kb.add("/")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("/")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            self._ui.start_search_mode()
+            self._ui.render()
+
+        @kb.add(Keys.Backspace)
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.backspace_search()
+                self._ui.render()
+
+        @kb.add(Keys.Enter)
+        @kb.add("l")
+        def _(event):
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.search_mode:
+                self._ui.exit_search_mode(clear_filter=False)
+                self._ui.render()
+                return
+            self._selected_id = self._ui.get_selected_conversation_id()
+            event.app.exit()
+
+        @kb.add(Keys.Escape)
+        def _(event):
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.search_mode:
+                self._ui.exit_search_mode(clear_filter=True)
+                self._ui.render()
+                return
+            event.app.exit()
+
+        @kb.add("q")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("q")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            event.app.exit()
+
+        @kb.add(Keys.ControlC)
+        def _(event):
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.search_mode:
+                self._ui.exit_search_mode(clear_filter=True)
+                self._ui.render()
+                return
+            event.app.exit()
+
+        @kb.add(Keys.Any)
+        def _(event):
+            if self._ui.search_mode:
+                char = event.data
+                if char and char.isprintable():
+                    self._ui.append_search_char(char)
+                    self._ui.render()
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+
+        return kb
+
+    def _handle_delete(self):
+        """Handle delete action for selected or current conversation."""
+        if not self._ui.conversations:
+            return
+
+        if self._ui.selected_items:
+            indices_to_delete = list(self._ui.selected_items)
+            ids_to_delete = self._ui.get_selected_conversation_ids()
+        else:
+            indices_to_delete = [self._ui.selected_index]
+            current_id = self._ui.get_selected_conversation_id()
+            ids_to_delete = [current_id] if current_id else []
+
+        if not ids_to_delete:
+            return
+
+        if self._on_delete:
+            success = self._on_delete(ids_to_delete)
+            if success:
+                self._ui.remove_conversations(indices_to_delete)
+                self._ui.render()
+        else:
+            self._ui.remove_conversations(indices_to_delete)
+            self._ui.render()
+
+    def run(self) -> Optional[str]:
+        """Run the input handler loop.
+
+        Returns:
+            The ID of the selected conversation, or None if cancelled.
+        """
+        self._running = True
+        self._g_pressed = False
+        self._d_pressed = False
+        self._selected_id = None
+
+        self._ui.start_live()
+
+        kb = self._create_key_bindings()
+
+        try:
+            session = PromptSession(key_bindings=kb)
+            session.prompt("")
+        except (KeyboardInterrupt, EOFError):
+            pass
+        except Exception as e:
+            logger.error(f"Error in conversation browser input handler: {e}")
+        finally:
+            self._ui.stop_live()
+
+        self._running = False
+        return self._selected_id
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the input handler is currently running."""
+        return self._running
+
+    def stop(self):
+        """Stop the input handler."""
+        self._running = False