agentcrew-ai 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

AgentCrew/modules/chat/message/handler.py

@@ -279,7 +279,7 @@ class MessageHandler(Observable):
                     # Notify about response progress
                     if not self.agent.is_streaming():
                         # Delays it a bit when using without stream
-                        time.sleep(0.5)
+                        time.sleep(0.3)
                     self._notify("response_chunk", (chunk_text, assistant_response))
                     if voice_sentence is not None:
                         if (
@@ -321,6 +321,8 @@ class MessageHandler(Observable):
                                     .lstrip("\n")
                                 )
 
+            self.stream_generator = None
+
             # End thinking when break the response stream
             if not end_thinking and start_thinking:
                 self._notify("thinking_completed", thinking_content)
@@ -386,11 +388,6 @@ class MessageHandler(Observable):
 
                 return await self.get_assistant_response()
 
-            self.stream_generator = None
-
-            if thinking_content:
-                self._notify("agent_continue", self.agent.name)
-
             # Add assistant response to messages
             if assistant_response.strip():
                 self._messages_append(

AgentCrew/modules/code_analysis/service.py

@@ -26,6 +26,7 @@ class CodeAnalysisService:
         ".cxx": "cpp",
         ".hxx": "cpp",
         ".rb": "ruby",
+        ".sh": "bash",
         ".rake": "ruby",
         ".go": "go",
         ".rs": "rust",
@@ -36,6 +37,7 @@ class CodeAnalysisService:
         ".json": "config",
         ".toml": "config",
         ".yaml": "config",
+        ".yml": "config",
         # Add more languages as needed
     }
 
@@ -784,6 +786,43 @@ class CodeAnalysisService:
                                 return result
                             break  # Only capture the first identifier
                         return result
+                else:
+                    if node.type in [
+                        "type_declaration",
+                        "function_declaration",
+                        "method_declaration",
+                        "interface_declaration",
+                    ]:
+                        for child in node.children:
+                            if (
+                                child.type == "identifier"
+                                or child.type == "field_identifier"
+                            ):
+                                result["name"] = self._extract_node_text(
+                                    child, source_code
+                                )
+                                result["first_line"] = (
+                                    self._extract_node_text(node, source_code)
+                                    .split("\n")[0]
+                                    .strip("{")
+                                )
+                                return result
+                        return result
+                    elif (
+                        node.type == "var_declaration"
+                        or node.type == "const_declaration"
+                    ):
+                        # Handle Go variable and constant declarations
+                        for child in node.children:
+                            if child.type == "var_spec" or child.type == "const_spec":
+                                for subchild in child.children:
+                                    if subchild.type == "identifier":
+                                        result["type"] = "variable_declaration"
+                                        result["name"] = self._extract_node_text(
+                                            subchild, source_code
+                                        )
+                                        return result
+                        return result
 
                 # Recursively process children
                 children = []

AgentCrew/modules/code_analysis/tool.py

