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

janito/__init__.py

@@ -2,4 +2,4 @@
 Janito package.
 """
 
-__version__ = "0.12.0"
+__version__ = "0.13.0"

janito/cli/agent.py

@@ -7,6 +7,8 @@ import json
 import anthropic
 import claudine
 import typer
+import datetime
+from typing import Optional
 from rich.console import Console
 from pathlib import Path
 from jinja2 import Template
@@ -19,6 +21,7 @@ from janito.tools import str_replace_editor
 from janito.tools.bash.bash import bash_tool
 from janito.cli.output import display_generation_params
 
+
 console = Console()
 
 def get_api_key() -> str:
@@ -154,12 +157,25 @@ def initialize_agent(temperature: float, verbose: bool) -> claudine.Agent:
     
     return agent
 
+def generate_message_id():
+    """
+    Generate a message ID based on timestamp with seconds granularity
+    
+    Returns:
+        str: A timestamp-based message ID
+    """
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    return timestamp
+
 def save_messages(agent):
     """
-    Save agent messages to .janito/last_message.json
+    Save agent messages to .janito/last_messages/{message_id}.json
     
     Args:
         agent: The claudine agent instance
+        
+    Returns:
+        str: The message ID used for saving
     """
     try:
         # Get the workspace directory
@@ -169,49 +185,115 @@ def save_messages(agent):
         janito_dir = workspace_dir / ".janito"
         janito_dir.mkdir(exist_ok=True)
         
+        # Create last_messages directory if it doesn't exist
+        messages_dir = janito_dir / "last_messages"
+        messages_dir.mkdir(exist_ok=True)
+        
+        # Generate a unique message ID
+        message_id = generate_message_id()
+        
         # Get messages from the agent
         messages = agent.get_messages()
         
+        # Create a message object with metadata
+        message_object = {
+            "id": message_id,
+            "timestamp": datetime.datetime.now().isoformat(),
+            "messages": messages
+        }
+        
         # Save messages to file
-        with open(janito_dir / "last_message.json", "w", encoding="utf-8") as f:
-            json.dump(messages, f, ensure_ascii=False, indent=2)
+        message_file = messages_dir / f"{message_id}.json"
+        with open(message_file, "w", encoding="utf-8") as f:
+            json.dump(message_object, f, ensure_ascii=False, indent=2)
+        
+        # No longer saving to last_message.json for backward compatibility
             
         if get_config().verbose:
-            console.print(f"[bold green]✅ Conversation saved to {janito_dir / 'last_message.json'}[/bold green]")
+            console.print(f"[bold green]✅ Conversation saved to {message_file}[/bold green]")
+            
+        return message_id
     except Exception as e:
         console.print(f"[bold red]❌ Error saving conversation:[/bold red] {str(e)}")
+        return None
 
-def load_messages():
+def load_messages(message_id=None):
     """
-    Load messages from .janito/last_message.json
+    Load messages from .janito/last_messages/{message_id}.json or the latest message file
     
+    Args:
+        message_id: Optional message ID to load specific conversation
+        
     Returns:
         List of message dictionaries or None if file doesn't exist
     """
     try:
         # Get the workspace directory
         workspace_dir = Path(get_config().workspace_dir)
+        janito_dir = workspace_dir / ".janito"
+        messages_dir = janito_dir / "last_messages"
+        
+        # If message_id is provided, try to load that specific conversation
+        if message_id:
+            # Check if the message ID is a file name or just the ID
+            if message_id.endswith('.json'):
+                message_file = messages_dir / message_id
+            else:
+                message_file = messages_dir / f"{message_id}.json"
+                
+            if not message_file.exists():
+                console.print(f"[bold yellow]⚠️ No conversation found with ID {message_id}[/bold yellow]")
+                return None
+                
+            # Load messages from file
+            with open(message_file, "r", encoding="utf-8") as f:
+                message_object = json.load(f)
+                
+            # Extract messages from the message object
+            if isinstance(message_object, dict) and "messages" in message_object:
+                messages = message_object["messages"]
+            else:
+                # Handle legacy format
+                messages = message_object
+                
+            if get_config().verbose:
+                console.print(f"[bold green]✅ Loaded conversation from {message_file}[/bold green]")
+                console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
+                
+            return messages
         
-        # Check if file exists
-        messages_file = workspace_dir / ".janito" / "last_message.json"
-        if not messages_file.exists():
+        # If no message_id is provided, try to load the latest message from last_messages directory
+        if not messages_dir.exists() or not any(messages_dir.iterdir()):
             console.print("[bold yellow]⚠️ No previous conversation found[/bold yellow]")
             return None
         
-        # Load messages from file
-        with open(messages_file, "r", encoding="utf-8") as f:
-            messages = json.load(f)
+        # Find the latest message file (based on filename which is a timestamp)
+        latest_file = max(
+            [f for f in messages_dir.iterdir() if f.is_file() and f.suffix == '.json'],
+            key=lambda x: x.stem
+        )
+        
+        # Load messages from the latest file
+        with open(latest_file, "r", encoding="utf-8") as f:
+            message_object = json.load(f)
+            
+        # Extract messages from the message object
+        if isinstance(message_object, dict) and "messages" in message_object:
+            messages = message_object["messages"]
+        else:
+            # Handle legacy format
+            messages = message_object
             
         if get_config().verbose:
-            console.print(f"[bold green]✅ Loaded previous conversation from {messages_file}[/bold green]")
+            console.print(f"[bold green]✅ Loaded latest conversation from {latest_file}[/bold green]")
             console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
             
         return messages
     except Exception as e:
-        console.print(f"[bold red]❌ Error loading previous conversation:[/bold red] {str(e)}")
+        console.print(f"[bold red]❌ Error loading conversation:[/bold red] {str(e)}")
         return None
 
-def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: bool = False) -> None:
+def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: Optional[str] = None) -> None:
     """
     Handle a query by initializing the agent and sending the query.
     
@@ -220,24 +302,29 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
         temperature: Temperature value for model generation
         verbose: Whether to enable verbose mode
         show_tokens: Whether to show detailed token usage
-        continue_conversation: Whether to continue the previous conversation
+        continue_conversation: Optional message ID to continue a specific conversation
     """
     # Initialize the agent
     agent = initialize_agent(temperature, verbose)
     
     # Load previous messages if continuing conversation
-    if continue_conversation:
-        messages = load_messages()
+    if continue_conversation is not None:
+        # If continue_conversation is an empty string (from flag with no value), use default behavior
+        message_id = None if continue_conversation == "" else continue_conversation
+        messages = load_messages(message_id)
         if messages:
             agent.set_messages(messages)
-            console.print("[bold blue]🔄 Continuing previous conversation[/bold blue]")
+            if message_id:
+                console.print(f"[bold blue]🔄 Continuing conversation with ID: {message_id}[/bold blue]")
+            else:
+                console.print("[bold blue]🔄 Continuing previous conversation[/bold blue]")
     
     # Send the query to the agent
     try:
         agent.query(query)
         
-        # Save messages after successful query
-        save_messages(agent)
+        # Save messages after successful query and get the message ID
+        message_id = save_messages(agent)
         
         # Print token usage report
         if show_tokens:
@@ -249,13 +336,26 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
         # Print tool usage statistics
         from janito.tools import print_usage_stats
         print_usage_stats()
+        
+        # Show message about continuing this conversation
+        if message_id:
+            script_name = "janito"
+            try:
+                # Check if we're running from the entry point script or as a module
+                if sys.argv[0].endswith(('janito', 'janito.exe')):
+                    console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] {script_name} --continue {message_id} <request>")
+                else:
+                    console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] python -m janito --continue {message_id} <request>")
+            except:
+                # Fallback message
+                console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] --continue {message_id} <request>")
             
     except KeyboardInterrupt:
         # Handle Ctrl+C by printing token and tool usage information
         console.print("\n[bold yellow]⚠️ Query interrupted by user (Ctrl+C)[/bold yellow]")
         
         # Save messages even if interrupted
-        save_messages(agent)
+        message_id = save_messages(agent)
         
         # Print token usage report (even if interrupted)
         try:
@@ -268,6 +368,19 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
             # Print tool usage statistics
             from janito.tools import print_usage_stats
             print_usage_stats()
+            
+            # Show message about continuing this conversation
+            if message_id:
+                script_name = "janito"
+                try:
+                    # Check if we're running from the entry point script or as a module
+                    if sys.argv[0].endswith(('janito', 'janito.exe')):
+                        console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] {script_name} --continue {message_id} <request>")
+                    else:
+                        console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] python -m janito --continue {message_id} <request>")
+                except:
+                    # Fallback message
+                    console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] --continue {message_id} <request>")
         except Exception as e:
             console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
             if verbose:

janito/cli/app.py

@@ -19,18 +19,19 @@ console = Console()
 def main(ctx: typer.Context, 
          query: Optional[str] = typer.Argument(None, help="Query to send to the claudine agent"),
          verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode with detailed output"),
-         show_tokens: bool = typer.Option(False, "--show-tokens", "-t", help="Show detailed token usage and pricing information"),
+         show_tokens: bool = typer.Option(False, "--show-tokens", "--tokens", help="Show detailed token usage and pricing information"),
          workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory"),
          config_str: Optional[str] = typer.Option(None, "--set-config", help="Configuration string in format 'key=value', e.g., 'temperature=0.7' or 'profile=technical'"),
          show_config: bool = typer.Option(False, "--show-config", help="Show current configuration"),
          reset_config: bool = typer.Option(False, "--reset-config", help="Reset configuration by removing the config file"),
          set_api_key: Optional[str] = typer.Option(None, "--set-api-key", help="Set the Anthropic API key globally in the user's home directory"),
          ask: bool = typer.Option(False, "--ask", help="Enable ask mode which disables tools that perform changes"),
+         trust: bool = typer.Option(False, "--trust", "-t", help="Enable trust mode which suppresses tool outputs for a more concise execution (per-session setting)"),
          temperature: float = typer.Option(0.0, "--temperature", help="Set the temperature for model generation (0.0 to 1.0)"),
          profile: Optional[str] = typer.Option(None, "--profile", help="Use a predefined parameter profile (precise, balanced, conversational, creative, technical)"),
          role: Optional[str] = typer.Option(None, "--role", help="Set the assistant's role (default: 'software engineer')"),
          version: bool = typer.Option(False, "--version", help="Show the version and exit"),
-         continue_conversation: bool = typer.Option(False, "--continue", "-c", help="Continue the previous conversation")):
+         continue_conversation: Optional[str] = typer.Option(None, "--continue", "-c", help="Continue a previous conversation, optionally with a specific message ID")):
     """
     Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
     """    
@@ -40,9 +41,16 @@ def main(ctx: typer.Context,
     # Set ask mode in config
     get_config().ask_mode = ask
     
+    # Set trust mode in config
+    get_config().trust_mode = trust
+    
     # Show a message if ask mode is enabled
     if ask:
         console.print("[bold yellow]⚠️ Ask Mode enabled:[/bold yellow] 🔒 Tools that perform changes are disabled")
+        
+    # Show a message if trust mode is enabled
+    if trust:
+        console.print("[bold blue]⚡ Trust Mode enabled:[/bold blue] Tool outputs are suppressed for concise execution (per-session setting)")
     
     # Show version and exit if requested
     if version:

janito/cli/commands.py

@@ -285,7 +285,7 @@ def handle_config_commands(
     set_api_key: Optional[str],
     config_str: Optional[str],
     query: Optional[str],
-    continue_conversation: bool = False
+    continue_conversation: Optional[str] = None
 ) -> bool:
     """
     Handle all configuration-related commands.
