janito 0.14.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

janito/tools/str_replace_editor/handlers/str_replace.py

@@ -1,94 +0,0 @@
-"""
-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

@@ -1,64 +0,0 @@
-"""
-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

@@ -1,159 +0,0 @@
-"""
-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

@@ -1,33 +0,0 @@
-"""
-Utility functions for the str_replace_editor package.
-"""
-import os
-from janito.config import get_config
-
-def normalize_path(path: str) -> str:
-    """
-    Normalizes a path relative to the workspace directory.
-    
-    For internal operations, converts relative paths to absolute paths
-    based on the workspace directory.
-    
-    Args:
-        path: The original path
-        
-    Returns:
-        The normalized absolute path
-    """
-    # If path is absolute, return it as is
-    if os.path.isabs(path):
-        return path
-    
-    # Handle paths starting with ./ by removing the ./ prefix
-    if path.startswith('./'):
-        path = path[2:]
-    
-    # Convert relative paths to absolute paths for internal operations
-    workspace_dir = get_config().workspace_dir
-    return os.path.normpath(os.path.join(workspace_dir, path))
-
-# Store file history for undo operations (in-memory backup)
-_file_history = {}

janito/tools/think.py

@@ -1,37 +0,0 @@
-"""
-Tool for thinking about something without obtaining new information or changing the database.
-"""
-from typing import Tuple
-import logging
-from janito.tools.usage_tracker import track_usage
-from janito.tools.rich_console import print_info
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-@track_usage('thoughts')
-def think(
-    thought: str,
-) -> Tuple[str, bool]:
-    """
-    Use the tool to think about something. It will not obtain new information or change the database,
-    but just append the thought to the log. Use it when complex reasoning or some cache memory is needed.
-    
-    Args:
-        thought: A thought to think about.
-        
-    Returns:
-        A tuple containing (message, is_error)
-    """
-    try:
-        # Log the thought
-        logger.info(f"Thought: {thought}")
-        
-        # Print a confirmation message
-        print_info(f"Thought recorded: {thought[:50]}{'...' if len(thought) > 50 else ''}", "Thinking")
-        
-        return (f"Thought recorded: {thought}", False)
-    except Exception as e:
-        error_msg = f"Error recording thought: {str(e)}"
-        logger.error(error_msg)
-        return (error_msg, True)

janito/tools/usage_tracker.py

@@ -1,137 +0,0 @@
-"""
-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
-        self.thoughts = 0  # Track the number of thoughts recorded
-    
-    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")