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

janito/tools/search_text.py

@@ -1,15 +1,16 @@
 import os
 import fnmatch
 import re
-import pathlib
-from typing import List, Dict, Any, Tuple
-from janito.tools.decorators import tool_meta
+from typing import List, Tuple
+from janito.tools.rich_console import print_info, print_success, print_error, print_warning
+from janito.tools.usage_tracker import track_usage
 
 
-@tool_meta(label="Searching for '{text_pattern}' in files matching '{file_pattern}'")
-def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".", recursive: bool = True, respect_gitignore: bool = True) -> Tuple[str, bool]:
+@track_usage('search_operations')
+def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".", recursive: bool = True) -> Tuple[str, bool]:
     """
     Search for text patterns within files matching a filename pattern.
+    Files in .gitignore are always ignored.
     
     Args:
         text_pattern: Text pattern to search for within files
@@ -18,39 +19,42 @@ def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".",
                      Examples: "*.py *.toml *.sh *.md test*"
         root_dir: Root directory to start search from (default: current directory)
         recursive: Whether to search recursively in subdirectories (default: True)
-        respect_gitignore: Whether to respect .gitignore files (default: True)
         
     Returns:
         A tuple containing (message, is_error)
     """
+    # Simplified initial message
+    print_info(f"Searching for '{text_pattern}' in '{file_pattern}'", "Text Search")
     try:
         # Convert to absolute path if relative
         abs_root = os.path.abspath(root_dir)
         
         if not os.path.isdir(abs_root):
-            return f"Error: Directory '{root_dir}' does not exist", True
+            error_msg = f"Error: Directory '{root_dir}' does not exist"
+            print_error(error_msg, "Directory Error")
+            return error_msg, True
         
         # Compile the regex pattern for better performance
         try:
             regex = re.compile(text_pattern)
-        except re.error as e:
-            return f"Error: Invalid regex pattern '{text_pattern}': {str(e)}", True
+        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 = []
         match_count = 0
         results = []
         
-        # Get gitignore patterns if needed
-        ignored_patterns = []
-        if respect_gitignore:
-            ignored_patterns = _get_gitignore_patterns(abs_root)
+        # Get gitignore patterns
+        ignored_patterns = _get_gitignore_patterns(abs_root)
         
         # Use os.walk for recursive behavior
         if recursive:
             for dirpath, dirnames, filenames in os.walk(abs_root):
                 # Skip ignored directories
-                if respect_gitignore:
-                    dirnames[:] = [d for d in dirnames if not _is_ignored(os.path.join(dirpath, d), ignored_patterns, abs_root)]
+                dirnames[:] = [d for d in dirnames if not _is_ignored(os.path.join(dirpath, d), ignored_patterns, abs_root)]
                 
                 # Handle multiple patterns separated by semicolons or spaces
                 patterns = []
@@ -66,7 +70,7 @@ def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".",
                         file_path = os.path.join(dirpath, filename)
                         
                         # Skip ignored files
-                        if respect_gitignore and _is_ignored(file_path, ignored_patterns, abs_root):
+                        if _is_ignored(file_path, ignored_patterns, abs_root):
                             continue
                         
                         # Skip if already processed this file
@@ -95,7 +99,7 @@ def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".",
                     file_path = os.path.join(abs_root, filename)
                     
                     # Skip ignored files
-                    if respect_gitignore and _is_ignored(file_path, ignored_patterns, abs_root):
+                    if _is_ignored(file_path, ignored_patterns, abs_root):
                         continue
                     
                     # Skip if already processed this file
@@ -111,14 +115,23 @@ def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".",
                             results.extend(file_matches)
         
         if matching_files:
+            # Only print the count summary, not the full results
+            summary = f"{match_count} matches in {len(matching_files)} files"
+            print_success(summary, "Search Results")
+            
+            # Still return the full results for programmatic use
             result_text = "\n".join(results)
-            summary = f"\n{match_count} matches in {len(matching_files)} files"
-            return f"Searching for '{text_pattern}' in files matching '{file_pattern}':{result_text}\n{summary}", False
+            result_msg = f"Searching for '{text_pattern}' in files matching '{file_pattern}':{result_text}\n{summary}"
+            return result_msg, False
         else:
-            return f"No matches found for '{text_pattern}' in files matching '{file_pattern}' in '{root_dir}'", False
+            result_msg = f"No matches found for '{text_pattern}' in files matching '{file_pattern}'"
+            print_warning("No matches found.")
+            return result_msg, False
             
     except Exception as e:
-        return f"Error searching text: {str(e)}", True
+        error_msg = f"Error searching text: {str(e)}"
+        print_error(error_msg, "Search Error")
+        return error_msg, True
 
 
 def _search_file(file_path: str, pattern: re.Pattern, root_dir: str) -> List[str]:
@@ -143,7 +156,7 @@ def _search_file(file_path: str, pattern: re.Pattern, root_dir: str) -> List[str
                     if len(display_line) > 100:
                         display_line = display_line[:97] + "..."
                     matches.append(f"  Line {i}: {display_line}")
-    except (UnicodeDecodeError, IOError) as e:
+    except (UnicodeDecodeError, IOError):
         # Skip binary files or files with encoding issues
         pass
     return matches

janito/tools/str_replace_editor/editor.py

@@ -1,7 +1,8 @@
 """
 Main module for implementing the Claude text editor functionality.
 """
-from typing import Dict, Any, Tuple
+from typing import Tuple
+from janito.config import get_config
 from .handlers import (
     handle_create,
     handle_view,
@@ -9,10 +10,7 @@ from .handlers import (
     handle_insert,
     handle_undo_edit
 )
-from .utils import normalize_path
-from janito.tools.decorators import tool_meta
 
-@tool_meta(label="File Command: ({command})")
 def str_replace_editor(**kwargs) -> Tuple[str, bool]:
     """
     Custom editing tool for viewing, creating and editing files
@@ -21,6 +19,7 @@ def str_replace_editor(**kwargs) -> Tuple[str, bool]:
     * The `create` command cannot be used if the specified `path` already exists as a file
     * If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
     * The `undo_edit` command will revert the last edit made to the file at `path`
+    * When in ask mode, only the `view` command is allowed
 
     Notes for using the `str_replace` command:
     * The `old_str` parameter should match EXACTLY one or more consecutive lines from the original file. Be mindful of whitespaces!
@@ -38,6 +37,10 @@ def str_replace_editor(**kwargs) -> Tuple[str, bool]:
     """
     command = kwargs.get("command")
     
+    # If in ask mode, only allow view operations
+    if get_config().ask_mode and command != "view":
+        return ("Cannot perform file modifications in ask mode. Use --ask option to disable modifications.", True)
+    
     if command == "create":
         return handle_create(kwargs)
     elif command == "view":

janito/tools/str_replace_editor/handlers/__init__.py

@@ -0,0 +1,16 @@
+"""
+Package for str_replace_editor command handlers.
+"""
+from .create import handle_create
+from .view import handle_view
+from .str_replace import handle_str_replace
+from .insert import handle_insert
+from .undo import handle_undo_edit
+
+__all__ = [
+    "handle_create",
+    "handle_view",
+    "handle_str_replace",
+    "handle_insert",
+    "handle_undo_edit"
+]

janito/tools/str_replace_editor/handlers/create.py

@@ -0,0 +1,60 @@
+"""
+Handler for the create command in str_replace_editor.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from janito.tools.rich_console import print_info, print_success, print_error
+from janito.tools.usage_tracker import get_tracker
+from ..utils import normalize_path
+
+def handle_create(args: Dict[str, Any]) -> Tuple[str, bool]:
+    """
+    Create a new file with the specified content.
+    
+    Args:
+        args: Dictionary containing:
+            - path: Path to the file to create
+            - file_text: Content to write to the file
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    path = args.get("path")
+    file_text = args.get("file_text", "")
+    
+    # Count the number of lines in the file content
+    line_count = len(file_text.splitlines())
+    print_info(f"Creating file: {path} (+{line_count} lines)", "File Creation")
+    
+    if not path:
+        return ("Missing required parameter: path", True)
+    
+    path = normalize_path(path)
+    
+    # Convert to Path object for better path handling
+    file_path = pathlib.Path(path)
+    
+    # Check if the file already exists - according to spec, create cannot be used if file exists
+    if file_path.exists() and file_path.is_file():
+        print_error(f"File {path} already exists. The 'create' command cannot be used if the specified path already exists as a file.", "Error")
+        return (f"File {path} already exists. The 'create' command cannot be used if the specified path already exists as a file.", True)
+    
+    # Create parent directories if they don't exist
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Write the content to the file
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(file_text)
+        # Track file creation and line delta
+        get_tracker().increment('files_created')
+        get_tracker().increment('lines_delta', line_count)
+        # Show relative path if it's not an absolute path
+        display_path = path if os.path.isabs(path) else os.path.relpath(file_path, get_config().workspace_dir)
+        print_success(f"", "Success")
+        return (f"Successfully created file {display_path}", False)
+    except Exception as e:
+        print_error(f"Error creating file {path}: {str(e)}", "Error")
+        return (f"Error creating file {path}: {str(e)}", True)

janito/tools/str_replace_editor/handlers/insert.py

@@ -0,0 +1,100 @@
+"""
+Handler for the insert command in str_replace_editor.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from janito.tools.rich_console import print_info, print_success, print_error
+from janito.tools.usage_tracker import get_tracker
+from ..utils import normalize_path, _file_history
+
+def handle_insert(args: Dict[str, Any]) -> Tuple[str, bool]:
+    """
+    Insert text at a specific location in a file.
+    
+    Args:
+        args: Dictionary containing:
+            - path: Path to the file to modify
+            - insert_line: The line number after which to insert the text
+            - new_str: The text to insert
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    path = args.get("path")
+    insert_line = args.get("insert_line")
+    new_str = args.get("new_str")
+    
+    # Count lines in new string
+    new_lines_count = len(new_str.splitlines()) if new_str else 0
+    
+    print_info(f"Inserting text in file: {path}, after line {insert_line} (+{new_lines_count} lines)", "Insert Operation")
+    
+    if not path:
+        print_error("Missing required parameter: path", "Error")
+        return ("Missing required parameter: path", True)
+    if insert_line is None:
+        print_error("Missing required parameter: insert_line", "Error")
+        return ("Missing required parameter: insert_line", True)
+    if new_str is None:
+        print_error("Missing required parameter: new_str", "Error")
+        return ("Missing required parameter: new_str", True)
+    
+    # Store the original path for display purposes
+    original_path = path
+    
+    # Normalize the path (converts to absolute path)
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
+    
+    if not file_path.exists():
+        print_error(f"File {path} does not exist", "Error")
+        return (f"File {path} does not exist", True)
+    
+    try:
+        # Read the file content
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            content = "".join(lines)
+        
+        # Save the current content for undo
+        if path not in _file_history:
+            _file_history[path] = []
+        _file_history[path].append(content)
+        
+        # Check if insert_line is valid
+        if insert_line < 0 or insert_line > len(lines):
+            print_error(f"Invalid insert line {insert_line} for file {path}", "Error")
+            return (f"Invalid insert line {insert_line} for file {path}", True)
+        
+        # Ensure new_str ends with a newline if it doesn't already
+        if new_str and not new_str.endswith('\n'):
+            new_str += '\n'
+        
+        # Insert the new string
+        lines.insert(insert_line, new_str)
+        
+        # Track the number of lines inserted
+        lines_count = len(new_str.splitlines())
+        get_tracker().increment('lines_replaced', lines_count)
+        
+        # Write the new content
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.writelines(lines)
+        
+        # Show relative path if it's not an absolute path in the original input
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        
+        # If the response is too long, truncate it
+        response = f"Successfully inserted text at line {insert_line} in file {display_path}"
+        print_success(response, "Success")
+        if len(response) > 1000:  # Arbitrary limit for demonstration
+            return (response[:1000] + "\n<response clipped>", False)
+            
+        return (response, False)
+    except Exception as e:
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        error_msg = f"Error inserting text in file {display_path}: {str(e)}"
+        print_error(error_msg, "Error")
+        return (error_msg, True)

janito/tools/str_replace_editor/handlers/str_replace.py

@@ -0,0 +1,94 @@
+"""
+Handler for the str_replace command in str_replace_editor.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from janito.tools.rich_console import print_info, print_success, print_error
+from janito.tools.usage_tracker import get_tracker, count_lines_in_string
+from ..utils import normalize_path, _file_history
+
+def handle_str_replace(args: Dict[str, Any]) -> Tuple[str, bool]:
+    """
+    Replace a specific string in a file with a new string.
+    
+    Args:
+        args: Dictionary containing:
+            - path: Path to the file to modify
+            - old_str: The text to replace (must match EXACTLY)
+            - new_str: The new text to insert
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    path = args.get("path")
+    old_str = args.get("old_str")
+    new_str = args.get("new_str", "")  # new_str can be empty to effectively delete text
+    
+    # Count lines in old and new strings
+    old_lines_count = len(old_str.splitlines()) if old_str else 0
+    new_lines_count = len(new_str.splitlines()) if new_str else 0
+    line_delta = new_lines_count - old_lines_count
+    delta_sign = "+" if line_delta > 0 else "" if line_delta == 0 else "-"
+    
+    print_info(f"Replacing text in file: {path} ({old_lines_count} -> {new_lines_count} lines, {delta_sign}{abs(line_delta)})", "Replacing text in file")
+    
+    if not path:
+        print_error("Missing required parameter: path", "Error")
+        return ("Missing required parameter: path", True)
+    if old_str is None:
+        print_error("Missing required parameter: old_str", "Error")
+        return ("Missing required parameter: old_str", True)
+    
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
+    
+    if not file_path.exists():
+        print_error(f"File {path} does not exist", "Error")
+        return (f"File {path} does not exist", True)
+    
+    try:
+        # Read the file content
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Save the current content for undo
+        if path not in _file_history:
+            _file_history[path] = []
+        _file_history[path].append(content)
+        
+        # Check if old_str exists in the content (must match EXACTLY)
+        if old_str not in content:
+            # 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
+        match_count = content.count(old_str)
+        if match_count > 1:
+            print_error(f"Found {match_count} matches for replacement text. The old_str parameter is not unique in the file. Please include more context to make it unique.", "Error")
+            return (f"Error: Found {match_count} matches for replacement text. The old_str parameter is not unique in the file. Please include more context to make it unique.", True)
+        
+        # Replace the string
+        new_content = content.replace(old_str, new_str)
+        
+        # Track the number of lines replaced and the line delta
+        lines_changed, line_delta = count_lines_in_string(old_str, new_str)
+        get_tracker().increment('lines_replaced', lines_changed)
+        get_tracker().increment('lines_delta', line_delta)
+        
+        # Write the new content
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+        
+        # Show relative path if it's not an absolute path in the original input
+        display_path = args.get("path") if os.path.isabs(args.get("path")) else os.path.relpath(file_path, get_config().workspace_dir)
+        print_success(f"", "Success")
+        return (f"Successfully replaced string in file {display_path}", False)
+    except Exception as e:
+        # Show relative path if it's not an absolute path in the original input
+        display_path = args.get("path") if os.path.isabs(args.get("path")) else os.path.relpath(file_path, get_config().workspace_dir)
+        print_error(f"Error replacing string in file {display_path}: {str(e)}", "Error")
+        return (f"Error replacing string in file {display_path}: {str(e)}", True)

janito/tools/str_replace_editor/handlers/undo.py

@@ -0,0 +1,64 @@
+"""
+Handler for the undo_edit command in str_replace_editor.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from janito.tools.rich_console import print_info, print_success, print_error, print_warning
+from ..utils import normalize_path, _file_history
+
+def handle_undo_edit(args: Dict[str, Any]) -> Tuple[str, bool]:
+    """
+    Undo the last edit made to a file using in-memory history.
+    
+    Args:
+        args: Dictionary containing:
+            - path: Path to the file whose last edit should be undone
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    path = args.get("path")
+    
+    print_info(f"Undoing last edit to file: {path}", "Undo Operation")
+    
+    if not path:
+        print_error("Missing required parameter: path", "Error")
+        return ("Missing required parameter: path", True)
+    
+    # Store the original path for display purposes
+    original_path = path
+    
+    # Normalize the path (converts to absolute path)
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
+    
+    # Check if file exists
+    if not file_path.exists():
+        print_error(f"File {path} does not exist", "Error")
+        return (f"File {path} does not exist", True)
+    
+    # Check in-memory history
+    if path not in _file_history or not _file_history[path]:
+        print_warning(f"Warning: No edit history for file {path}")
+        return (f"No edit history for file {path}", True)
+    
+    try:
+        # Get the last content
+        last_content = _file_history[path].pop()
+        
+        # Write the last content back to the file
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(last_content)
+        
+        # Show relative path if it's not an absolute path in the original input
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        success_msg = f"Successfully reverted the last edit made to the file {display_path}"
+        print_success(success_msg, "Success")
+        return (success_msg, False)
+    except Exception as e:
+        display_path = original_path if os.path.isabs(original_path) else os.path.relpath(file_path, get_config().workspace_dir)
+        error_msg = f"Error undoing edit to file {display_path}: {str(e)}"
+        print_error(error_msg, "Error")
+        return (error_msg, True)

janito/tools/str_replace_editor/handlers/view.py

@@ -0,0 +1,159 @@
+"""
+Handler for the view command in str_replace_editor.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from janito.tools.rich_console import print_info, print_error, console
+from janito.tools.usage_tracker import get_tracker
+from ..utils import normalize_path
+
+def handle_view(args: Dict[str, Any]) -> Tuple[str, bool]:
+    """
+    View the contents of a file or list directory contents.
+    
+    Args:
+        args: Dictionary containing:
+            - path: Path to the file or directory to view
+            - view_range (optional): Array of two integers specifying start and end line numbers
+        
+    Returns:
+        A tuple containing (content_or_message, is_error)
+    """
+    path = args.get("path")
+    view_range = args.get("view_range")
+    
+    # First normalize the path to check if it's a file or directory
+    normalized_path = normalize_path(path)
+    file_path = pathlib.Path(normalized_path)
+    
+    if file_path.exists():
+        if file_path.is_dir():
+            print_info(f"Viewing directory: {path}: ", "Directory View")
+        else:
+            if view_range:
+                # Print with proper title for File View
+                print_info(f"Viewing file: {path}, from line {view_range[0]} to {view_range[1]}: ", "File View")
+            else:
+                # Print with proper title for File View
+                print_info(f"Viewing file: {path}, all lines: ", "File View")
+    else:
+        # If path doesn't exist yet, assume it's a file (will be validated later)
+        if view_range:
+            # Print with proper title for File View
+            print_info(f"Viewing file: {path}, from line {view_range[0]} to {view_range[1]}: ", "File View")
+        else:
+            # Print with proper title for File View
+            print_info(f"Viewing file: {path}, all lines: ", "File View")
+    
+    if not path:
+        print_error("Missing required parameter: path", "Error")
+        return ("Missing required parameter: path", True)
+    
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
+    
+    if not file_path.exists():
+        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():
+        try:
+            result = []
+            # Process the first level
+            for item in sorted(file_path.iterdir()):
+                if item.name.startswith('.'):
+                    continue  # Skip hidden files/directories
+                
+                if item.is_dir():
+                    result.append(f"{item.name}/")
+                    # Process the second level
+                    try:
+                        for subitem in sorted(item.iterdir()):
+                            if subitem.name.startswith('.'):
+                                continue  # Skip hidden files/directories
+                                
+                            if subitem.is_dir():
+                                result.append(f"{item.name}/{subitem.name}/")
+                            else:
+                                result.append(f"{item.name}/{subitem.name}")
+                    except PermissionError:
+                        # Skip directories we can't access
+                        pass
+                else:
+                    result.append(item.name)
+            
+            if not result:
+                return (f"Directory {path} is empty or contains only hidden files", False)
+            
+            # Track directory view
+            get_tracker().increment('file_views')
+            
+            # Directory listings should not be truncated
+            file_dir_count = len(result)
+            output = "\n".join(result)
+            
+            # 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)
+    
+    # If the path is a file, view its contents with cat -n style output
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.readlines()
+        
+        # If view_range is specified, return only the specified lines
+        if view_range:
+            start_line = max(1, view_range[0]) - 1  # Convert to 0-indexed
+            end_line = view_range[1] if view_range[1] != -1 else len(content)
+            end_line = min(end_line, len(content))
+            
+            # Adjust content to only include the specified lines
+            content = content[start_line:end_line]
+            
+            # Track partial file view
+            get_tracker().increment('partial_file_views')
+        else:
+            # Track full file view
+            get_tracker().increment('file_views')
+        
+        # Add line numbers to each line (cat -n style)
+        numbered_content = []
+        start_idx = 1 if view_range is None else view_range[0]
+        for i, line in enumerate(content):
+            line_number = start_idx + i
+            # Ensure line ends with newline
+            if not line.endswith('\n'):
+                line += '\n'
+            # Format line number in cyan color using Rich's styling
+            # Use a simpler approach with f-strings and Rich's console
+            
+            # Create a string with the line number that will be styled as cyan
+            line_num_str = f"{line_number:6d}\t{line}"
+            numbered_content.append(line_num_str)
+        
+        # Check if we need to truncate the output
+        MAX_LINES = 500  # Arbitrary limit for demonstration
+        if len(numbered_content) > MAX_LINES:
+            truncated_content = "".join(numbered_content[:MAX_LINES])
+            print(truncated_content + "\n<response clipped>")
+            return (truncated_content + "\n<response clipped>", False)
+        
+        content_to_print = "".join(numbered_content)
+        
+        # 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:
+        return (f"Error viewing file {path}: {str(e)}", True)

janito/tools/str_replace_editor/utils.py

@@ -2,7 +2,6 @@
 Utility functions for the str_replace_editor package.
 """
 import os
-from typing import Dict
 from janito.config import get_config
 
 def normalize_path(path: str) -> str: