agentcrew-ai 0.8.13__py3-none-any.whl → 0.9.1__py3-none-any.whl

AgentCrew/modules/console/display_handlers.py

@@ -122,12 +122,125 @@ class DisplayHandlers:
         )
 
     def display_debug_info(self, debug_info):
-        """Display debug information."""
-        self.console.print(Text("Current messages:", style=RICH_STYLE_YELLOW))
+        """Display debug information with formatting and truncation.
+
+        Args:
+            debug_info: Either a dict with 'type' and 'messages' keys (new format)
+                       or a raw list of messages (legacy format)
+        """
+        if (
+            isinstance(debug_info, dict)
+            and "type" in debug_info
+            and "messages" in debug_info
+        ):
+            # New format with type and messages
+            msg_type = debug_info["type"]
+            messages = debug_info["messages"]
+            title = "Agent Messages" if msg_type == "agent" else "Chat Messages"
+        else:
+            # Legacy format - just raw messages
+            title = "Messages"
+            messages = debug_info
+
+        self.console.print(
+            Text(f"\n{title} ({len(messages)} messages):", style=RICH_STYLE_YELLOW)
+        )
+
+        formatted = self._format_messages_for_debug(messages)
         try:
-            self.console.print(json.dumps(debug_info, indent=2))
+            self.console.print(json.dumps(formatted, indent=2))
         except Exception:
-            self.console.print(debug_info)
+            self.console.print(str(formatted))
+
+    def _format_messages_for_debug(
+        self, messages, max_content_length: int = 200
+    ) -> list:
+        """Format messages for debug display with truncated content.
+
+        Args:
+            messages: List of message dictionaries
+            max_content_length: Maximum length for message content
+
+        Returns:
+            List of formatted message dictionaries
+        """
+        formatted = []
+
+        for i, msg in enumerate(messages):
+            formatted_msg = {"#": i, "content": ""}
+
+            # Copy basic fields
+            if "role" in msg:
+                formatted_msg["role"] = msg["role"]
+            if "agent" in msg:
+                formatted_msg["agent"] = msg["agent"]
+
+            # Truncate content
+            content = msg.get("content", "")
+            formatted_msg["content"] = self._truncate_content(
+                content, max_content_length
+            )
+
+            # Include tool_use/tool_result indicators if present
+            if isinstance(content, list):
+                content_types = []
+                for item in content:
+                    if isinstance(item, dict):
+                        item_type = item.get("type", "unknown")
+                        if item_type == "tool_use":
+                            tool_name = item.get("name", "unknown")
+                            content_types.append(f"tool_use:{tool_name}")
+                        elif item_type == "tool_result":
+                            content_types.append("tool_result")
+                        elif item_type not in ("text",):
+                            content_types.append(item_type)
+                if content_types:
+                    formatted_msg["content_types"] = content_types
+
+            formatted.append(formatted_msg)
+
+        return formatted
+
+    def _truncate_content(self, content, max_length: int = 200) -> str:
+        """Truncate content to max_length with ellipsis.
+
+        Args:
+            content: Message content (can be string, list, or dict)
+            max_length: Maximum length for the output
+
+        Returns:
+            Truncated string representation
+        """
+        if isinstance(content, str):
+            text = content
+        elif isinstance(content, list):
+            # Extract text from content blocks
+            text_parts = []
+            for item in content:
+                if isinstance(item, dict):
+                    if item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
+                    elif item.get("type") == "tool_use":
+                        text_parts.append(f"[tool:{item.get('name', 'unknown')}]")
+                    elif item.get("type") == "tool_result":
+                        result = item.get("content", "")
+                        if isinstance(result, str):
+                            text_parts.append(f"[result:{result[:50]}...]")
+                        else:
+                            text_parts.append("[result:...]")
+                elif isinstance(item, str):
+                    text_parts.append(item)
+            text = " | ".join(text_parts)
+        else:
+            text = str(content)
+
+        # Clean up whitespace
+        text = " ".join(text.split())
+
+        if len(text) <= max_length:
+            return text
+
+        return text[: max_length - 3] + "..."
 
     def display_models(self, models_by_provider: Dict):
         """Display available models grouped by provider."""
@@ -161,13 +274,15 @@ class DisplayHandlers:
         self,
         conversations: List[Dict[str, Any]],
         get_history_callback=None,
+        delete_callback=None,
     ):
         """Display available conversations using interactive browser.
-        
+
         Args:
             conversations: List of conversation metadata
             get_history_callback: Optional callback to fetch full conversation history
-            
+            delete_callback: Optional callback to delete conversations by IDs
+
         Returns:
             Selected conversation ID or None if cancelled
         """
@@ -177,11 +292,12 @@ class DisplayHandlers:
             )
             return None
 
-        from .conversation_browser import ConversationBrowser
+        from .conversation_browser.browser import ConversationBrowser
 
         browser = ConversationBrowser(
             console=self.console,
             get_conversation_history=get_history_callback,
+            on_delete=delete_callback,
         )
         browser.set_conversations(conversations)
         return browser.show()
@@ -378,6 +494,10 @@ class DisplayHandlers:
                 "Use '/unconsolidate' undo last consolidated.",
                 style=RICH_STYLE_YELLOW,
             ),
