janito 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

janito/token_report.py

@@ -1,145 +1,154 @@
-"""
-Module for generating token usage reports.
-"""
-
-from rich.console import Console
-from rich.panel import Panel
-
-def generate_token_report(agent, verbose=False):
-    """
-    Generate a token usage report.
-    
-    Args:
-        agent: The Claude agent instance
-        verbose: Whether to show detailed token usage information
-        
-    Returns:
-        None - prints the report to the console
-    """
-    console = Console()
-    usage = agent.get_tokens()
-    cost = agent.get_token_cost()
-    
-    text_usage = usage.text_usage
-    tools_usage = usage.tools_usage
-    
-    if verbose:
-        total_usage = usage.total_usage
-        
-        # Get costs from the cost object
-        text_input_cost = cost.input_cost
-        text_output_cost = cost.output_cost
-        text_cache_creation_cost = cost.cache_creation_cost
-        text_cache_read_cost = cost.cache_read_cost
-        
-        tools_input_cost = cost.input_cost
-        tools_output_cost = cost.output_cost
-        tools_cache_creation_cost = cost.cache_creation_cost
-        tools_cache_read_cost = cost.cache_read_cost
-        
-        # Format costs
-        format_cost = lambda cost: f"{cost * 100:.2f}¢" if cost < 1.0 else f"${cost:.6f}"
-        
-        console.print("\n[bold blue]Detailed Token Usage:[/bold blue]")
-        console.print(f"Text Input tokens: {text_usage.input_tokens}")
-        console.print(f"Text Output tokens: {text_usage.output_tokens}")
-        console.print(f"Text Cache Creation tokens: {text_usage.cache_creation_input_tokens}")
-        console.print(f"Text Cache Read tokens: {text_usage.cache_read_input_tokens}")
-        console.print(f"Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens + text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens}")
-        
-        console.print(f"Tool Input tokens: {tools_usage.input_tokens}")
-        console.print(f"Tool Output tokens: {tools_usage.output_tokens}")
-        console.print(f"Tool Cache Creation tokens: {tools_usage.cache_creation_input_tokens}")
-        console.print(f"Tool Cache Read tokens: {tools_usage.cache_read_input_tokens}")
-        console.print(f"Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens + tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens}")
-        
-        console.print(f"Total tokens: {total_usage.input_tokens + total_usage.output_tokens + total_usage.cache_creation_input_tokens + total_usage.cache_read_input_tokens}")
-        
-        console.print("\n[bold blue]Pricing Information:[/bold blue]")
-        console.print(f"Text Input cost: {format_cost(text_input_cost)}")
-        console.print(f"Text Output cost: {format_cost(text_output_cost)}")
-        console.print(f"Text Cache Creation cost: {format_cost(text_cache_creation_cost)}")
-        console.print(f"Text Cache Read cost: {format_cost(text_cache_read_cost)}")
-        console.print(f"Text Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost)}")
-        
-        console.print(f"Tool Input cost: {format_cost(tools_input_cost)}")
-        console.print(f"Tool Output cost: {format_cost(tools_output_cost)}")
-        console.print(f"Tool Cache Creation cost: {format_cost(tools_cache_creation_cost)}")
-        console.print(f"Tool Cache Read cost: {format_cost(tools_cache_read_cost)}")
-        console.print(f"Tool Total cost: {format_cost(tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
-        
-        console.print(f"Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost + tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
-        
-        # Show cache delta if available
-        if hasattr(cost, 'cache_delta') and cost.cache_delta:
-            cache_delta = cost.cache_delta
-            console.print(f"\n[bold green]Cache Savings:[/bold green] {format_cost(cache_delta)}")
-            
-            # Calculate percentage savings
-            total_cost_without_cache = cost.total_cost + cache_delta
-            if total_cost_without_cache > 0:
-                savings_percentage = (cache_delta / total_cost_without_cache) * 100
-                console.print(f"[bold green]Cache Savings Percentage:[/bold green] {savings_percentage:.2f}%")
-                console.print(f"[bold green]Cost without cache:[/bold green] {format_cost(total_cost_without_cache)}")
-                console.print(f"[bold green]Cost with cache:[/bold green] {format_cost(cost.total_cost)}")
-            
-        # Per-tool breakdown
-        if usage.by_tool:
-            console.print("\n[bold blue]Per-Tool Breakdown:[/bold blue]")
-            try:
-                if hasattr(cost, 'by_tool') and cost.by_tool:
-                    for tool_name, tool_usage in usage.by_tool.items():
-                        tool_input_cost = cost.by_tool[tool_name].input_cost
-                        tool_output_cost = cost.by_tool[tool_name].output_cost
-                        tool_cache_creation_cost = cost.by_tool[tool_name].cache_creation_cost
-                        tool_cache_read_cost = cost.by_tool[tool_name].cache_read_cost
-                        tool_total_cost = tool_input_cost + tool_output_cost + tool_cache_creation_cost + tool_cache_read_cost
-                        
-                        console.print(f"   Tool: {tool_name}")
-                        console.print(f"  Input tokens: {tool_usage.input_tokens}")
-                        console.print(f"  Output tokens: {tool_usage.output_tokens}")
-                        console.print(f"  Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
-                        console.print(f"  Cache Read tokens: {tool_usage.cache_read_input_tokens}")
-                        console.print(f"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
-                        console.print(f"  Total cost: {format_cost(tool_total_cost)}")
-                else:
-                    # Calculate costs manually for each tool if cost.by_tool is not available
-                    for tool_name, tool_usage in usage.by_tool.items():
-                        # Estimate costs based on overall pricing
-                        total_tokens = tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens
-                        estimated_cost = (total_tokens / (usage.total_usage.total_tokens + usage.total_usage.total_cache_tokens)) * cost.total_cost if usage.total_usage.total_tokens > 0 else 0
-                        
-                        console.print(f"   Tool: {tool_name}")
-                        console.print(f"  Input tokens: {tool_usage.input_tokens}")
-                        console.print(f"  Output tokens: {tool_usage.output_tokens}")
-                        console.print(f"  Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
-                        console.print(f"  Cache Read tokens: {tool_usage.cache_read_input_tokens}")
-                        console.print(f"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
-                        console.print(f"  Total cost: {format_cost(estimated_cost)}")
-            except Exception as e:
-                console.print(f"Error: {str(e)}")
-    else:
-        total_tokens = (text_usage.input_tokens + text_usage.output_tokens + 
-                       text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens +
-                       tools_usage.input_tokens + tools_usage.output_tokens +
-                       tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens)
-        
-        # Format costs
-        format_cost = lambda cost: f"{cost * 100:.2f}¢" if cost < 1.0 else f"${cost:.6f}"
-        
-        # Prepare summary message
-        summary = f"Total tokens: {total_tokens} | Cost: {format_cost(cost.total_cost)}"
-        
-        # Add cache savings if available
-        if hasattr(cost, 'cache_delta') and cost.cache_delta != 0:
-            cache_delta = cost.cache_delta
-            total_cost_without_cache = cost.total_cost + cache_delta
-            savings_percentage = 0
-            if total_cost_without_cache > 0:
-                savings_percentage = (cache_delta / total_cost_without_cache) * 100
-            
-            summary += f" | Cache savings: {format_cost(cache_delta)} ({savings_percentage:.1f}%)"
-        
-        # Display with a rule
-        console.rule("[blue]Token Usage[/blue]")
-        console.print(f"[blue]{summary}[/blue]", justify="center")
+"""
+Module for generating token usage reports.
+"""
+
+from rich.console import Console
+
+def generate_token_report(agent, verbose=False, interrupted=False):
+    """
+    Generate a token usage report.
+    
+    Args:
+        agent: The Claude agent instance
+        verbose: Whether to show detailed token usage information
+        interrupted: Whether the request was interrupted
+        
+    Returns:
+        None - prints the report to the console
+    """
+    console = Console()
+    usage = agent.get_tokens()
+    cost = agent.get_token_cost()
+    
+    text_usage = usage.text_usage
+    tools_usage = usage.tools_usage
+    
+    if verbose:
+        total_usage = usage.total_usage
+        
+        # Get costs from the cost object
+        text_input_cost = cost.input_cost
+        text_output_cost = cost.output_cost
+        text_cache_creation_cost = cost.cache_creation_cost
+        text_cache_read_cost = cost.cache_read_cost
+        
+        tools_input_cost = cost.input_cost
+        tools_output_cost = cost.output_cost
+        tools_cache_creation_cost = cost.cache_creation_cost
+        tools_cache_read_cost = cost.cache_read_cost
+        
+        # Format costs
+        def format_cost(cost):
+            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
+        
+        console.print("\n[bold blue]📊 Detailed Token Usage:[/bold blue]")
+        console.print(f"📝 Text Input tokens: {text_usage.input_tokens}")
+        console.print(f"📤 Text Output tokens: {text_usage.output_tokens}")
+        console.print(f"💾 Text Cache Creation tokens: {text_usage.cache_creation_input_tokens}")
+        console.print(f"📖 Text Cache Read tokens: {text_usage.cache_read_input_tokens}")
+        console.print(f"📋 Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens + text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens}")
+        
+        console.print(f"🔧 Tool Input tokens: {tools_usage.input_tokens}")
+        console.print(f"🔨 Tool Output tokens: {tools_usage.output_tokens}")
+        console.print(f"💾 Tool Cache Creation tokens: {tools_usage.cache_creation_input_tokens}")
+        console.print(f"📖 Tool Cache Read tokens: {tools_usage.cache_read_input_tokens}")
+        console.print(f"🧰 Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens + tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens}")
+        
+        console.print(f"🔢 Total tokens: {total_usage.input_tokens + total_usage.output_tokens + total_usage.cache_creation_input_tokens + total_usage.cache_read_input_tokens}")
+        
+        console.print("\n[bold blue]💰 Pricing Information:[/bold blue]")
+        console.print(f"📝 Text Input cost: {format_cost(text_input_cost)}")
+        console.print(f"📤 Text Output cost: {format_cost(text_output_cost)}")
+        console.print(f"💾 Text Cache Creation cost: {format_cost(text_cache_creation_cost)}")
+        console.print(f"📖 Text Cache Read cost: {format_cost(text_cache_read_cost)}")
+        console.print(f"📋 Text Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost)}")
+        
+        console.print(f"🔧 Tool Input cost: {format_cost(tools_input_cost)}")
+        console.print(f"🔨 Tool Output cost: {format_cost(tools_output_cost)}")
+        console.print(f"💾 Tool Cache Creation cost: {format_cost(tools_cache_creation_cost)}")
+        console.print(f"📖 Tool Cache Read cost: {format_cost(tools_cache_read_cost)}")
+        console.print(f"🧰 Tool Total cost: {format_cost(tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
+        
+        total_cost_text = f"💵 Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost + tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}"
+        if interrupted:
+            total_cost_text += " (interrupted request not accounted)"
+        console.print(total_cost_text)
+        
+        # Show cache delta if available
+        if hasattr(cost, 'cache_delta') and cost.cache_delta:
+            cache_delta = cost.cache_delta
+            console.print(f"\n[bold green]💰 Cache Savings:[/bold green] {format_cost(cache_delta)}")
+            
+            # Calculate percentage savings
+            total_cost_without_cache = cost.total_cost + cache_delta
+            if total_cost_without_cache > 0:
+                savings_percentage = (cache_delta / total_cost_without_cache) * 100
+                console.print(f"[bold green]📊 Cache Savings Percentage:[/bold green] {savings_percentage:.2f}%")
+                console.print(f"[bold green]💸 Cost without cache:[/bold green] {format_cost(total_cost_without_cache)}")
+                console.print(f"[bold green]💲 Cost with cache:[/bold green] {format_cost(cost.total_cost)}")
+            
+        # Per-tool breakdown
+        if usage.by_tool:
+            console.print("\n[bold blue]🔧 Per-Tool Breakdown:[/bold blue]")
+            try:
+                if hasattr(cost, 'by_tool') and cost.by_tool:
+                    for tool_name, tool_usage in usage.by_tool.items():
+                        tool_input_cost = cost.by_tool[tool_name].input_cost
+                        tool_output_cost = cost.by_tool[tool_name].output_cost
+                        tool_cache_creation_cost = cost.by_tool[tool_name].cache_creation_cost
+                        tool_cache_read_cost = cost.by_tool[tool_name].cache_read_cost
+                        tool_total_cost = tool_input_cost + tool_output_cost + tool_cache_creation_cost + tool_cache_read_cost
+                        
+                        console.print(f"   🔧 Tool: {tool_name}")
+                        console.print(f"  📥 Input tokens: {tool_usage.input_tokens}")
+                        console.print(f"  📤 Output tokens: {tool_usage.output_tokens}")
+                        console.print(f"  💾 Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
+                        console.print(f"  📖 Cache Read tokens: {tool_usage.cache_read_input_tokens}")
+                        console.print(f"  🔢 Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
+                        console.print(f"  💵 Total cost: {format_cost(tool_total_cost)}")
+                else:
+                    # Calculate costs manually for each tool if cost.by_tool is not available
+                    for tool_name, tool_usage in usage.by_tool.items():
+                        # Estimate costs based on overall pricing
+                        total_tokens = tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens
+                        estimated_cost = (total_tokens / (usage.total_usage.total_tokens + usage.total_usage.total_cache_tokens)) * cost.total_cost if usage.total_usage.total_tokens > 0 else 0
+                        
+                        console.print(f"   🔧 Tool: {tool_name}")
+                        console.print(f"  📥 Input tokens: {tool_usage.input_tokens}")
+                        console.print(f"  📤 Output tokens: {tool_usage.output_tokens}")
+                        console.print(f"  💾 Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
+                        console.print(f"  📖 Cache Read tokens: {tool_usage.cache_read_input_tokens}")
+                        console.print(f"  🔢 Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
+                        console.print(f"  💵 Total cost: {format_cost(estimated_cost)}")
+            except Exception as e:
+                console.print(f"❌ Error: {str(e)}")
+    else:
+        total_tokens = (text_usage.input_tokens + text_usage.output_tokens + 
+                       text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens +
+                       tools_usage.input_tokens + tools_usage.output_tokens +
+                       tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens)
+        
+        # Format costs
+        def format_cost(cost):
+            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
+        
+        # Prepare summary message
+        cost_text = f"Cost: {format_cost(cost.total_cost)}"
+        if interrupted:
+            cost_text += " (interrupted request not accounted)"
+            
+        summary = f"Total tokens: {total_tokens} | {cost_text}"
+        
+        # Add cache savings if available
+        if hasattr(cost, 'cache_delta') and cost.cache_delta != 0:
+            cache_delta = cost.cache_delta
+            total_cost_without_cache = cost.total_cost + cache_delta
+            savings_percentage = 0
+            if total_cost_without_cache > 0:
+                savings_percentage = (cache_delta / total_cost_without_cache) * 100
+            
+            summary += f" | Cache savings: {format_cost(cache_delta)} ({savings_percentage:.1f}%)"
+        
+        # Display with a rule
+        console.rule("[blue]Token Usage[/blue]")
+        console.print(f"[blue]{summary}[/blue]", justify="center")

janito/tools/__init__.py

@@ -1,21 +1,38 @@
-"""
-Janito tools package.
-"""
-
-from .str_replace_editor import str_replace_editor
-from .find_files import find_files
-from .delete_file import delete_file
-from .search_text import search_text
-from .replace_file import replace_file
-from .prompt_user import prompt_user
-
-__all__ = ["str_replace_editor", "find_files", "delete_file", "search_text", "replace_file", "prompt_user", "get_tools"]
-
-def get_tools():
-    """
-    Get a list of all available tools.
-    
-    Returns:
-        List of tool functions (excluding str_replace_editor which is passed separately)
-    """
-    return [find_files, delete_file, search_text, replace_file, prompt_user]
+"""
+Janito tools package.
+"""
+
+from .str_replace_editor import str_replace_editor
+from .find_files import find_files
+from .delete_file import delete_file
+from .search_text import search_text
+from .replace_file import replace_file
+from .prompt_user import prompt_user
+from .move_file import move_file
+from janito.tools.fetch_webpage import fetch_webpage
+from .usage_tracker import get_tracker, reset_tracker, print_usage_stats
+from janito.config import get_config
+
+__all__ = ["str_replace_editor", "find_files", "delete_file", "search_text", "replace_file", 
+           "prompt_user", "move_file", "fetch_webpage", "get_tools", 
+           "get_tracker", "reset_tracker", "print_usage_stats"]
+
+def get_tools():
+    """
+    Get a list of all available tools.
+    
+    Returns:
+        List of tool functions (excluding str_replace_editor which is passed separately)
+        If ask_mode is enabled, only returns tools that don't perform changes
+    """
+    # Tools that only read or view but don't modify anything
+    read_only_tools = [find_files, search_text, prompt_user, fetch_webpage]
+    
+    # Tools that modify the filesystem
+    write_tools = [delete_file, replace_file, move_file]
+    
+    # If ask_mode is enabled, only return read-only tools
+    if get_config().ask_mode:
+        return read_only_tools
+    else:
+        return read_only_tools + write_tools

janito/tools/bash/bash.py

@@ -0,0 +1,84 @@
+from typing import Optional
+from typing import Tuple
+import threading
+import platform
+import re
+from janito.config import get_config
+from janito.tools.usage_tracker import get_tracker
+from janito.tools.rich_console import console, print_info
+
+# Import the appropriate implementation based on the platform
+if platform.system() == "Windows":
+    from janito.tools.bash.win_persistent_bash import PersistentBash
+else:
+    from janito.tools.bash.unix_persistent_bash import PersistentBash
+
+# Global instance of PersistentBash to maintain state between calls
+_bash_session = None
+_session_lock = threading.RLock()  # Use RLock to allow reentrant locking
+
+def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]:
+    """
+    Execute a bash command using a persistent Bash session.
+    The appropriate implementation (Windows or Unix) is selected based on the detected platform.
+    When in ask mode, only read-only commands are allowed.
+    Output is printed to the console in real-time as it's received.
+    
+    Args:
+        command: The bash command to execute
+        restart: Whether to restart the bash session
+        
+    Returns:
+        A tuple containing (output message, is_error flag)
+    """
+    # Import console for printing output in real-time
+    from janito.tools.rich_console import console, print_info
+    
+    # Only print command if not in trust mode
+    if not get_config().trust_mode:
+        print_info(f"{command}", "Bash Run")
+    global _bash_session
+    
+    # Check if in ask mode and if the command might modify files
+    if get_config().ask_mode:
+        # List of potentially modifying commands
+        modifying_patterns = [
+            r'\brm\b', r'\bmkdir\b', r'\btouch\b', r'\becho\b.*[>\|]', r'\bmv\b', r'\bcp\b',
+            r'\bchmod\b', r'\bchown\b', r'\bsed\b.*-i', r'\bawk\b.*[>\|]', r'\bcat\b.*[>\|]',
+            r'\bwrite\b', r'\binstall\b', r'\bapt\b', r'\byum\b', r'\bpip\b.*install',
+            r'\bnpm\b.*install', r'\bdocker\b', r'\bkubectl\b.*apply', r'\bgit\b.*commit',
+            r'\bgit\b.*push', r'\bgit\b.*merge', r'\bdd\b'
+        ]
+        
+        # Check if command matches any modifying pattern
+        for pattern in modifying_patterns:
+            if re.search(pattern, command, re.IGNORECASE):
+                return ("Cannot execute potentially modifying commands in ask mode. Use --ask option to disable modifications.", True)
+    
+    with _session_lock:
+        # Initialize or restart the session if needed
+        if _bash_session is None or restart:
+            if _bash_session is not None:
+                _bash_session.close()
+            # Get GitBash path from config (None means auto-detect)
+            gitbash_path = get_config().gitbash_path
+            _bash_session = PersistentBash(bash_path=gitbash_path)
+        
+        try:
+            # Execute the command - output will be printed to console in real-time
+            output = _bash_session.execute(command)
+            
+            # Track bash command execution
+            get_tracker().increment('bash_commands')
+            
+            # Always assume execution was successful
+            is_error = False
+            
+            # Return the output as a string (even though it was already printed in real-time)
+            return output, is_error
+            
+        except Exception as e:
+            # Handle any exceptions that might occur
+            error_message = f"Error executing bash command: {str(e)}"
+            console.print(error_message, style="red bold")
+            return error_message, True

janito/tools/bash/unix_persistent_bash.py

@@ -0,0 +1,184 @@
+import subprocess
+import time
+import uuid
+
+class PersistentBash:
+    """
+    A wrapper class that maintains a persistent Bash session.
+    Allows sending commands and collecting output without restarting Bash.
+    """
+    
+    def __init__(self, bash_path=None):
+        """
+        Initialize a persistent Bash session.
+        
+        Args:
+            bash_path (str, optional): Path to the Bash executable. If None, tries to detect automatically.
+        """
+        self.process = None
+        self.bash_path = bash_path
+        
+        # If bash_path is not provided, try to detect it
+        if self.bash_path is None:
+            # On Unix-like systems, bash is usually in the PATH
+            self.bash_path = "bash"
+            
+            # Check if bash exists
+            try:
+                subprocess.run(["which", "bash"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            except subprocess.CalledProcessError as err:
+                raise FileNotFoundError("Could not find bash executable. Please specify the path manually.") from err
+        
+        # Start the bash process
+        self.start_process()
+    
+    def start_process(self):
+        """Start the Bash process."""
+        # Create a subprocess with pipe for stdin, stdout, and stderr
+        bash_args = [self.bash_path]
+        
+        self.process = subprocess.Popen(
+            bash_args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # Redirect stderr to stdout
+            text=True,                # Use text mode for input/output
+            bufsize=0,                # Unbuffered
+            universal_newlines=True,  # Universal newlines mode
+        )
+        
+        # Set up a more reliable environment
+        setup_commands = [
+            "export PS1='$ '",  # Simple prompt to avoid parsing issues
+            "export TERM=dumb",  # Disable color codes and other terminal features
+            "set +o history",  # Disable history
+            "shopt -s expand_aliases", # Enable alias expansion
+        ]
+        
+        # Send setup commands
+        for cmd in setup_commands:
+            self._send_command(cmd)
+        
+        # Clear initial output with a marker
+        marker = f"INIT_COMPLETE_{uuid.uuid4().hex}"
+        self._send_command(f"echo {marker}")
+        
+        while True:
+            line = self.process.stdout.readline().strip()
+            if marker in line:
+                break
+    
+    def _send_command(self, command):
+        """Send a command to the Bash process without reading the output."""
+        if self.process is None or self.process.poll() is not None:
+            self.start_process()
+            
+        self.process.stdin.write(command + "\n")
+        self.process.stdin.flush()
+    
+    def execute(self, command, timeout=None):
+        """
+        Execute a command in the Bash session and return the output.
+        
+        Args:
+            command (str): The command to execute.
+            timeout (int, optional): Timeout in seconds. If None, no timeout is applied.
+            
+        Returns:
+            str: The command output.
+        """
+        from janito.tools.rich_console import console
+        
+        if self.process is None or self.process.poll() is not None:
+            # Process has terminated, restart it
+            self.start_process()
+        
+        # Create a unique marker to identify the end of output
+        end_marker = f"END_OF_COMMAND_{uuid.uuid4().hex}"
+        
+        # Construct the wrapped command with echo markers
+        # Only use timeout when explicitly requested
+        if timeout is not None and timeout > 0:
+            # Check if timeout command is available
+            is_timeout_available = False
+            try:
+                check_cmd = "command -v timeout > /dev/null 2>&1 && echo available || echo unavailable"
+                self._send_command(check_cmd)
+                for _ in range(10):  # Read up to 10 lines to find the result
+                    line = self.process.stdout.readline().strip()
+                    if "available" in line:
+                        is_timeout_available = True
+                        break
+                    elif "unavailable" in line:
+                        is_timeout_available = False
+                        break
+            except:
+                is_timeout_available = False
+
+            if is_timeout_available:
+                # For timeout to work with shell syntax, we need to use bash -c
+                escaped_command = command.replace('"', '\\"')
+                wrapped_command = f"timeout {timeout}s bash -c \"{escaped_command}\" 2>&1; echo '{end_marker}'"
+            else:
+                wrapped_command = f"{command} 2>&1; echo '{end_marker}'"
+        else:
+            wrapped_command = f"{command} 2>&1; echo '{end_marker}'"
+        
+        # Send the command
+        self._send_command(wrapped_command)
+        
+        # Collect output until the end marker is found
+        output_lines = []
+        start_time = time.time()
+        max_wait = timeout if timeout is not None else 3600  # Default to 1 hour if no timeout
+        
+        while time.time() - start_time < max_wait + 5:  # Add buffer time
+            try:
+                line = self.process.stdout.readline().rstrip('\r\n')
+                if end_marker in line:
+                    break
+                    
+                # Print the output to the console in real-time if not in trust mode
+                if line:
+                    from janito.config import get_config
+                    if not get_config().trust_mode:
+                        console.print(line)
+                    
+                output_lines.append(line)
+            except Exception as e:
+                error_msg = f"[Error reading output: {str(e)}]"
+                console.print(error_msg, style="red")
+                output_lines.append(error_msg)
+                continue
+            
+        # Check for timeout
+        if time.time() - start_time >= max_wait + 5:
+            timeout_msg = f"Error: Command timed out after {max_wait} seconds"
+            console.print(timeout_msg, style="red bold")
+            output_lines.append(timeout_msg)
+            
+            # Try to reset the bash session after a timeout
+            self.close()
+            self.start_process()
+        
+        return "\n".join(output_lines)
+    
+    def close(self):
+        """Close the Bash session."""
+        if self.process and self.process.poll() is None:
+            try:
+                self._send_command("exit")
+                self.process.wait(timeout=2)
+            except:
+                pass
+            finally:
+                try:
+                    self.process.terminate()
+                except:
+                    pass
+                
+        self.process = None
+    
+    def __del__(self):
+        """Destructor to ensure the process is closed."""
+        self.close()