@@ -300,7 +300,7 @@ def handle_config_commands(
         set_api_key: API key
         config_str: Configuration string in format 'key=value'
         query: Query string
-        continue_conversation: Whether to continue the previous conversation
+        continue_conversation: Optional message ID to continue a specific conversation
         
     Returns:
         bool: True if the program should exit after these operations

janito/config.py

@@ -53,6 +53,7 @@ class Config:
             cls._instance._verbose = False
             # Chat history context feature has been removed
             cls._instance._ask_mode = False
+            cls._instance._trust_mode = False  # New trust mode setting
             # Set technical profile as default
             profile_data = PROFILES["technical"]
             cls._instance._temperature = profile_data["temperature"]
@@ -74,6 +75,8 @@ class Config:
                         self._verbose = config_data["debug_mode"]
                     if "ask_mode" in config_data:
                         self._ask_mode = config_data["ask_mode"]
+                    if "trust_mode" in config_data:
+                        self._trust_mode = config_data["trust_mode"]
                     if "temperature" in config_data:
                         self._temperature = config_data["temperature"]
                     if "profile" in config_data:
@@ -95,6 +98,7 @@ class Config:
             # Chat history context feature has been removed
             "verbose": self._verbose,
             "ask_mode": self._ask_mode,
+            # trust_mode is not saved as it's a per-session setting
             "temperature": self._temperature,
             "role": self._role
         }
@@ -265,6 +269,21 @@ class Config:
         self._ask_mode = value
         self._save_config()
         
+    @property
+    def trust_mode(self) -> bool:
+        """Get the trust mode status."""
+        return self._trust_mode
+        
+    @trust_mode.setter
+    def trust_mode(self, value: bool) -> None:
+        """Set the trust mode status.
+        
+        Note: This setting is not persisted to config file
+        as it's meant to be a per-session setting.
+        """
+        self._trust_mode = value
+        # Don't save to config file - this is a per-session setting
+        
     @property
     def temperature(self) -> float:
         """Get the temperature value for model generation."""
@@ -323,6 +342,7 @@ class Config:
             self._verbose = False
             # Chat history context feature has been removed
             self._ask_mode = False
+            self._trust_mode = False
             # Set technical profile as default
             profile_data = PROFILES["technical"]
             self._temperature = profile_data["temperature"]

janito/data/instructions_template.txt

@@ -6,22 +6,23 @@ If the question is related to the project, use the tools using the relative path
 If creating or editing files with a large number of lines, organize them into smaller files.
 If creating or editing files in an existing directory check surrounding files for the used patterns.
 
-# Structure Discovery (.janito/docs/STRUCTURE.md)
-Always start exploring the project by viewing for the file .janito/docs/STRUCTURE.md.
+# Structure Discovery (./docs/STRUCTURE.md)
+Always start exploring the project by viewing for the file ./docs/STRUCTURE.md.
 Do not track files or directories wich are in .gitignore in the structure.
 At the end of responding to the user, update the structure file based on the files and directories you have interacted with,
 be precise focusing on the most important files and directories, avoid adding extra information like architecture or design patterns.
 