@@ -72,7 +72,16 @@ def get_code_analysis_tool_handler(
         if isinstance(result, dict) and "error" in result:
             raise Exception(f"Failed to analyze code: {result['error']}")
 
-        return result
+        return [
+            {
+                "type": "text",
+                "text": result,
+            },
+            {
+                "type": "text",
+                "text": "Base on the code analysis, learn about the patterns and development flows, adapt project behaviors if possible for better response.",
+            },
+        ]
 
     return handler
 

AgentCrew/modules/console/command_handlers.py

@@ -12,6 +12,7 @@ import subprocess
 import sys
 
 from rich.text import Text
+from rich.table import Table
 
 from .constants import (
     RICH_STYLE_YELLOW,
@@ -19,7 +20,7 @@ from .constants import (
 from AgentCrew.modules.config.config_management import ConfigManagement
 from loguru import logger
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict
 
 if TYPE_CHECKING:
     from .console_ui import ConsoleUI
@@ -38,6 +39,7 @@ class CommandHandlers:
         """
         self.console = console_ui.console
         self.message_handler = console_ui.message_handler
+        self.context_service = console_ui.message_handler.persistent_service
 
     def open_file_in_editor(self, file_path: str) -> bool:
         """
@@ -278,3 +280,186 @@ class CommandHandlers:
                 )
             )
             logger.error(f"Import agent error: {str(e)}", exc_info=True)
+
+    def handle_list_behaviors_command(self) -> None:
+        try:
+            if not self.context_service:
+                self.console.print(
+                    Text(
+                        "❌ Context persistence service not available", style="bold red"
+                    )
+                )
+                return
+
+            global_behaviors = self.context_service.get_adaptive_behaviors(
+                self.message_handler.agent.name
+            )
+            project_behaviors = self.context_service.get_adaptive_behaviors(
+                self.message_handler.agent.name, is_local=True
+            )
+
+            if not global_behaviors and not project_behaviors:
+                self.console.print(
+                    Text("ℹ️  No adaptive behaviors found.", style=RICH_STYLE_YELLOW)
+                )
+                return
+
+            self._display_behaviors_table(global_behaviors, project_behaviors)
+
+        except Exception as e:
+            self.console.print(
+                Text(f"❌ Error listing behaviors: {str(e)}", style="bold red")
+            )
+            logger.error(f"List behaviors error: {str(e)}", exc_info=True)
+
+    def _display_behaviors_table(
+        self,
+        global_behaviors: Dict[str, str],
+        project_behaviors: Dict[str, str],
+    ) -> None:
+        if global_behaviors:
+            global_table = Table(
+                title="🌍 Global Behaviors",
+                show_header=True,
+                header_style="bold cyan",
+                title_style="bold blue",
+            )
+            global_table.add_column("ID", style="yellow", no_wrap=True)
+            global_table.add_column("Behavior", style="white")
+
+            for behavior_id, behavior_text in global_behaviors.items():
+                global_table.add_row(behavior_id, behavior_text)
+
+            self.console.print(global_table)
+            self.console.print()
+
+        if project_behaviors:
+            project_table = Table(
+                title="📁 Project Behaviors",
+                show_header=True,
+                header_style="bold green",
+                title_style="bold magenta",
+            )
+            project_table.add_column("ID", style="yellow", no_wrap=True)
+            project_table.add_column("Behavior", style="white")
+
+            for behavior_id, behavior_text in project_behaviors.items():
+                project_table.add_row(behavior_id, behavior_text)
+
+            self.console.print(project_table)
+            self.console.print()
+
+    def handle_update_behavior_command(
+        self, behavior_id: str, behavior_text: str, scope: str = "global"
+    ) -> None:
+        try:
+            if not self.context_service:
+                self.console.print(
+                    Text(
+                        "❌ Context persistence service not available", style="bold red"
+                    )
+                )
+                return
+
+            behavior_text = behavior_text.strip()
+
+            if not behavior_text:
+                self.console.print(
+                    Text("❌ Behavior text cannot be empty", style="bold red")
+                )
+                return
+
+            behavior_lower = behavior_text.lower().strip()
+            if not behavior_lower.startswith("when"):
+                self.console.print(
+                    Text(
+                        "❌ Behavior must follow 'when..., [action]...' format",
+                        style="bold red",
+                    )
+                )
+                return
+
+            is_local = scope == "project"
+            success = self.context_service.store_adaptive_behavior(
+                self.message_handler.agent.name,
+                behavior_id,
+                behavior_text,
+                is_local=is_local,
+            )
+
+            if success:
+                self.console.print(
+                    Text(
+                        f"✅ Behavior '{behavior_id}' updated successfully ({scope} scope)",
+                        style="bold green",
+                    )
+                )
+            else:
+                self.console.print(Text("❌ Failed to save behavior", style="bold red"))
+
+        except ValueError as e:
+            self.console.print(
+                Text(f"❌ Invalid behavior format: {str(e)}", style="bold red")
+            )
+        except Exception as e:
+            self.console.print(
+                Text(f"❌ Error updating behavior: {str(e)}", style="bold red")
+            )
+            logger.error(f"Update behavior error: {str(e)}", exc_info=True)
+
+    def handle_delete_behavior_command(
+        self, behavior_id: str, scope: str = "global"
+    ) -> None:
+        try:
+            if not self.context_service:
+                self.console.print(
+                    Text(
+                        "❌ Context persistence service not available", style="bold red"
+                    )
+                )
+                return
+
+            is_local = scope == "project"
+
+            success = self.context_service.remove_adaptive_behavior(
+                self.message_handler.agent.name, behavior_id, is_local=is_local
+            )
+            if success:
+                self.console.print(
+                    Text(
+                        f"✅ Behavior '{behavior_id}' deleted successfully",
+                        style="bold green",
+                    )
+                )
+            else:
+                self.console.print(
+                    Text(
+                        f"❌ Failed to delete behavior '{behavior_id}'",
+                        style="bold red",
+                    )
+                )
+
+        except Exception as e:
+            self.console.print(
+                Text(f"❌ Error deleting behavior: {str(e)}", style="bold red")
+            )
+            logger.error(f"Delete behavior error: {str(e)}", exc_info=True)
+
+    def get_all_behavior_ids(self) -> list[str]:
+        try:
+            if not self.context_service:
+                return []
+
+            all_behaviors = self.context_service.get_adaptive_behaviors(
+                self.message_handler.agent.name
+            ) | self.context_service.get_adaptive_behaviors(
+                self.message_handler.agent.name, is_local=True
+            )
+            behavior_ids = []
+
+            for id, _ in all_behaviors.items():
+                behavior_ids.extend(id)
+
+            return behavior_ids
+        except Exception:
+            return []

AgentCrew/modules/console/completers.py

@@ -121,6 +121,7 @@ class ChatCompleter(Completer):
         self.jump_completer = JumpCompleter(message_handler)
         self.mcp_completer = MCPCompleter(message_handler)
         self.drop_completer = DropCompleter(message_handler)
+        self.behavior_completer = BehaviorIDCompleter(message_handler)
 
     def get_completions(self, document, complete_event):
         text = document.text
@@ -140,6 +141,8 @@ class ChatCompleter(Completer):
             yield from self.file_completer.get_completions(document, complete_event)
         elif text.startswith("/drop "):
             yield from self.drop_completer.get_completions(document, complete_event)
+        elif text.startswith(("/delete_behavior ", "/update_behavior ")):
+            yield from self.behavior_completer.get_completions(document, complete_event)
         elif text.startswith("/export_agent "):
             remaining_text = text[14:]  # Remove "/export_agent "
 
@@ -221,6 +224,15 @@ class ChatCompleter(Completer):
                 "/toggle_session_yolo",
                 "Toggle Auto-Approve Mode for Tool Calls (this session only)",
             ),
