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

AgentCrew/modules/console/diff_display.py

@@ -4,6 +4,7 @@ Provides split view diff display with syntax highlighting.
 """
 
 import difflib
+from typing import List, Dict
 from rich.text import Text
 from rich.table import Table
 from rich.box import SIMPLE_HEAD
@@ -16,67 +17,37 @@ class DiffDisplay:
     """Helper class for creating split diff views."""
 
     @staticmethod
-    def has_search_replace_blocks(text: str) -> bool:
-        """Check if text contains search/replace blocks."""
-        return (
-            "<<<<<<< SEARCH" in text and "=======" in text and ">>>>>>> REPLACE" in text
+    def has_search_replace_blocks(blocks: List[Dict]) -> bool:
+        """Check if input is a valid list of search/replace blocks."""
+        if not isinstance(blocks, list):
+            return False
+        return len(blocks) > 0 and all(
+            isinstance(b, dict) and "search" in b and "replace" in b for b in blocks
         )
 
     @staticmethod
-    def parse_search_replace_blocks(blocks_text: str) -> list:
+    def parse_search_replace_blocks(blocks: List[Dict]) -> List[Dict]:
         """
-        Parse search/replace blocks from text.
+        Parse search/replace blocks from list format.
 
         Args:
-            blocks_text: Text containing search/replace blocks
+            blocks: List of dicts with 'search' and 'replace' keys
 
         Returns:
             List of dicts with 'index', 'search', and 'replace' keys
         """
-        blocks = []
-        lines = blocks_text.split("\n")
-        i = 0
-        block_index = 0
-
-        while i < len(lines):
-            if lines[i].strip() == "<<<<<<< SEARCH":
-                search_lines = []
-                i += 1
-
-                while i < len(lines) and lines[i].strip() != "=======":
-                    search_lines.append(lines[i])
-                    i += 1
-
-                if i >= len(lines):
-                    break
-
-                i += 1
-                replace_lines = []
-
-                while (
-                    i < len(lines)
-                    and lines[i].strip() != ">>>>>>> REPLACE"
-                    and lines[i].strip() != "======="
-                ):
-                    replace_lines.append(lines[i])
-                    i += 1
-
-                if i >= len(lines):
-                    break
-
-                blocks.append(
-                    {
-                        "index": block_index,
-                        "search": "\n".join(search_lines),
-                        "replace": "\n".join(replace_lines),
-                    }
-                )
-                block_index += 1
-                i += 1
-            else:
-                i += 1
-
-        return blocks
+        if not isinstance(blocks, list):
+            return []
+
+        return [
+            {
+                "index": i,
+                "search": block.get("search", ""),
+                "replace": block.get("replace", ""),
+            }
+            for i, block in enumerate(blocks)
+            if isinstance(block, dict)
+        ]
 
     @staticmethod
     def create_split_diff_table(

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."""
@@ -157,34 +270,37 @@ class DisplayHandlers:
                 f"  - {agent_name}{current}: {agent_data['description']}"
             )
 
