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

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,92 @@
+"""
+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:
+            print_error("No exact match found for replacement. Please check your text and ensure whitespaces match exactly.", "Error")
+            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,153 @@
+"""
+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"File or directory {path} does not exist", "Error")
+        return (f"File or directory {path} does not exist", 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)
+            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)
+        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:

janito/tools/usage_tracker.py

@@ -0,0 +1,136 @@
+"""
+Tool usage tracking module for Janito.
+
+This module provides functionality to track tool usage statistics
+such as files modified, created, deleted, and lines replaced.
+"""
+
+from functools import wraps
+from typing import Dict, Any, Callable
+import threading
+
+# Global tracker instance
+_tracker = None
+_tracker_lock = threading.Lock()
+
+class ToolUsageTracker:
+    """Tracks usage statistics for Janito tools."""
+    
+    def __init__(self):
+        self.reset()
+    
+    def reset(self):
+        """Reset all counters to zero."""
+        self.files_modified = 0
+        self.files_created = 0
+        self.files_deleted = 0
+        self.files_moved = 0
+        self.lines_replaced = 0
+        self.lines_delta = 0  # Track the net change in number of lines
+        self.web_requests = 0
+        self.bash_commands = 0
+        self.user_prompts = 0
+        self.search_operations = 0
+        self.file_views = 0
+        self.partial_file_views = 0
+    
+    def increment(self, counter_name: str, value: int = 1):
+        """Increment a specific counter by the given value."""
+        if hasattr(self, counter_name):
+            setattr(self, counter_name, getattr(self, counter_name) + value)
+    
+    def get_stats(self) -> Dict[str, int]:
+        """Get all non-zero statistics as a dictionary."""
+        stats = {}
+        for attr_name in dir(self):
+            if not attr_name.startswith('_') and not callable(getattr(self, attr_name)):
+                value = getattr(self, attr_name)
+                if value > 0:
+                    # Convert attribute_name to "Attribute Name" format
+                    display_name = ' '.join(word.capitalize() for word in attr_name.split('_'))
+                    stats[display_name] = value
+        return stats
+
+
+def get_tracker() -> ToolUsageTracker:
+    """Get the global tracker instance."""
+    global _tracker
+    with _tracker_lock:
+        if _tracker is None:
+            _tracker = ToolUsageTracker()
+    return _tracker
+
+
+def reset_tracker():
+    """Reset the global tracker."""
+    get_tracker().reset()
+
+
+def track_usage(counter_name: str, increment_value: int = 1):
+    """
+    Decorator to track tool usage.
+    
+    Args:
+        counter_name: The name of the counter to increment
+        increment_value: Value to increment the counter by (default: 1)
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            # Only track successful operations
+            if isinstance(result, tuple) and len(result) >= 2:
+                message, is_error = result[0], result[1]
+                if not is_error:
+                    get_tracker().increment(counter_name, increment_value)
+            return result
+        return wrapper
+    return decorator
+
+
+def count_lines_in_string(old_str: str, new_str: str) -> tuple[int, int]:
+    """
+    Count the number of lines that differ between old_str and new_str.
+    
+    Args:
+        old_str: Original string
+        new_str: New string
+        
+    Returns:
+        Tuple of (number of lines that differ, line delta)
+    """
+    old_lines = old_str.splitlines()
+    new_lines = new_str.splitlines()
+    
+    # Calculate the line delta (positive for added lines, negative for removed lines)
+    line_delta = len(new_lines) - len(old_lines)
+    
+    # Simple approach: count the total number of lines changed
+    # For tracking purposes, we'll use the max to ensure we don't undercount
+    return max(len(old_lines), len(new_lines)), line_delta
+
+
+def print_usage_stats():
+    """Print the current usage statistics if any values are non-zero."""
+    stats = get_tracker().get_stats()
+    if stats:
+        from rich.console import Console
+        
+        console = Console()
+        
+        # Create a single-line summary of tool usage
+        summary_parts = []
+        for name, value in stats.items():
+            # Format lines delta with a sign
+            if name == "Lines Delta":
+                sign = "+" if value > 0 else "" if value == 0 else "-"
+                formatted_value = f"{sign}{abs(value)}"
+                summary_parts.append(f"{name}: {formatted_value}")
+            else:
+                summary_parts.append(f"{name}: {value}")
+        
+        summary = " | ".join(summary_parts)
+        
+        # Display with a rule similar to token usage
+        console.rule("[blue]Tool Usage[/blue]")
+        console.print(f"[blue]{summary}[/blue]", justify="center")