+            ("/list_behaviors", "List all agent adaptive behaviors"),
+            (
+                "/update_behavior",
+                "Update or create an adaptive behavior (usage: /update_behavior <scope> <id> <behavior_text>)",
+            ),
+            (
+                "/delete_behavior",
+                "Delete an adaptive behavior (usage: /delete_behavior <id>)",
+            ),
             ("/exit", "Exit the application"),
             ("/quit", "Exit the application"),
         ]
@@ -305,6 +317,61 @@ class DropCompleter(Completer):
                     )
 
 
+class BehaviorIDCompleter(Completer):
+    """Completer that shows available behavior IDs when typing /delete_behavior or /update_behavior commands."""
+
+    def __init__(self, message_handler=None):
+        self.message_handler = message_handler
+
+    def get_completions(self, document, complete_event):
+        text = document.text
+
+        if text.startswith(
+            (
+                "/delete_behavior global ",
+                "/delete_behavior project ",
+                "/update_behavior global ",
+                "/update_behavior project ",
+            )
+        ):
+            word_before_cursor = document.get_word_before_cursor(
+                pattern=COMPLETER_PATTERN
+            )
+
+            if self.message_handler and self.message_handler.persistent_service:
+                try:
+                    scope = text.split(" ")[1].strip()
+                    all_behaviors = (
+                        self.message_handler.persistent_service.get_adaptive_behaviors(
+                            self.message_handler.agent.name, is_local=scope == "project"
+                        )
+                    )
+                    behavior_ids = []
+                    for id, _ in all_behaviors.items():
+                        behavior_ids.append(id)
+
+                    for behavior_id in behavior_ids:
+                        if behavior_id.startswith(word_before_cursor):
+                            yield Completion(
+                                behavior_id,
+                                start_position=-len(word_before_cursor),
+                                display=behavior_id,
+                            )
+                except Exception:
+                    pass
+        elif text.startswith(("/delete_behavior ", "/update_behavior ")):
+            word_before_cursor = document.get_word_before_cursor(
+                pattern=COMPLETER_PATTERN
+            )
+            for scope in ["global", "project"]:
+                if scope.startswith(word_before_cursor):
+                    yield Completion(
+                        scope,
+                        start_position=-len(word_before_cursor),
+                        display=scope,
+                    )
+
+
 class DirectoryListingCompleter(Completer):
     def __init__(self):
         # Use PathCompleter for the heavy lifting