-
 # Tools
 The bash tool does not support commands which will require user input.
 Prefer the str_replace_editor tool to view directories and file contents.
 
 </IMPORTANT>
-Call the tool user_prompt when:
+Call the user_prompt tool when:
 - There are multiple options to apply a certain change
 - The next operation risk is moderated or high
 - The implementation plan is complex, requiring a review
 Proceed according to the user answer.
 <IMPORTANT/>
 
+When changing code in Python files, be mindful about the need to review the imports specially when new type hints are used (eg. Optional, Tuple, List, Dict, etc).
+After performing changes to a project in interfaces which are exposed to the user, provide a short summary on how to verify the changes. eg. "run cmd xpto"

janito/tools/bash/bash.py

@@ -34,7 +34,9 @@ def bash_tool(command: str, restart: Optional[bool] = False) -> Tuple[str, bool]
     # Import console for printing output in real-time
     from janito.tools.rich_console import console, print_info
     
-    print_info(f"{command}", "Bash Run")
+    # 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

janito/tools/bash/unix_persistent_bash.py

@@ -1,182 +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 line:
-                    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."""
+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()

janito/tools/bash/win_persistent_bash.py

@@ -222,9 +222,11 @@ class PersistentBash:
                 if end_marker in line:
                     break
                     
-                # Print the output to the console in real-time
+                # Print the output to the console in real-time if not in trust mode
                 if line:
-                    console.print(line)
+                    from janito.config import get_config
+                    if not get_config().trust_mode:
+                        console.print(line)
                     
                 output_lines.append(line)
             except UnicodeDecodeError as e:

janito/tools/rich_console.py

@@ -4,6 +4,7 @@ Utility module for rich console printing in tools.
 from rich.console import Console
 from rich.text import Text
 from typing import Optional
+from janito.config import get_config
 
 # Create a shared console instance
 console = Console()
@@ -16,6 +17,9 @@ def print_info(message: str, title: Optional[str] = None):
         message: The message to print
         title: Optional title for the panel
     """
