agentcrew-ai 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

AgentCrew/modules/command_execution/service.py

@@ -2,7 +2,6 @@ import os
 import sys
 import time
 import uuid
-import queue
 import threading
 import subprocess
 import re
@@ -10,12 +9,11 @@ import atexit
 import hashlib
 from typing import Dict, Any, Optional, Tuple, List
 from datetime import datetime
-from .metric import CommandMetrics
 from .types import CommandState, CommandProcess
 from .constants import (
     MAX_CONCURRENT_COMMANDS,
     MAX_COMMAND_LIFETIME,
-    MAX_OUTPUT_SIZE,
+    MAX_OUTPUT_LINES,
     MAX_COMMANDS_PER_MINUTE,
     MAX_INPUT_SIZE,
     BLOCKED_PATTERNS,
@@ -68,9 +66,6 @@ class CommandExecutionService:
         # Rate limiting (application-wide)
         self._rate_limiter: List[float] = []
 
-        # Metrics
-        self.metrics = CommandMetrics()
-
         # Register cleanup on shutdown
         atexit.register(self.shutdown)
 
@@ -242,40 +237,40 @@ class CommandExecutionService:
     def _reader_thread(
         self,
         stream,
-        output_queue: queue.Queue,
+        output_list: list,
+        output_lock: threading.Lock,
         stop_event: threading.Event,
-        max_size: int,
+        max_lines: int,
     ):
         """
-        Read stream line by line into queue with size enforcement.
+        Read stream line by line into persistent list with rolling buffer.
 
-        Uses sentinel values:
-        - ('data', line): Normal output line
-        - ('eof', None): End of stream
-        - ('error', msg): Error occurred
-        - ('size_limit', None): Output size limit reached
-        """
-        total_bytes = 0
+        When output exceeds max_lines, old lines are removed to keep recent output.
 
+        Args:
+            stream: Process stdout or stderr stream
+            output_list: Persistent list to append output lines
+            output_lock: Threading lock for thread-safe list access
+            stop_event: Event to signal thread stop
+            max_lines: Maximum number of lines to keep (rolling buffer)
+        """
         try:
             for line in iter(stream.readline, b""):
                 if stop_event.is_set():
                     break
 
-                total_bytes += len(line)
-                if total_bytes > max_size:
-                    output_queue.put(("size_limit", None))
-                    logger.warning(f"Output size limit ({max_size} bytes) exceeded")
-                    break
-
                 decoded = line.decode("utf-8", errors="replace")
-                output_queue.put(("data", decoded))
+
+                with output_lock:
+                    output_list.append(decoded)
+
+                    # Keep only recent lines using slice
+                    if len(output_list) > max_lines:
+                        output_list[:] = output_list[-max_lines:]
 
         except Exception as e:
             logger.error(f"Reader thread error: {e}")
-            output_queue.put(("error", str(e)))
         finally:
-            output_queue.put(("eof", None))
             stream.close()
 
     def execute_command(
@@ -371,9 +366,10 @@ class CommandExecutionService:
                 target=self._reader_thread,
                 args=(
                     process.stdout,
-                    cmd_process.output_queue,
+                    cmd_process.stdout_lines,
+                    cmd_process.output_lock,
                     cmd_process.stop_event,
-                    MAX_OUTPUT_SIZE,
+                    MAX_OUTPUT_LINES,
                 ),
                 daemon=True,
                 name=f"stdout-reader-{command_id}",
@@ -383,9 +379,10 @@ class CommandExecutionService:
                 target=self._reader_thread,
                 args=(
                     process.stderr,
-                    cmd_process.error_queue,
+                    cmd_process.stderr_lines,
+                    cmd_process.output_lock,
                     cmd_process.stop_event,
-                    MAX_OUTPUT_SIZE,
+                    MAX_OUTPUT_LINES,
                 ),
                 daemon=True,
                 name=f"stderr-reader-{command_id}",
@@ -405,21 +402,10 @@ class CommandExecutionService:
             cmd_process.exit_code = process.returncode
             cmd_process.transition_to(CommandState.COMPLETING)
 
-            output_lines = []
-            error_lines = []
-
-            while not cmd_process.output_queue.empty():
-                msg_type, data = cmd_process.output_queue.get()
-                if msg_type == "data":
-                    output_lines.append(data)
-
-            while not cmd_process.error_queue.empty():
-                msg_type, data = cmd_process.error_queue.get()
-                if msg_type == "data":
-                    error_lines.append(data)
-
-            output = "".join(output_lines)
-            error_output = "".join(error_lines)
+            # Get output from persistent storage (thread-safe)
+            with cmd_process.output_lock:
+                output = "".join(cmd_process.stdout_lines)
+                error_output = "".join(cmd_process.stderr_lines)
 
             duration = time.time() - start_time
 
@@ -433,7 +419,6 @@ class CommandExecutionService:
                 len(output) + len(error_output),
             )
 
-            self.metrics.record_execution(command, duration, "completed")
             self._cleanup_command_internal(command_id)
 
             result = {
@@ -466,22 +451,20 @@ class CommandExecutionService:
             logger.error(f"Command execution error: {e}")
 
             self._audit_log(command, "error", command_id)
-            self.metrics.record_execution(command, time.time() - start_time, "error")
 
             if command_id in self._instances:
                 self._cleanup_command_internal(command_id)
 
             return {"status": "error", "error": f"Execution failed: {str(e)}"}
 
-    def get_command_status(
-        self, command_id: str, consume_output: bool = True
-    ) -> Dict[str, Any]:
+    def get_command_status(self, command_id: str) -> Dict[str, Any]:
         """
         Check status of running command.
 
+        Output is persistent and will be returned in full on every call.
+
         Args:
             command_id: Command identifier
-            consume_output: If True, drain and return queued output
 
         Returns:
             Dict with status, output, exit_code, elapsed_time
@@ -494,30 +477,11 @@ class CommandExecutionService:
 
         exit_code = cmd_process.process.poll()
 
-        output_lines = []
-        error_lines = []
-
-        if consume_output:
-            while not cmd_process.output_queue.empty():
-                try:
-                    msg_type, data = cmd_process.output_queue.get_nowait()
-                    if msg_type == "data":
-                        output_lines.append(data)
-                    elif msg_type == "size_limit":
-                        output_lines.append("\n[OUTPUT SIZE LIMIT REACHED]\n")
-                except queue.Empty:
-                    break
-
-            while not cmd_process.error_queue.empty():
-                try:
-                    msg_type, data = cmd_process.error_queue.get_nowait()
-                    if msg_type == "data":
-                        error_lines.append(data)
-                except queue.Empty:
-                    break
+        # Get output from persistent storage (thread-safe)
+        with cmd_process.output_lock:
+            output = "".join(cmd_process.stdout_lines)
+            error_output = "".join(cmd_process.stderr_lines)
 
-        output = "".join(output_lines)
-        error_output = "".join(error_lines)
         elapsed = time.time() - cmd_process.start_time
 
         if elapsed > MAX_COMMAND_LIFETIME:
@@ -546,7 +510,6 @@ class CommandExecutionService:
                 duration,
                 len(output) + len(error_output),
             )