AgentCrew/modules/console/confirmation_handler.py

@@ -11,6 +11,8 @@ from rich.box import HORIZONTALS
 from rich.console import Group
 import time
 
+from .diff_display import DiffDisplay
+
 from .constants import (
     RICH_STYLE_BLUE,
     RICH_STYLE_BLUE_BOLD,
@@ -45,6 +47,20 @@ class ConfirmationHandler:
             self._handle_ask_tool(tool_use, confirmation_id, message_handler)
             return
 
+        # Special handling for 'write_or_edit_file' tool with search/replace blocks
+        if tool_use["name"] == "write_or_edit_file":
+            file_path = tool_use["input"].get("file_path", "")
+            text_or_blocks = tool_use["input"].get("text_or_search_replace_blocks", "")
+
+            if DiffDisplay.has_search_replace_blocks(text_or_blocks):
+                self._display_write_or_edit_file_diff(
+                    tool_use, file_path, text_or_blocks
+                )
+                self._get_and_handle_tool_response(
+                    tool_use, confirmation_id, message_handler
+                )
+                return
+
         tool_texts_group = []
         header = Text("🔧 Tool ", style=RICH_STYLE_YELLOW)
         header.append(tool_use["name"], style=RICH_STYLE_BLUE_BOLD)
@@ -72,8 +88,71 @@ class ConfirmationHandler:
             )
         )
 