+            Text(
+                "Use '/visual' to view raw message content with vim-like navigation and copy.",
+                style=RICH_STYLE_YELLOW,
+            ),
             Text(
                 "Tool calls require confirmation before execution.",
                 style=RICH_STYLE_BLUE,

AgentCrew/modules/console/visual_mode/__init__.py

@@ -0,0 +1,5 @@
+"""Visual mode module for viewing raw message content."""
+
+from .viewer import VisualModeViewer
+
+__all__ = ["VisualModeViewer"]

AgentCrew/modules/console/visual_mode/viewer.py

@@ -0,0 +1,41 @@
+"""Visual mode viewer for raw message content."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional, Callable
+
+from rich.console import Console
+from rich.text import Text
+
+from .viewer_ui import VisualModeUI
+from .viewer_input_handler import VisualModeInputHandler
+from ..constants import RICH_STYLE_YELLOW
+
+if TYPE_CHECKING:
+    pass
+
+
+class VisualModeViewer:
+    """Main class for visual mode viewing of raw message content."""
+
+    def __init__(
+        self,
+        console: Console,
+        on_copy: Optional[Callable[[str], None]] = None,
+    ):
+        self._console = console
+        self._on_copy = on_copy
+        self._ui = VisualModeUI(console)
+        self._input_handler = VisualModeInputHandler(self._ui, on_copy=on_copy)
+
+    def set_messages(self, messages: List[Dict[str, Any]]):
+        self._ui.set_messages(messages)
+
+    def show(self):
+        if not self._ui._messages:
+            self._console.print(
+                Text("No messages to display in visual mode.", style=RICH_STYLE_YELLOW)
+            )
+            return
+
+        self._input_handler.run()

AgentCrew/modules/console/visual_mode/viewer_input_handler.py

@@ -0,0 +1,315 @@
+"""Input handler for visual mode viewer."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Callable
+
+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 .viewer_ui import VisualModeUI
+
+
+class VisualModeInputHandler:
+    """Handles keyboard input for the visual mode viewer."""
+
+    def __init__(
+        self,
+        ui: VisualModeUI,
+        on_copy: Optional[Callable[[str], None]] = None,
+    ):
+        self._ui = ui
+        self._running = False
+        self._g_pressed = False
+        self._on_copy = on_copy
+
+    def _create_key_bindings(self) -> KeyBindings:
+        kb = KeyBindings()
+
+        @kb.add(Keys.Up)
+        @kb.add("k")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("up"):
+                self._ui.render()
+
+        @kb.add(Keys.Down)
+        @kb.add("j")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("down"):
+                self._ui.render()
+
+        @kb.add(Keys.Left)
+        @kb.add("h")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("left"):
+                self._ui.render()
+
+        @kb.add(Keys.Right)
+        @kb.add("l")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("right"):
+                self._ui.render()
+
+        @kb.add("w")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("w")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("word_forward"):
+                self._ui.render()
+
+        @kb.add("b")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("b")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("word_backward"):
+                self._ui.render()
+
+        @kb.add("0")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("0")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("line_start"):
+                self._ui.render()
+
+        @kb.add("$")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("$")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("line_end"):
+                self._ui.render()
+
+        @kb.add("g")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("g")
+                self._ui.render()
+                return
+            if self._g_pressed:
+                self._g_pressed = False
+                if self._ui.move_cursor("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
+            if self._ui.move_cursor("bottom"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlU)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("half_up"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlD)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("half_down"):
+                self._ui.render()
+
+        @kb.add(Keys.PageUp)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("page_up"):
+                self._ui.render()
+
+        @kb.add(Keys.PageDown)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("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._ui.toggle_visual_mode()
+            self._ui.render()
+
+        @kb.add("y")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("y")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            text = self._ui.get_selected_text()
+            if text and self._on_copy:
+                self._on_copy(text)
+            if self._ui._visual_mode:
+                self._ui.toggle_visual_mode()
+                self._ui.render()
+
+        @kb.add("Y")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("Y")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if 0 <= self._ui._cursor_line < len(self._ui._lines):
+                line_text = self._ui._lines[self._ui._cursor_line][0]
+                if self._on_copy:
+                    self._on_copy(line_text)
+
+        @kb.add("/")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("/")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.start_search_mode()
+            self._ui.render()
+
+        @kb.add("n")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("n")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.next_search_match()
+            self._ui.render()
+
+        @kb.add("N")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("N")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.prev_search_match()
+            self._ui.render()
+
+        @kb.add(Keys.Enter)
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.exit_search_mode(clear_results=False)
+                self._ui.render()
+
+        @kb.add(Keys.Backspace)
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.backspace_search()
+                self._ui.render()
+
+        @kb.add(Keys.Escape)
+        def _(event):
+            self._g_pressed = False
+            if self._ui._visual_mode:
+                self._ui.toggle_visual_mode()
+                self._ui.render()
+            elif self._ui._search_mode:
+                self._ui.exit_search_mode(clear_results=True)
+                self._ui.render()
+            else:
+                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
+            event.app.exit()
+
+        @kb.add(Keys.ControlC)
+        def _(event):
+            self._g_pressed = False
+            if self._ui._visual_mode:
+                text = self._ui.get_selected_text()
+                if text and self._on_copy:
+                    self._on_copy(text)
+                self._ui.toggle_visual_mode()
+                self._ui.render()
+            elif self._ui._search_mode:
+                self._ui.exit_search_mode(clear_results=True)
+                self._ui.render()
+            else:
+                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
+
+        return kb
+
+    def run(self):
+        self._running = True
+        self._g_pressed = False
+
+        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 visual mode input handler: {e}")
+        finally:
+            self._ui.stop_live()
+
+        self._running = False
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def stop(self):
+        self._running = False