-            self.metrics.record_execution(cmd_process.command, duration, "completed")
             self._cleanup_command_internal(command_id)
 
             return {
@@ -690,11 +653,6 @@ class CommandExecutionService:
                             pass
 
                     cmd_process.transition_to(CommandState.KILLED)
-                    self.metrics.record_execution(
-                        cmd_process.command,
-                        time.time() - cmd_process.start_time,
-                        "killed",
-                    )
 
                 except Exception as e:
                     logger.error(f"Process termination error: {e}")
@@ -767,10 +725,6 @@ class CommandExecutionService:
         """
         return self.cleanup_command(command_id)
 
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get command execution metrics"""
-        return self.metrics.get_report()
-
     def shutdown(self):
         """Shutdown service and cleanup all running commands"""
         logger.info("Shutting down CommandExecutionService")

AgentCrew/modules/command_execution/tool.py

@@ -6,6 +6,7 @@ Tool definitions and handlers for secure shell command execution.
 
 from typing import Dict, Any, Callable
 from .service import CommandExecutionService
+import os
 
 
 def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
@@ -34,8 +35,7 @@ def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
         },
         "working_dir": {
             "type": "string",
-            "default": "./",
-            "description": "Working directory.",
+            "description": f"Working directory. Current working directory is {os.getcwd()}. Use ./ for current dir.",
         },
         "env_vars": {
             "type": "object",
@@ -50,7 +50,7 @@ def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
             "input_schema": {
                 "type": "object",
                 "properties": args,
-                "required": ["command"],
+                "required": ["command", "working_dir"],
             },
         }
     else:
@@ -62,7 +62,7 @@ def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
                 "parameters": {
                     "type": "object",
                     "properties": args,
-                    "required": ["command"],
+                    "required": ["command", "working_dir"],
                 },
             },
         }
