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

janito/tools/find_files.py

@@ -1,83 +1,102 @@
 import os
-import fnmatch
-from typing import List, Dict, Any, Tuple
-from janito.tools.decorators import tool_meta
+import glob
+import fnmatch  # Still needed for gitignore pattern matching
+from typing import List, Tuple
+from janito.tools.rich_console import print_info, print_success, print_error, print_warning
 
 
-@tool_meta(label="Finding files matching path pattern {pattern}, on {root_dir} ({recursive and 'recursive' or 'non-recursive'}, {respect_gitignore and 'respecting gitignore' or 'ignoring gitignore'})")
-def find_files(pattern: str, root_dir: str = ".", recursive: bool = True, respect_gitignore: bool = True) -> Tuple[str, bool]:
+def find_files(pattern: str, root_dir: str = ".", recursive: bool = True) -> Tuple[str, bool]:
     """
     Find files whose path matches a glob pattern.
+    Files in .gitignore are always ignored.
     
     Args:
         pattern: pattern to match file paths against (e.g., "*.py", "*/tools/*.py")
         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)
     """
+    # Print start message without newline
+    print_info(
+        f"Finding files matching path pattern {pattern}, on {root_dir} " +
+        f"({'recursive' if recursive else 'non-recursive'})",
+        title="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, title="File Operation")
+            return error_msg, True
         
         matching_files = []
         
-        # 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 more intuitive recursive behavior
+        # Check if the search pattern itself is in the gitignore
+        if _is_pattern_ignored(pattern, ignored_patterns):
+            warning_msg = f"Warning: The search pattern '{pattern}' matches patterns in .gitignore. Search may not yield expected results."
+            print_error(warning_msg, title="Text Search")
+            return warning_msg, True
+        
+        # Use glob for pattern matching
+        # 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:
-            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)]
-                
-                for filename in filenames:
-                    file_path = os.path.join(dirpath, filename)
-                    
-                    # Skip ignored files
-                    if respect_gitignore and _is_ignored(file_path, ignored_patterns, abs_root):
-                        continue
-                    
-                    # Convert to relative path from root_dir
-                    rel_path = os.path.relpath(file_path, abs_root)
-                    # Match against the relative path, not just the filename
-                    if fnmatch.fnmatch(rel_path, pattern):
-                        matching_files.append(rel_path)
+            # 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
-            for filename in os.listdir(abs_root):
-                file_path = os.path.join(abs_root, filename)
-                
-                # Skip ignored files
-                if respect_gitignore and _is_ignored(file_path, ignored_patterns, abs_root):
-                    continue
+            glob_files = glob.glob(glob_pattern)
+        
+        # Process the glob results
+        for file_path in glob_files:
+            # Skip directories
+            if not os.path.isfile(file_path):
+                continue
                 
-                if os.path.isfile(file_path):
-                    # Convert to relative path from root_dir
-                    rel_path = os.path.relpath(file_path, abs_root)
-                    # Match against the relative path, not just the filename
-                    if fnmatch.fnmatch(rel_path, pattern):
-                        matching_files.append(rel_path)
+            # Skip ignored files
+            if _is_ignored(file_path, ignored_patterns, abs_root):
+                continue
+            
+            # Convert to relative path from root_dir
+            rel_path = os.path.relpath(file_path, abs_root)
+            matching_files.append(rel_path)
         
         # Sort the files for consistent output
         matching_files.sort()
         
         if matching_files:
             file_list = "\n- ".join(matching_files)
-            return f"Found {len(matching_files)} files matching pattern '{pattern}':\n- {file_list}\n{len(matching_files)}", False
+            result_msg = f"{len(matching_files)} files found"
+            print_success(result_msg, title="Search Results")
+            return file_list, False
         else:
-            return f"No files found matching pattern '{pattern}' in '{root_dir}'", False
+            result_msg = "No files found"
+            print_success(result_msg, title="Search Results")
+            return result_msg, False
             
     except Exception as e:
-        return f"Error finding files: {str(e)}", True
+        error_msg = f"Error finding files: {str(e)}"
+        print_error(error_msg, title="Text Search")
+        return error_msg, True
 
 
 def _get_gitignore_patterns(root_dir: str) -> List[str]:
@@ -115,6 +134,49 @@ def _get_gitignore_patterns(root_dir: str) -> List[str]:
     return patterns
 
 
+def _is_pattern_ignored(search_pattern: str, gitignore_patterns: List[str]) -> bool:
+    """
+    Check if a search pattern conflicts with gitignore patterns.
+    
+    Args:
+        search_pattern: The search pattern to check
+        gitignore_patterns: List of gitignore patterns
+        
+    Returns:
+        True if the search pattern conflicts with gitignore patterns, False otherwise
+    """
+    # Remove any directory part from the search pattern
+    pattern_only = search_pattern.split('/')[-1]
+    
+    for git_pattern in gitignore_patterns:
+        # Skip negation patterns
+        if git_pattern.startswith('!'):
+            continue
+            
+        # Remove trailing slash for directory patterns
+        if git_pattern.endswith('/'):
+            git_pattern = git_pattern[:-1]
+            
+        # Direct match
+        if git_pattern == search_pattern or git_pattern == pattern_only:
+            return True
+            
+        # Check if the gitignore pattern is a prefix of the search pattern
+        if search_pattern.startswith(git_pattern) and (
+            len(git_pattern) == len(search_pattern) or 
+            search_pattern[len(git_pattern)] in ['/', '\\']
+        ):
+            return True
+            
+        # Check for wildcard matches
+        if '*' in git_pattern or '?' in git_pattern:
+            # Check if the search pattern would be caught by this gitignore pattern
+            if fnmatch.fnmatch(search_pattern, git_pattern) or fnmatch.fnmatch(pattern_only, git_pattern):
+                return True
+                
+    return False
+
+
 def _is_ignored(path: str, patterns: List[str], root_dir: str) -> bool:
     """
     Check if a path should be ignored based on gitignore patterns.

janito/tools/move_file.py

@@ -0,0 +1,72 @@
+"""
+Tool for moving files through the claudine agent.
+"""
+import shutil
+from pathlib import Path
+from typing import Tuple
+from janito.tools.str_replace_editor.utils import normalize_path
+from janito.tools.rich_console import print_info, print_success, print_error
+from janito.tools.usage_tracker import track_usage
+
+
+@track_usage('files_moved')
+def move_file(
+    source_path: str,
+    destination_path: str,
+) -> Tuple[str, bool]:
+    """
+    Move a file from source path to destination path.
+    
+    Args:
+        source_path: Path to the file to move, relative to the workspace directory
+        destination_path: Destination path where the file should be moved, relative to the workspace directory
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    print_info(f"Moving file from {source_path} to {destination_path}", "Move Operation")
+    
+    # Store the original paths for display purposes
+    original_source = source_path
+    original_destination = destination_path
+    
+    # Normalize the file paths (converts to absolute paths)
+    source = normalize_path(source_path)
+    destination = normalize_path(destination_path)
+    
+    # Convert to Path objects for better path handling
+    source_obj = Path(source)
+    destination_obj = Path(destination)
+    
+    # Check if the source file exists
+    if not source_obj.exists():
+        error_msg = f"Source file {original_source} does not exist."
+        print_error(error_msg, "Error")
+        return (error_msg, True)
+    
+    # Check if source is a directory
+    if source_obj.is_dir():
+        error_msg = f"{original_source} is a directory, not a file. Use move_directory for directories."
+        print_error(error_msg, "Error")
+        return (error_msg, True)
+    
+    # Check if destination directory exists
+    if not destination_obj.parent.exists():
+        try:
+            destination_obj.parent.mkdir(parents=True, exist_ok=True)
+            print_info(f"Created directory: {destination_obj.parent}", "Info")
+        except Exception as e:
+            error_msg = f"Error creating destination directory: {str(e)}"
+            print_error(error_msg, "Error")
+            return (error_msg, True)
+    
+    # Move the file
+    try:
+        shutil.move(str(source_obj), str(destination_obj))
+        success_msg = f"Successfully moved file from {original_source} to {original_destination}"
+        print_success(success_msg, "Success")
+        return (success_msg, False)
+    except Exception as e:
+        error_msg = f"Error moving file from {original_source} to {original_destination}: {str(e)}"
+        print_error(error_msg, "Error")
+        return (error_msg, True)

janito/tools/prompt_user.py

@@ -1,16 +1,24 @@
 """
 Tool for prompting the user for input through the claudine agent.
 """