-        # Get user response
+        self._get_and_handle_tool_response(tool_use, confirmation_id, message_handler)
+
+    def _handle_ask_tool(self, tool_use, confirmation_id, message_handler):
+        """Handle the ask tool - display question and guided answers."""
+        question = tool_use["input"].get("question", "")
+        guided_answers = tool_use["input"].get("guided_answers", [])
+        if isinstance(guided_answers, str):
+            guided_answers = guided_answers.strip("\n ").splitlines()
+
+        guided_answers.append("Custom your answer")
+
+        self.input_handler._stop_input_thread()
+        # Display the question
+        self.console.print(
+            Text("\n❓ Agent is asking for clarification:", style=RICH_STYLE_BLUE_BOLD)
+        )
+        response = self.input_handler.get_choice_input(f"{question}", guided_answers)
+
+        if response == "Custom your answer":
+            custom_answer = self.input_handler.get_prompt_input("Input your answer:")
+            message_handler.resolve_tool_confirmation(
+                confirmation_id, {"action": "answer", "answer": custom_answer}
+            )
+        elif response:
+            message_handler.resolve_tool_confirmation(
+                confirmation_id, {"action": "answer", "answer": response}
+            )
+
+        else:
+            message_handler.resolve_tool_confirmation(
+                confirmation_id, {"action": "answer", "answer": "Cancelled by user"}
+            )
+
+        self._ui.start_loading_animation()
+
+        self.input_handler._start_input_thread()
+
+    def _display_write_or_edit_file_diff(self, tool_use, file_path, blocks_text):
+        """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)
+        header.append(" - Search/Replace Blocks", style=RICH_STYLE_YELLOW)
+
+        self.console.print(
+            Panel(header, box=HORIZONTALS, border_style=RICH_STYLE_YELLOW)
+        )
+
+        blocks = DiffDisplay.parse_search_replace_blocks(blocks_text)
+
+        if not blocks:
+            self.console.print(
+                Text("No valid search/replace blocks found", style=RICH_STYLE_RED)
+            )
+            return
+
+        for block in blocks:
+            diff_table = DiffDisplay.create_split_diff_table(
+                block["search"], block["replace"], max_width=self.console.width - 4
+            )
+            self.console.print(diff_table)
+
+    def _get_and_handle_tool_response(self, tool_use, confirmation_id, message_handler):
+        """Get user response for tool confirmation and handle it."""
         self.input_handler._stop_input_thread()
+
         choices = [
             "yes",
             "no",
@@ -91,11 +170,11 @@ class ConfirmationHandler:
                 confirmation_id, {"action": "approve"}
             )
         elif response == choices[1]:
-            response = self.input_handler.get_prompt_input(
+            deny_reason = self.input_handler.get_prompt_input(
                 "Please tell me why you are denying this tool: "
             )
             message_handler.resolve_tool_confirmation(
-                confirmation_id, {"action": "deny", "reason": response}
+                confirmation_id, {"action": "deny", "reason": deny_reason}
             )
         elif response == choices[2]:
             message_handler.resolve_tool_confirmation(
@@ -120,44 +199,10 @@ class ConfirmationHandler:
                 style=RICH_STYLE_YELLOW,
             )
             self.console.print(saved_text)
-        self._ui.start_loading_animation()
-        self.input_handler._start_input_thread()
-        time.sleep(0.2)  # Small delay to between tool calls
-
-    def _handle_ask_tool(self, tool_use, confirmation_id, message_handler):
-        """Handle the ask tool - display question and guided answers."""
-        question = tool_use["input"].get("question", "")
-        guided_answers = tool_use["input"].get("guided_answers", [])
-        if isinstance(guided_answers, str):
-            guided_answers = guided_answers.strip("\n ").splitlines()
-
-        guided_answers.append("Custom your answer")
-
-        self.input_handler._stop_input_thread()
-        # Display the question
-        self.console.print(
-            Text("\n❓ Agent is asking for clarification:", style=RICH_STYLE_BLUE_BOLD)
-        )
-        response = self.input_handler.get_choice_input(f"{question}", guided_answers)
-
-        if response == "Custom your answer":
-            custom_answer = self.input_handler.get_prompt_input("Input your answer:")
-            message_handler.resolve_tool_confirmation(
-                confirmation_id, {"action": "answer", "answer": custom_answer}
-            )
-        elif response:
-            message_handler.resolve_tool_confirmation(
-                confirmation_id, {"action": "answer", "answer": response}
-            )
-
-        else:
-            message_handler.resolve_tool_confirmation(
-                confirmation_id, {"action": "answer", "answer": "Cancelled by user"}
-            )
 
         self._ui.start_loading_animation()
-
         self.input_handler._start_input_thread()
+        time.sleep(0.2)
 
     def display_mcp_prompt_confirmation(self, prompt_data, input_queue):
         """Display MCP prompt confirmation request and get user response."""