@@ -258,9 +258,7 @@ def get_check_command_status_tool_handler(
         if not command_id:
             raise ValueError("Missing required parameter: command_id")
 
-        result = command_service.get_command_status(
-            command_id=command_id, consume_output=True
-        )
+        result = command_service.get_command_status(command_id=command_id)
 
         if result["status"] == "completed":
             response = f"Command completed.\nExit Code: {result['exit_code']}\nDuration: {result['duration_seconds']}s\n\n"

AgentCrew/modules/command_execution/types.py

@@ -1,4 +1,3 @@
-import queue
 import threading
 import subprocess
 from enum import Enum
@@ -31,13 +30,13 @@ class CommandProcess:
     process: subprocess.Popen
     platform: str
     start_time: float
-    output_queue: queue.Queue = field(default_factory=queue.Queue)
-    error_queue: queue.Queue = field(default_factory=queue.Queue)
+    stdout_lines: List[str] = field(default_factory=list)
+    stderr_lines: List[str] = field(default_factory=list)
+    output_lock: threading.Lock = field(default_factory=threading.Lock)
     state: CommandState = CommandState.QUEUED
     exit_code: Optional[int] = None
     reader_threads: List[threading.Thread] = field(default_factory=list)
     stop_event: threading.Event = field(default_factory=threading.Event)
-    total_output_size: int = 0
     working_dir: Optional[str] = None
 
     def transition_to(self, new_state: CommandState):

AgentCrew/modules/console/command_handlers.py

@@ -346,8 +346,8 @@ class CommandHandlers:
             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()
+            self.console.print(project_table)
+            self.console.print()
 
     def handle_update_behavior_command(
         self, behavior_id: str, behavior_text: str, scope: str = "global"

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."""

AgentCrew/modules/console/console_ui.py

@@ -20,7 +20,6 @@ from .constants import (
     RICH_STYLE_GREEN,
     RICH_STYLE_BLUE,
     RICH_STYLE_YELLOW,
-    RICH_STYLE_GREEN_BOLD,
     RICH_STYLE_YELLOW_BOLD,
     PROMPT_CHAR,
 )
@@ -83,11 +82,17 @@ class ConsoleUI(Observer):
 
         if event == "thinking_started":
             self.ui_effects.stop_loading_animation()  # Stop loading on first chunk
-            self.display_handlers.display_thinking_started(data)  # data is agent_name
+            # self.display_handlers.display_thinking_started(data)  # data is agent_name
         elif event == "thinking_chunk":
-            self.display_handlers.display_thinking_chunk(
-                data
-            )  # data is the thinking chunk
+            self.ui_effects.update_live_display(data, is_thinking=True)
+            # self.display_handlers.display_thinking_chunk(
+            #     data
+            # )  # data is the thinking chunk
+            #
+        elif event == "thinking_completed":
+            self.ui_effects.finish_response(
+                self.ui_effects.updated_text, is_thinking=True
+            )
         elif event == "user_message_created":
             pass
         elif event == "response_chunk":
@@ -178,10 +183,6 @@ class ConsoleUI(Observer):
                 f"{data['agent_name'] if 'agent_name' in data else 'other'} agent"
             )
             self.display_handlers.display_message(transfer_text)
-        elif event == "agent_continue":
-            self.display_handlers.display_message(
-                Text(f"\n🤖 {data.upper()}:", style=RICH_STYLE_GREEN_BOLD)
-            )
         elif event == "jump_performed":
             jump_text = Text(
                 f"🕰️ Jumping to turn {data['turn_number']}...\n",
@@ -189,12 +190,11 @@ class ConsoleUI(Observer):
             )
             preview_text = Text("Conversation rewound to: ", style=RICH_STYLE_YELLOW)
             preview_text.append(data["preview"])
+            self._clean_and_reprint_chat()
 
             self.display_handlers.display_message(jump_text)
             self.display_handlers.display_message(preview_text)
             self.input_handler.set_current_buffer(data["message"])
-        elif event == "thinking_completed":
-            self.display_handlers.display_divider()
         elif event == "file_processing":
             self.ui_effects.stop_loading_animation()  # Stop loading on first chunk
             self.display_handlers.add_file(data["file_path"])
@@ -286,25 +286,14 @@ class ConsoleUI(Observer):
         Signal handler for SIGWINCH.
         This function is called when the terminal window is resized.
         """
-        import os
         import time
 
         if self.input_handler.is_message_processing or self._is_resizing:
             return  # Ignore resize during message processing
         self._is_resizing = True
         time.sleep(0.5)  # brief pause to allow resize to complete
-        os.system("cls" if os.name == "nt" else "printf '\033c'")
-        self.display_handlers.display_loaded_conversation(
-            self.message_handler.streamline_messages, self.message_handler.agent.name
-        )
-        self.display_handlers.print_prompt_prefix(
-            self.message_handler.agent.name,
-            self.message_handler.agent.get_model(),
-            self.message_handler.tool_manager.get_effective_yolo_mode(),
-        )
-
+        self._clean_and_reprint_chat()
         self.display_handlers.print_divider("👤 YOU: ", with_time=True)
-
         prompt = Text(
             PROMPT_CHAR,
             style=RICH_STYLE_BLUE,
@@ -318,6 +307,21 @@ class ConsoleUI(Observer):
         self.console.print(prompt, end="")
         self._is_resizing = False
 
+    def _clean_and_reprint_chat(self):
+        """Clear and reprint the chat display."""
+
+        import os
+
+        os.system("cls" if os.name == "nt" else "printf '\033c'")
+        self.display_handlers.display_loaded_conversation(
+            self.message_handler.streamline_messages, self.message_handler.agent.name
+        )
+        self.display_handlers.print_prompt_prefix(
+            self.message_handler.agent.name,
+            self.message_handler.agent.get_model(),
+            self.message_handler.tool_manager.get_effective_yolo_mode(),
+        )
+
     def start_streaming_response(self, agent_name: str):
         """Start streaming the assistant's response."""
         self.ui_effects.start_streaming_response(agent_name)