-from typing import Tuple
-from janito.tools.decorators import tool_meta
+from typing import Tuple, List
+import sys
+import textwrap
+from rich.console import Console
+from janito.tools.rich_console import print_info, print_error, print_warning
+from janito.tools.usage_tracker import track_usage
+from janito.cli.utils import get_stdin_termination_hint
 
 
-@tool_meta(label="Prompting user with '{prompt_text}'")
+console = Console()
+
+@track_usage('user_prompts')
 def prompt_user(
     prompt_text: str,
 ) -> Tuple[str, bool]:
     """
     Prompt the user for input and return their response.
+    Displays the prompt in a panel and uses stdin for input.
     
     Args:
         prompt_text: Text to display to the user as a prompt
@@ -19,8 +27,31 @@ def prompt_user(
         A tuple containing (user_response, is_error)
     """
     try:
-        # Print the prompt and get user input
-        user_response = input(f"{prompt_text}")
+        # Display the prompt with ASCII header
+        console.print("\n" + "="*50)
+        console.print("USER PROMPT")
+        console.print("="*50)
+        console.print(prompt_text)
+        
+        # Show input instructions with stdin termination hint
+        termination_hint = get_stdin_termination_hint().replace("[bold yellow]", "").replace("[/bold yellow]", "")
+        print_info(f"Enter your response below. {termination_hint}\n", "Input Instructions")
+        
+        # Read input from stdin
+        lines = []
+        for line in sys.stdin:
+            lines.append(line.rstrip('\n'))
+        
+        # Join the lines with newlines to preserve the multiline format
+        user_response = "\n".join(lines)
+        
+        # If no input was provided, return a message
+        if not user_response.strip():
+            print_warning("No input was provided. Empty Input.")
+            return ("", False)
+            
         return (user_response, False)
     except Exception as e:
-        return (f"Error prompting user: {str(e)}", True)
+        error_msg = f"Error prompting user: {str(e)}"
+        print_error(error_msg, "Prompt Error")
+        return (error_msg, True)

janito/tools/replace_file.py

@@ -5,9 +5,12 @@ import os
 from typing import Tuple
 
 from janito.tools.decorators import tool
+from janito.tools.rich_console import print_info, print_success, print_error
+from janito.tools.usage_tracker import track_usage, get_tracker
 
 
 @tool
+@track_usage('files_modified')
 def replace_file(file_path: str, new_content: str) -> Tuple[str, bool]:
     """
     Replace an existing file with new content.
@@ -20,17 +23,41 @@ def replace_file(file_path: str, new_content: str) -> Tuple[str, bool]:
         A tuple containing (message, is_error)
     """
     try:
+        print_info(f"Replacing file '{file_path}'", "File Operation")
+        
         # Convert relative path to absolute path
         abs_path = os.path.abspath(file_path)
         
         # Check if file exists
         if not os.path.isfile(abs_path):
-            return f"Error: File '{file_path}' does not exist", True
+            error_msg = f"Error: File '{file_path}' does not exist"
+            print_error(error_msg, "File Error")
+            return error_msg, True
+        
+        # Read the original content to calculate line delta
+        try:
+            with open(abs_path, 'r', encoding='utf-8') as f:
+                old_content = f.read()
+            
+            # Calculate line delta
+            old_lines_count = len(old_content.splitlines()) if old_content else 0
+            new_lines_count = len(new_content.splitlines()) if new_content else 0
+            line_delta = new_lines_count - old_lines_count
+            
+            # Track line delta
+            get_tracker().increment('lines_delta', line_delta)
+        except Exception:
+            # If we can't read the file, we can't calculate line delta
+            pass
             
         # Write new content to the file
         with open(abs_path, 'w', encoding='utf-8') as f:
             f.write(new_content)
-            
-        return f"Successfully replaced file '{file_path}'", False
+        
+        success_msg = f"Successfully replaced file '{file_path}'"
+        print_success(success_msg, "Success")
+        return success_msg, False
     except Exception as e:
-        return f"Error replacing file '{file_path}': {str(e)}", True
+        error_msg = f"Error replacing file '{file_path}': {str(e)}"
+        print_error(error_msg, "Error")
+        return error_msg, True

janito/tools/rich_console.py

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