-    def display_conversations(self, conversations: List[Dict[str, Any]]):
-        """Display available conversations."""
+    def display_conversations(
+        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
+        """
         if not conversations:
             self.console.print(
                 Text("No saved conversations found.", style=RICH_STYLE_YELLOW)
             )
-            return
-
-        self.console.print(Text("Available conversations:", style=RICH_STYLE_YELLOW))
-        for i, convo in enumerate(conversations[:30], 1):
-            # Format timestamp for better readability
-            timestamp = convo.get("timestamp", "Unknown")
-            if isinstance(timestamp, (int, float)):
-                timestamp = datetime.fromtimestamp(timestamp).strftime(
-                    "%Y-%m-%d %H:%M:%S"
-                )
-
-            title = convo.get("title", "Untitled")
-            convo_id = convo.get("id", "unknown")
+            return None
 
-            # Display conversation with index for easy selection
-            self.console.print(f"  {i}. {title} [{convo_id}]")
-            self.console.print(f"     Created: {timestamp}")
+        from .conversation_browser.browser import ConversationBrowser
 
-            # Show a preview if available
-            if "preview" in convo:
-                self.console.print(f"     Preview: {convo['preview']}")
-            self.console.print("")
+        browser = ConversationBrowser(
+            console=self.console,
+            get_conversation_history=get_history_callback,
+            on_delete=delete_callback,
+        )
+        browser.set_conversations(conversations)
+        return browser.show()
 
     def display_consolidation_result(self, result: Dict[str, Any]):
         """Display information about a consolidation operation."""

AgentCrew/modules/console/tool_display.py

@@ -109,9 +109,7 @@ class ToolDisplayHandlers:
             )
         )
 
-    def _display_write_or_edit_file_use(
-        self, tool_use: Dict, file_path: str, blocks_text: str
-    ):
+    def _display_write_or_edit_file_use(self, tool_use: Dict, file_path: str, blocks):
         """Display write_or_edit_file tool with split diff view."""
         tool_icon = self.get_tool_icon(tool_use["name"])
 
@@ -121,10 +119,10 @@ class ToolDisplayHandlers:
 
         self.console.print(Panel(header, box=HORIZONTALS, title_align="left"))
 
-        blocks = DiffDisplay.parse_search_replace_blocks(blocks_text)
+        parsed_blocks = DiffDisplay.parse_search_replace_blocks(blocks)
 
-        if blocks:
-            for block in blocks:
+        if parsed_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/file_editing/service.py

@@ -41,21 +41,21 @@ class FileEditingService:
     def write_or_edit_file(
         self,
         file_path: str,
-        percentage_to_change: float,
         text_or_search_replace_blocks: str,
+        is_search_replace: bool = False,
         agent_name: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Main entry point for file editing.
 
         Decision logic:
-        - percentage > 50: Full file write
-        - percentage <= 50: Search/replace blocks
+        - is_search_replace=False: Full file write
+        - is_search_replace=True: Search/replace blocks
 
         Args:
             file_path: Path to file (absolute or relative, ~ supported)
-            percentage_to_change: Percentage of lines changing (0-100)
             text_or_search_replace_blocks: Full content or search/replace blocks
+            is_search_replace: True for search/replace mode, False for full content
             agent_name: Optional agent name for permission checks
 
         Returns:
@@ -94,12 +94,12 @@ class FileEditingService:
                 }
 
         try:
-            if percentage_to_change > 50:
-                result = self._write_full_file(file_path, text_or_search_replace_blocks)
-            else:
+            if is_search_replace:
                 result = self._apply_search_replace(
                     file_path, text_or_search_replace_blocks
                 )
+            else:
+                result = self._write_full_file(file_path, text_or_search_replace_blocks)
 
             if result["status"] != "success":
                 return result
@@ -166,7 +166,7 @@ class FileEditingService:
             return {
                 "status": "error",
                 "error": f"File not found: {file_path}",
-                "suggestion": "Use percentage_to_change > 50 to create new files",
+                "suggestion": "Use full content mode (string) to create new files",
             }
 
         try:

AgentCrew/modules/file_editing/tool.py

@@ -4,39 +4,42 @@ File editing tool definitions and handlers for AgentCrew.
 Provides file_write_or_edit tool for intelligent file editing with search/replace blocks.
 """
 
-from typing import Dict, Any, Callable, Optional
+from typing import Dict, Any, Callable, Optional, List
 from .service import FileEditingService
 
 
-def get_file_write_or_edit_tool_definition(provider="claude") -> Dict[str, Any]:
-    """
-    Get tool definition for file editing.
+def convert_blocks_to_string(blocks: List[Dict[str, str]]) -> str:
+    result_parts = []
+    for block in blocks:
+        search_text = block.get("search", "")
+        replace_text = block.get("replace", "")
+        block_str = (
+            f"<<<<<<< SEARCH\n{search_text}\n=======\n{replace_text}\n>>>>>>> REPLACE"
+        )
+        result_parts.append(block_str)
+    return "\n".join(result_parts)
+
 
-    Args:
-        provider: LLM provider name ("claude", "openai", "groq", "google")
+def is_full_content_mode(blocks: List[Dict[str, str]]) -> bool:
+    if len(blocks) == 1:
+        block = blocks[0]
+        search_text = block.get("search", "")
+        return search_text == ""
+    return False
 
-    Returns:
-        Provider-specific tool definition
-    """
-    tool_description = """Write/edit files via search/replace blocks or full content.
 
-LOGIC: percentage_to_change >50 = full content | ≤50 = search/replace
+def get_file_write_or_edit_tool_definition(provider="claude") -> Dict[str, Any]:
+    tool_description = """Write/edit files via search/replace blocks.
 
-SEARCH/REPLACE BLOCK FORMAT:
-<<<<<<< SEARCH
-[exact content to find]
-=======
-[replacement content]
->>>>>>> REPLACE
+FORMAT: Array of {"search": "...", "replace": "..."} objects
+- Empty search + replace with content = write full file content
+- Non-empty search + replace = search/replace operation
+- Non-empty search + empty replace = delete matched content
 
 RULES:
 1. SEARCH must match exactly (character-perfect)
 2. Include changing lines +0-3 context
-3. Multiple blocks in one call OK
-4. Preserve whitespace/indentation
-5. Empty REPLACE = delete
-
-EXAMPLES: Add import (existing+new) | Delete (full→empty) | Modify (signature+changes)
+3. Preserve whitespace/indentation
 
 Auto syntax check (30+ langs) with rollback on error
 """
@@ -46,19 +49,28 @@ Auto syntax check (30+ langs) with rollback on error
             "type": "string",
             "description": "Path (absolute/relative). Use ~ for home. Ex: './src/main.py'",
         },
-        "percentage_to_change": {
-            "type": "number",
-            "description": "% lines changing (0-100). >50=full, ≤50=blocks",
-        },
         "text_or_search_replace_blocks": {
-            "type": "string",
-            "description": "Full content (>50%) OR search/replace blocks (≤50%)",
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "search": {
+                        "type": "string",
+                        "description": "Exact content to find. Empty string means full file write mode.",
+                    },
+                    "replace": {
+                        "type": "string",
+                        "description": "Replacement content (empty string to delete)",
+                    },
+                },
+                "required": ["search", "replace"],
+            },
+            "description": 'Array of search/replace blocks. For full file write: [{"search": "", "replace": "full content"}]. For edits: [{"search": "exact match", "replace": "replacement"}]',
         },
     }
 
     tool_required = [
         "file_path",
-        "percentage_to_change",
         "text_or_search_replace_blocks",
     ]
 
@@ -72,7 +84,7 @@ Auto syntax check (30+ langs) with rollback on error
                 "required": tool_required,
             },
         }
-    else:  # provider in ["openai", "google", "groq"] or other OpenAI-compatible
+    else:
         return {
             "type": "function",
             "function": {
@@ -90,44 +102,37 @@ Auto syntax check (30+ langs) with rollback on error
 def get_file_write_or_edit_tool_handler(
     file_editing_service: FileEditingService,
 ) -> Callable:
-    """
-    Get the handler function for the file editing tool.
-
-    Args:
-        file_editing_service: FileEditingService instance
-
-    Returns:
-        Handler function
-    """
-
     def handle_file_write_or_edit(**params) -> str:
-        """
-        Tool execution handler.
-
-        Args:
-            **params: Tool parameters (file_path, percentage_to_change, text_or_search_replace_blocks)
-
-        Returns:
-            Success or error message
-        """
         file_path = params.get("file_path")
-        percentage_to_change = params.get("percentage_to_change")
-        text_or_search_replace_blocks = params.get("text_or_search_replace_blocks")
+        blocks = params.get("text_or_search_replace_blocks")
 
         if not file_path:
             raise ValueError("Error: No file path provided.")
 
-        if percentage_to_change is None:
-            raise ValueError("Error: No percentage_to_change provided.")
+        if blocks is None:
+            raise ValueError("Error: No search/replace blocks provided.")
 
-        if not text_or_search_replace_blocks:
-            raise ValueError("Error: No content or search/replace blocks provided.")
+        if not isinstance(blocks, list):
+            raise ValueError(
+                "Error: text_or_search_replace_blocks must be an array of search/replace objects."
+            )
 
-        result = file_editing_service.write_or_edit_file(
-            file_path=file_path,
-            percentage_to_change=float(percentage_to_change),
-            text_or_search_replace_blocks=text_or_search_replace_blocks,
-        )
+        full_content_mode = is_full_content_mode(blocks)
+
+        if full_content_mode:
+            content = blocks[0].get("replace", "")
+            result = file_editing_service.write_or_edit_file(
+                file_path=file_path,
+                is_search_replace=False,
+                text_or_search_replace_blocks=content,
+            )
+        else:
+            blocks_string = convert_blocks_to_string(blocks)
+            result = file_editing_service.write_or_edit_file(
+                file_path=file_path,
+                is_search_replace=True,
+                text_or_search_replace_blocks=blocks_string,
+            )
 
         if result["status"] == "success":
             parts = [f"{result['file_path']}"]
@@ -171,13 +176,6 @@ def get_file_write_or_edit_tool_handler(
 
 
 def register(service_instance: Optional[FileEditingService] = None, agent=None):
-    """
-    Register file editing tools with AgentCrew tool registry.
-
-    Args:
-        service_instance: Optional FileEditingService instance
-        agent: Optional agent to register with directly
-    """
     from AgentCrew.modules.tools.registration import register_tool
 
     if service_instance is None: