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

janito/tools/rich_console.py

@@ -1,176 +0,0 @@
-"""
-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()
-
-def print_info(message: str, title: Optional[str] = None):
-    """
-    Print an informational message with rich formatting.
-    
-    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
-    # Map titles to specific icons
-    icon_map = {
-        # File operations
-        "Delete Operation": "🗑️ ",
-        "Move Operation": "📦",
-        "File Operation": "📄",
-        "Directory View": "📁",
-        "File View": "📄",
-        "File Creation": "📝",
-        "Undo Operation": "↩️",
-        
-        # Search and find operations
-        "Text Search": "🔍",
-        "Search Results": "📊",
-        
-        # Web operations
-        "Web Fetch": "🌐",
-        "Content Extraction": "📰",
-        "News Extraction": "📰",
-        "Targeted Extraction": "🎯",
-        "Content Chunking": "📊",
-        "Content Ex": "📰",  # For truncated "Content Extraction" in search results
-        
-        # Command execution
-        "Bash Run": "🔄",
-        
-        # User interaction
-        "Input Instructions": "⌨️",
-        
-        # Default
-        "Info": "ℹ️ ",
-    }
-    
-    # Get the appropriate icon based on title and message content
-    icon = "ℹ️ "  # Default icon
-    
-    # Check for exact matches in the icon map based on title
-    if title and title in icon_map:
-        icon = icon_map[title]
-    else:
-        # Check for matching strings in both title and message
-        for key, value in icon_map.items():
-            # Skip the default "Info" key to avoid too many matches
-            if key == "Info":
-                continue
-                
-            # Check if the key appears in both title and message (if title exists)
-            if title and key in title and key in message:
-                icon = value
-                break
-                
-        # If no match found yet, check for partial matches for str_replace_editor operations
-        if title:
-            if "Replacing text in file" in title:
-                icon = "✏️ "  # Edit icon
-            elif "Inserting text in file" in title:
-                icon = "➕"  # Plus icon
-            elif "Viewing file" in title:
-                icon = "📄"  # File icon
-            elif "Viewing directory" in title:
-                icon = "📁"  # Directory icon
-            elif "Creating file" in title:
-                icon = "📝"  # Create icon
-            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"{indent}{icon} {title}", style="bold white on blue")
-            console.print("-"*50)
-            console.print(f"{indent}$ {text}", style="white on dark_blue")
-            # Make sure we're not returning anything
-            return
-        else:
-            console.print(f"{indent}{icon} {message}", style="blue", end="")
-    else:
-        console.print(f"{indent}{icon} {text}", style="blue", end="")
-
-def print_success(message: str, title: Optional[str] = None):
-    """
-    Print a success message with rich formatting.
-    
-    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:
-        console.print(f" ✅ {message}", style="green")
-    else:
-        console.print(f"✅ {text}", style="green")
-
-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)
-    
-    # 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="yellow")
-        else:
-            console.print(f"{message}", style="yellow")
-    else:
-        # 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

@@ -1,226 +0,0 @@
-import os
-import fnmatch
-import re
-import glob
-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
-
-
-@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
-        file_pattern: Pattern to match file paths against (e.g., "*.py", "*/tools/*.py")
-                     Multiple patterns can be specified using semicolons or spaces as separators
-        root_dir: Root directory to start search from (default: current directory)
-        recursive: Whether to search recursively in subdirectories (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):
-            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:
-            # 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
-        ignored_patterns = _get_gitignore_patterns(abs_root)
-        
-        # Handle multiple patterns separated by semicolons or spaces
-        patterns = []
-        if ';' in file_pattern:
-            patterns = file_pattern.split(';')
-        elif ' ' in file_pattern and not (os.path.sep in file_pattern or '/' in file_pattern):
-            # Only split by space if the pattern doesn't appear to be a path
-            patterns = file_pattern.split()
-        else:
-            patterns = [file_pattern]
-        
-        # Process each pattern
-        for pattern in patterns:
-            # Construct the glob pattern with the root directory
-            glob_pattern = os.path.join(abs_root, pattern) if not pattern.startswith(os.path.sep) else pattern
-            
-            # Use recursive glob if needed
-            if recursive:
-                # Use ** pattern for recursive search if not already in the pattern
-                if '**' not in glob_pattern:
-                    # Check if the pattern already has a directory component
-                    if os.path.sep in pattern or '/' in pattern:
-                        # Pattern already has directory component, keep as is
-                        pass
-                    else:
-                        # Add ** to search in all subdirectories
-                        glob_pattern = os.path.join(abs_root, '**', pattern)
-                
-                # Use recursive=True for Python 3.5+ glob
-                glob_files = glob.glob(glob_pattern, recursive=True)
-            else:
-                # Non-recursive mode - only search in the specified directory
-                glob_files = glob.glob(glob_pattern)
-            
-            # Process matching files
-            for file_path in glob_files:
-                # Skip directories and already processed files
-                if not os.path.isfile(file_path) or file_path in matching_files:
-                    continue
-                    
-                # Skip ignored files
-                if _is_ignored(file_path, ignored_patterns, abs_root):
-                    continue
-                
-                file_matches = _search_file(file_path, regex, abs_root)
-                if file_matches:
-                    matching_files.append(file_path)
-                    match_count += len(file_matches)
-                    results.append(f"\n{os.path.relpath(file_path, abs_root)} ({len(file_matches)} matches):")
-                    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)
-            result_msg = f"Searching for '{text_pattern}' in files matching '{file_pattern}':{result_text}\n{summary}"
-            return result_msg, False
-        else:
-            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:
-        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]:
-    """
-    Search for regex pattern in a file and return matching lines with line numbers.
-    
-    Args:
-        file_path: Path to the file to search
-        pattern: Compiled regex pattern to search for
-        root_dir: Root directory (for path display)
-        
-    Returns:
-        List of formatted matches with line numbers and content
-    """
-    matches = []
-    try:
-        with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
-            for i, line in enumerate(f, 1):
-                if pattern.search(line):
-                    # Truncate long lines for display
-                    display_line = line.strip()
-                    if len(display_line) > 100:
-                        display_line = display_line[:97] + "..."
-                    matches.append(f"  Line {i}: {display_line}")
-    except (UnicodeDecodeError, IOError):
-        # Skip binary files or files with encoding issues
-        pass
-    return matches
-
-
-def _get_gitignore_patterns(root_dir: str) -> List[str]:
-    """
-    Get patterns from .gitignore files.
-    
-    Args:
-        root_dir: Root directory to start from
-        
-    Returns:
-        List of gitignore patterns
-    """
-    patterns = []
-    
-    # Check for .gitignore in the root directory
-    gitignore_path = os.path.join(root_dir, '.gitignore')
-    if os.path.isfile(gitignore_path):
-        try:
-            with open(gitignore_path, 'r', encoding='utf-8') as f:
-                for line in f:
-                    line = line.strip()
-                    # Skip empty lines and comments
-                    if line and not line.startswith('#'):
-                        patterns.append(line)
-        except Exception:
-            pass
-    
-    # Add common patterns that are always ignored
-    common_patterns = [
-        '.git/', '.venv/', 'venv/', '__pycache__/', '*.pyc', 
-        '*.pyo', '*.pyd', '.DS_Store', '*.so', '*.egg-info/'
-    ]
-    patterns.extend(common_patterns)
-    
-    return patterns
-
-
-def _is_ignored(path: str, patterns: List[str], root_dir: str) -> bool:
-    """
-    Check if a path should be ignored based on gitignore patterns.
-    
-    Args:
-        path: Path to check
-        patterns: List of gitignore patterns
-        root_dir: Root directory for relative paths
-        
-    Returns:
-        True if the path should be ignored, False otherwise
-    """
-    # Get the relative path from the root directory
-    rel_path = os.path.relpath(path, root_dir)
-    
-    # Convert to forward slashes for consistency with gitignore patterns
-    rel_path = rel_path.replace(os.sep, '/')
-    
-    # Add trailing slash for directories
-    if os.path.isdir(path) and not rel_path.endswith('/'):
-        rel_path += '/'
-    
-    for pattern in patterns:
-        # Handle negation patterns (those starting with !)
-        if pattern.startswith('!'):
-            continue  # Skip negation patterns for simplicity
-        
-        # Handle directory-specific patterns (those ending with /)
-        if pattern.endswith('/'):
-            if os.path.isdir(path) and fnmatch.fnmatch(rel_path, pattern + '*'):
-                return True
-        
-        # Handle file patterns
-        if fnmatch.fnmatch(rel_path, pattern):
-            return True
-        
-        # Handle patterns without wildcards as path prefixes
-        if '*' not in pattern and '?' not in pattern and rel_path.startswith(pattern):
-            return True
-    
-    return False

janito/tools/str_replace_editor/__init__.py

@@ -1,6 +0,0 @@
-"""
-Package for implementing the Claude text editor functionality.
-"""
-from .editor import str_replace_editor
-
-__all__ = ["str_replace_editor"]

janito/tools/str_replace_editor/editor.py

@@ -1,55 +0,0 @@
-"""
-Main module for implementing the Claude text editor functionality.
-"""
-from typing import Tuple
-from janito.config import get_config
-from .handlers import (
-    handle_create,
-    handle_view,
-    handle_str_replace,
-    handle_insert,
-    handle_undo_edit
-)
-
-def str_replace_editor(**kwargs) -> Tuple[str, bool]:
-    """
-    Custom editing tool for viewing, creating and editing files
-    * State is persistent across command calls and discussions with the user
-    * If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep
-    * 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!
-    * If the `old_str` parameter is not unique in the file, the replacement will not be performed. Make sure to include enough context in `old_str` to make it unique
-    * The `new_str` parameter should contain the edited lines that should replace the `old_str`
-    
-    Args:
-        **kwargs: All arguments passed to the tool, including:
-            - command: The command to execute (view, create, str_replace, insert, undo_edit)
-            - path: Path to the file
-            - Additional command-specific arguments
-        
-    Returns:
-        A tuple containing (message, is_error)
-    """
-    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":
-        return handle_view(kwargs)
-    elif command == "str_replace":
-        return handle_str_replace(kwargs)
-    elif command == "insert":
-        return handle_insert(kwargs)
-    elif command == "undo_edit":
-        return handle_undo_edit(kwargs)
-    else:
-        return (f"Command '{command}' not implemented yet", True)

janito/tools/str_replace_editor/handlers/__init__.py

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

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

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