+    # Skip printing if trust mode is enabled
+    if get_config().trust_mode:
+        return
     # Map titles to specific icons
     icon_map = {
         # File operations
@@ -82,20 +86,22 @@ def print_info(message: str, title: Optional[str] = None):
             elif "Undoing last edit" in title:
                 icon = "↩️"  # Undo icon
     
+    # Add indentation to all tool messages
+    indent = "    "
     text = Text(message)
     if title:
         # Special case for Bash Run commands
         if title == "Bash Run":
             console.print("\n" + "-"*50)
-            console.print(f"{icon} {title}", style="bold white on blue")
+            console.print(f"{indent}{icon} {title}", style="bold white on blue")
             console.print("-"*50)
-            console.print(f"$ {text}", style="white on dark_blue")
+            console.print(f"{indent}$ {text}", style="white on dark_blue")
             # Make sure we're not returning anything
             return
         else:
-            console.print(f"{icon} {message}", style="blue", end="")
+            console.print(f"{indent}{icon} {message}", style="blue", end="")
     else:
-        console.print(f"{icon} {text}", style="blue", end="")
+        console.print(f"{indent}{icon} {text}", style="blue", end="")
 
 def print_success(message: str, title: Optional[str] = None):
     """
@@ -105,6 +111,9 @@ def print_success(message: str, title: Optional[str] = None):
         message: The message to print
         title: Optional title for the panel
     """
+    # Skip printing if trust mode is enabled
+    if get_config().trust_mode:
+        return
     text = Text(message)
     if title:
         console.print(f" ✅ {message}", style="green")
@@ -114,26 +123,54 @@ def print_success(message: str, title: Optional[str] = None):
 def print_error(message: str, title: Optional[str] = None):
     """
     Print an error message with rich formatting.
+    In trust mode, error messages are suppressed.
     
     Args:
         message: The message to print
         title: Optional title for the panel
     """
+    # Skip printing if trust mode is enabled
+    if get_config().trust_mode:
+        return
+        
     text = Text(message)
-    if title:
-        # Special case for File View - print without header
+    
+    # Check if message starts with question mark emoji (❓)
+    # If it does, use warning styling (yellow) instead of error styling (red)
+    starts_with_question_mark = message.startswith("❓")
+    
+    if starts_with_question_mark:
+        # Use warning styling for question mark emoji errors
+        # For question mark emoji errors, don't include the title (like "Error")
+        # Just print the message with the emoji
         if title == "File View":
-            console.print(f"\n ❌ {message}", style="red")
+            console.print(f"\n {message}", style="yellow")
         else:
-            console.print(f"❌ {title} {text}")
+            console.print(f"{message}", style="yellow")
     else:
-        console.print(f"\n❌ {text}", style="red")
+        # Regular error styling
+        if title:
+            # Special case for File View - print without header
+            if title == "File View":
+                console.print(f"\n ❌ {message}", style="red")
+            # Special case for Search Error
+            elif title == "Search Error":
+                console.print(f"❌ {message}", style="red")
+            else:
+                console.print(f"❌ {title} {text}", style="red")
+        else:
+            console.print(f"\n❌ {text}", style="red")
 
 def print_warning(message: str):
     """
     Print a warning message with rich formatting.
+    In trust mode, warning messages are suppressed.
     
     Args:
         message: The message to print
     """
+    # Skip printing if trust mode is enabled
+    if get_config().trust_mode:
+        return
+        
     console.print(f"⚠️  {message}", style="yellow")

janito/tools/search_text.py

@@ -37,9 +37,10 @@ def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".",
         # Compile the regex pattern for better performance
         try:
             regex = re.compile(text_pattern)
-        except re.error as e:
-            error_msg = f"Error: Invalid regex pattern '{text_pattern}': {str(e)}"
-            print_error(error_msg, "Regex Error")
+        except re.error:
+            # Simplified error message without the specific regex error details
+            error_msg = f"Error: Invalid regex pattern '{text_pattern}'"
+            print_error(error_msg, "Search Error")
             return error_msg, True
         
         matching_files = []

janito/tools/str_replace_editor/handlers/str_replace.py

@@ -60,7 +60,9 @@ def handle_str_replace(args: Dict[str, Any]) -> Tuple[str, bool]:
         
         # Check if old_str exists in the content (must match EXACTLY)
         if old_str not in content:
-            print_error("No exact match found for replacement. Please check your text and ensure whitespaces match exactly.", "Error")
+            # Only print error if not in trust mode
+            if not get_config().trust_mode:
+                print_error("No exact match", "?")
             return ("Error: No exact match found for replacement. Please check your text and ensure whitespaces match exactly.", True)
         
         # Count occurrences to check for multiple matches

janito/tools/str_replace_editor/handlers/view.py

@@ -55,8 +55,8 @@ def handle_view(args: Dict[str, Any]) -> Tuple[str, bool]:
     file_path = pathlib.Path(path)
     
     if not file_path.exists():
-        print_error(f"File or directory {path} does not exist", "Error")
-        return (f"File or directory {path} does not exist", True)
+        print_error(f"❓ (not found)", "Error")
+        return (f"❓ (not found)", True)
     
     # If the path is a directory, list non-hidden files and directories up to 2 levels deep
     if file_path.is_dir():
@@ -94,9 +94,12 @@ def handle_view(args: Dict[str, Any]) -> Tuple[str, bool]:
             # Directory listings should not be truncated
             file_dir_count = len(result)
             output = "\n".join(result)
-            console.print(f"Found ", style="default", end="")
-            console.print(f"{file_dir_count}", style="cyan", end="")
-            console.print(" files and directories")
+            
+            # Only print count if not in trust mode
+            if not get_config().trust_mode:
+                console.print(f"Found ", style="default", end="")
+                console.print(f"{file_dir_count}", style="cyan", end="")
+                console.print(" files and directories")
             return (output, False)
         except Exception as e:
             return (f"Error listing directory {path}: {str(e)}", True)
@@ -144,9 +147,12 @@ def handle_view(args: Dict[str, Any]) -> Tuple[str, bool]:
             return (truncated_content + "\n<response clipped>", False)
         
         content_to_print = "".join(numbered_content)
-        console.print("(", style="default", end="")
-        console.print(f"{len(numbered_content)}", style="cyan", end="")
-        console.print(")")
+        
+        # Only print line count if not in trust mode
+        if not get_config().trust_mode:
+            console.print("(", style="default", end="")
+            console.print(f"{len(numbered_content)}", style="cyan", end="")
+            console.print(")")
         # Return the content as a string without any Rich objects
         return (content_to_print, False)
     except Exception as e:

{janito-0.12.0.dist-info → janito-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 0.12.0
+Version: 0.13.0
 Summary: Janito CLI tool
 Project-URL: Homepage, https://github.com/joaompinto/janito
 Author-email: João Pinto <lamego.pinto@gmail.com>
@@ -35,6 +35,8 @@ Janito is a powerful AI-assisted command-line interface (CLI) tool built with Py
 - 🌐 Web page fetching with content extraction capabilities
 - 🔄 Parameter profiles for optimizing Claude's behavior for different tasks
 - 📋 Line delta tracking to monitor net changes in files
+- 💬 Conversation history with ability to resume previous conversations
+- 🔇 Trust mode for concise output without tool details
 
 ## 🛠️ System Requirements
 
@@ -108,14 +110,24 @@ janito --show-tokens "Explain what is in the project"
 # Use a specific parameter profile for creative tasks
 janito --profile creative "Write a fun description for our project"
 
-# Continue previous conversation
-janito --continue "Plese add one more line"
+# Use trust mode for concise output without tool details
+janito --trust "Optimize the HTML code"
+# Or use the short alias
+janito -t "Optimize the HTML code"
+
+# Continue the most recent conversation
+janito --continue "Please add one more line"
+
+# Continue a specific conversation using its message ID
+# (Janito displays the message ID after each conversation)
+janito --continue abc123def "Let's refine that code"
 
 # Show current configuration and available profiles
 janito --show-config
 
 # You can press Ctrl+C at any time to interrupt a query
 # Janito will still display token and tool usage information
+# Even interrupted conversations can be continued with --continue
 ```
 
 ## 🔧 Available Tools
@@ -134,7 +146,7 @@ Janito comes with several built-in tools:
 Janito includes a comprehensive token usage tracking system that helps you monitor API costs:
 
 - **Basic tracking**: By default, Janito displays a summary of token usage and cost after each query
-- **Detailed reporting**: Use the `--show-tokens` or `-t` flag to see detailed breakdowns including:
+- **Detailed reporting**: Use the `--show-tokens` flag to see detailed breakdowns including:
   - Input and output token counts
   - Per-tool token usage statistics
   - Precise cost calculations
@@ -147,6 +159,11 @@ janito --show-tokens "Write a Python function to sort a list"
 
 # Basic usage (shows simplified token usage summary)
 janito "Explain Docker containers"
+
+# Use trust mode for concise output without tool details
+janito --trust "Create a simple Python script"
+# Or use the short alias
+janito -t "Create a simple Python script"
 ```
 
 The usage tracker automatically calculates cache savings, showing you how much you're saving by reusing previous responses.
@@ -169,6 +186,64 @@ janito --profile creative "Write a poem about coding"
 janito --show-config
 ```
 
+## 🔇 Trust Mode
+
+Janito offers a trust mode that suppresses tool outputs for a more concise execution experience:
+
+### How It Works
+
+- When enabled with `--trust` or `-t`, Janito suppresses informational and success messages from tools
+- Only essential output and error messages are displayed
+- The final result from Claude is still shown in full
+- Trust mode is a per-session setting and not saved to your configuration
+
+### Using Trust Mode
+
+```bash
+# Enable trust mode with the full flag
+janito --trust "Create a Python script that reads a CSV file"
+
+# Or use the short alias
+janito -t "Create a Python script that reads a CSV file"
+```
+
+This feature is particularly useful for:
+- Experienced users who don't need to see every step of the process
+- Batch processing or scripting where concise output is preferred
+- Focusing on results rather than the process
+- Creating cleaner output for documentation or sharing
+
+## 💬 Conversation History
+
+Janito automatically saves your conversation history, allowing you to continue previous discussions:
+
+### How It Works
+
+- Each conversation is saved with a unique message ID in `.janito/last_messages/`
+- The most recent conversation is also saved as `.janito/last_message.json` for backward compatibility
+- After each conversation, Janito displays the command to continue that specific conversation
+
+### Using the Continue Feature
+
+```bash
+# Continue the most recent conversation
+janito --continue "Add more details to your previous response"
+
+# Continue a specific conversation using its ID
+janito --continue abc123def "Let's modify that code you suggested"
+```
+
+The `--continue` flag (or `-c` for short) allows you to:
+- Resume the most recent conversation when used without an ID
+- Resume a specific conversation when provided with a message ID
+- Maintain context across multiple interactions for complex tasks
+
+This feature is particularly useful for:
+- Multi-step development tasks
+- Iterative code improvements
+- Continuing discussions after system interruptions
+- Maintaining context when working on complex problems
+
 ## ⚙️ Dependencies
 
 Janito automatically installs the following dependencies:
@@ -177,6 +252,28 @@ Janito automatically installs the following dependencies:
 - claudine - For Claude AI integration
 - Additional packages for file handling and web content extraction
 
+## 🛠️ Command-Line Options
+
+Janito offers a variety of command-line options to customize its behavior:
+
+```
+--verbose, -v                 Enable verbose mode with detailed output
+--show-tokens                 Show detailed token usage and pricing information
+--workspace, -w TEXT          Set the workspace directory
+--set-config TEXT             Configuration string in format 'key=value', e.g., 'temperature=0.7'
+--show-config                 Show current configuration
+--reset-config                Reset configuration by removing the config file
+--set-api-key TEXT            Set the Anthropic API key globally in the user's home directory
+--ask                         Enable ask mode which disables tools that perform changes
+--trust, -t                   Enable trust mode which suppresses tool outputs for concise execution
+--temperature FLOAT           Set the temperature for model generation (0.0 to 1.0)
+--profile TEXT                Use a predefined parameter profile (precise, balanced, conversational, creative, technical)
+--role TEXT                   Set the assistant's role (default: 'software engineer')
+--version                     Show the version and exit
+--continue, -c TEXT           Continue a previous conversation, optionally with a specific message ID
+--help                        Show the help message and exit
+```
+
 ## 🔑 API Key Configuration
 
 You can configure your Anthropic API key in several ways:

{janito-0.12.0.dist-info → janito-0.13.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-janito/__init__.py,sha256=UhMcaPInS2sBvYxOLldeLu7sKy-ZZxndtrf6NPqQBgI,53
+janito/__init__.py,sha256=5Cnu7sPJURDSY1cnxtGvzs0MpwHUsh5zYZRNQ2LkM8k,53
 janito/__main__.py,sha256=Oy-Nc1tZkpyvTKuq1R8oHSuJTkvptN6H93kIHBu7DKY,107
 janito/callbacks.py,sha256=E1FPXYHZUgiEGMabYuf999PSf_Su4ByHOWlc1-hMqWE,915
-janito/config.py,sha256=haIErp8tVL6e_5h4fsgLqFib2aCAZZ3sIXa8wStn_yo,12424
+janito/config.py,sha256=MHfloii_OnOVcV4pbunfdnAv8uJzxu_ytDK34Rj8yZ8,13221
 janito/test_file.py,sha256=c6GWGdTYG3z-Y5XBao9Tmhmq3G-v0L37OfwLgBo8zIU,126
 janito/token_report.py,sha256=Mks7o2yTxPChgQyBJNoQ5eMmrhSgEM4LKCKi2tHJbVo,9580
 janito/cli/__init__.py,sha256=dVi9l3E86YyukjxQ-XSUnMZkghnNasXex-X5XAOBiwk,85
-janito/cli/agent.py,sha256=AYJhSqPbz1Ywz_RBzHxfXIK6x-aZrqA8-C2QzmxZ3J8,10533
-janito/cli/app.py,sha256=RghsHSmvnECGWzoAeQOJdxHTZM_Xcw6Y4jgbJ5I6-5M,4131
-janito/cli/commands.py,sha256=c1EHJ_VZR_3aA3zRvCLaBn9yfdj5emQpTI0Z_bXcIyc,12664
+janito/cli/agent.py,sha256=iFwzbZupkpXQVO0YrQmCGKKQGcqCRdAY3JLg6tZaJiQ,15940
+janito/cli/app.py,sha256=czgOEWCsWlKeLWMHxPv6fxOStoL2wcC8_QZs6mMtTp8,4643
+janito/cli/commands.py,sha256=pgassnKENr0DGcZT3tFXtz8MCVuEZwHgxiBktgAik6g,12682
 janito/cli/output.py,sha256=mo3hUokhrD4SWexUjCbLGGQeCDUf0369DA_i9BW7HjU,933
 janito/cli/utils.py,sha256=gO4NtCNwtEzYDsQesrFlqB5FtYuw87yGwo4iG3nINgw,661
-janito/data/instructions_template.txt,sha256=oXmjVEajwLuTjcyXyD123CGSjNG1QLbfzbw9iEq-w5w,1411
+janito/data/instructions_template.txt,sha256=FlyGpNjl2LRBjPWLTK40oKOSH6sveHp5ud35nf_lfs8,1716
 janito/tools/__init__.py,sha256=hio75FRkxLSQB13We-SCCM7Qa9lMqWCfWhEonHlTr8M,1405
 janito/tools/decorators.py,sha256=Tp48n5y4LKsjyV3HeOA9wk2dV413RrEG-23kRyQVlKs,2522
 janito/tools/delete_file.py,sha256=UrZ5q59SIxWfuJcqgol6yPBqL-RhO9lFCF4MqAc6o00,2252
@@ -18,12 +18,12 @@ janito/tools/find_files.py,sha256=c_N9ETcRPprQeuZYanwFnl-9E05ZqUYhNVoCRS5uqQg,83
 janito/tools/move_file.py,sha256=FCs1ghalfHlXmcbAA_IlLcUll9hTOU1MMFGrTWopXvM,2741
 janito/tools/prompt_user.py,sha256=OnTiWVBCbL_2MYu7oThlKr8X_pnYdG-dzxXSOgJF41c,1942
 janito/tools/replace_file.py,sha256=i4GoLtS14eKSU5lYI18mJ96S0_ekeHMwlQfazg-fxrM,2296
-janito/tools/rich_console.py,sha256=VyLStA7fCgMGp9KZ0TYHAC3FOOAWKKHx1XTWWWF2ISI,4560
-janito/tools/search_text.py,sha256=hZLgKlF_cC5JRQ2XsussndSZMmptwr8d0tTKCyCXFwg,9755
+janito/tools/rich_console.py,sha256=0zWYRF8qk4N-upuwswUSEfYFAfkEYDYeCgxst-czWtY,6044
+janito/tools/search_text.py,sha256=RxbnNeZ3ErCvevwbl60fQAe55QYtU-D9n13iixeDcqQ,9822
 janito/tools/usage_tracker.py,sha256=IE7GVBDYsX2EDLjsVaVqTeAnT2SAYfcOJvBaH__wHdU,4613
-janito/tools/bash/bash.py,sha256=gOYhp2CexuEjSSpHGhVQLr-Ooc67Etl7Br1TbRtY6vc,3577
-janito/tools/bash/unix_persistent_bash.py,sha256=tFFhbG9rk1KcONmG0j6SZHrqYxCXELhzobRSTEHPFm0,6868
-janito/tools/bash/win_persistent_bash.py,sha256=mMgAdRi7jlznq7ssNmgiSMEqzEI-rIV0kgYpndcum6U,12758
+janito/tools/bash/bash.py,sha256=AFm0w_z-yyYRWxuR744OFpm5iCZaZpE-pWbnKbgajp4,3665
+janito/tools/bash/unix_persistent_bash.py,sha256=I59PPQiXHscPJ6Y7ev_83dLFNFWq1hKwAK9kFXdnbBY,7185
+janito/tools/bash/win_persistent_bash.py,sha256=96xm_yijjc6hBYfNluLahbvR2oUuHug_JkoMah7Hy38,12894
 janito/tools/fetch_webpage/__init__.py,sha256=0RG0ev-yrfo8gPzt-36WMpVdY2qtMhk2Z-mVpq-7m1o,1076
 janito/tools/fetch_webpage/chunking.py,sha256=mMtrZeirZ_GnKOOzeG8BijLVpSUI0-TA5Ioqi2HKb1A,2971
 janito/tools/fetch_webpage/core.py,sha256=3XDvYnC_UbQUNumwWw32hfJhjJUEaPzzoF2yhxhwxos,7764
@@ -36,12 +36,12 @@ janito/tools/str_replace_editor/utils.py,sha256=akiPqCHjky_RwL9OitHJJ7uQ-3fNaA8w
 janito/tools/str_replace_editor/handlers/__init__.py,sha256=RP6JCeDRIL4R-lTpGowIoOAi64gg6VxZvJGp8Q2UOVU,373
 janito/tools/str_replace_editor/handlers/create.py,sha256=s8RQE04kDAL7OLZA8WxJkDqTmJlGmCNiit4tIHnmNMo,2470
 janito/tools/str_replace_editor/handlers/insert.py,sha256=eKHodm2ozKUlRMxWMLAsu9ca6unUo1jfXWwHSld-pSU,4061
-janito/tools/str_replace_editor/handlers/str_replace.py,sha256=quHQ1vOqvXCPaC14W5iub01kKB4XNMqwh1odnXnhhxY,4459
+janito/tools/str_replace_editor/handlers/str_replace.py,sha256=RciLTlA7R2PGljeeyluLcBHUAje9c1OCxm-bFE7j6iY,4473
 janito/tools/str_replace_editor/handlers/undo.py,sha256=3OIdAWkpXC2iDe94_sfx_WxEFh3a1cRzoP0NtPXq1Ks,2491
-janito/tools/str_replace_editor/handlers/view.py,sha256=ZWcx7r5VwxWG3ImQxK2lzONL9xlqctM-hy2kMF-huT0,6616
-janito/data/instructions_template.txt,sha256=oXmjVEajwLuTjcyXyD123CGSjNG1QLbfzbw9iEq-w5w,1411
-janito-0.12.0.dist-info/METADATA,sha256=oR3nvTukvj3uPVcZ2LbAA4lx46W08elLhWphDWXpAAs,6458
-janito-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-janito-0.12.0.dist-info/entry_points.txt,sha256=JMbF_1jg-xQddidpAYkzjOKdw70fy_ymJfcmerY2wIY,47
-janito-0.12.0.dist-info/licenses/LICENSE,sha256=6-H8LXExbBIAuT4cyiE-Qy8Bad1K4pagQRVTWr6wkhk,1096
-janito-0.12.0.dist-info/RECORD,,
+janito/tools/str_replace_editor/handlers/view.py,sha256=k8F-n64bomHmDjavr5OJKC4cHhfm4_1-aMIFZdMICQo,6809
+janito/data/instructions_template.txt,sha256=FlyGpNjl2LRBjPWLTK40oKOSH6sveHp5ud35nf_lfs8,1716
+janito-0.13.0.dist-info/METADATA,sha256=06Vh36jWdwTcsUOpIyRkHybxssdksSoWNvPVE41y1jM,10584
+janito-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+janito-0.13.0.dist-info/entry_points.txt,sha256=JMbF_1jg-xQddidpAYkzjOKdw70fy_ymJfcmerY2wIY,47
+janito-0.13.0.dist-info/licenses/LICENSE,sha256=6-H8LXExbBIAuT4cyiE-Qy8Bad1K4pagQRVTWr6wkhk,1096
+janito-0.13.0.dist-info/RECORD,,