janito 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

janito/tools/search_text.py

@@ -0,0 +1,197 @@
+import os
+import fnmatch
+import re
+import pathlib
+from typing import List, Dict, Any, Tuple
+from janito.tools.decorators import tool_meta
+
+
+@tool_meta(label="Searching for '{text_pattern}' in files matching '{file_pattern}'")
+def search_text(text_pattern: str, file_pattern: str = "*", root_dir: str = ".", recursive: bool = True, respect_gitignore: bool = True) -> Tuple[str, bool]:
+    """
+    Search for text patterns within files matching a filename pattern.
+    
+    Args:
+        text_pattern: Text pattern to search for within files
+        file_pattern: Pattern to match file names against (default: "*" - all files)
+        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)
+    """
+    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
+        
+        # Compile the regex pattern for better performance
+        try:
+            regex = re.compile(text_pattern)
+        except re.error as e:
+            return f"Error: Invalid regex pattern '{text_pattern}': {str(e)}", True
+        
+        matching_files = []
+        match_count = 0
+        results = []
+        
+        # Get gitignore patterns if needed
+        ignored_patterns = []
+        if respect_gitignore:
+            ignored_patterns = _get_gitignore_patterns(abs_root)
+        
+        # Use os.walk for recursive behavior
+        if recursive:
+            for dirpath, dirnames, filenames in os.walk(abs_root):
+                # Skip ignored directories
+                if respect_gitignore:
+                    dirnames[:] = [d for d in dirnames if not _is_ignored(os.path.join(dirpath, d), ignored_patterns, abs_root)]
+                
+                for filename in fnmatch.filter(filenames, file_pattern):
+                    file_path = os.path.join(dirpath, filename)
+                    
+                    # Skip ignored files
+                    if respect_gitignore and _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)
+        else:
+            # Non-recursive mode - only search in the specified directory
+            for filename in fnmatch.filter(os.listdir(abs_root), file_pattern):
+                file_path = os.path.join(abs_root, filename)
+                
+                # Skip ignored files
+                if respect_gitignore and _is_ignored(file_path, ignored_patterns, abs_root):
+                    continue
+                
+                if os.path.isfile(file_path):
+                    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:
+            result_text = "\n".join(results)
+            summary = f"\n{match_count} matches in {len(matching_files)} files"
+            return f"Searching for '{text_pattern}' in files matching '{file_pattern}':{result_text}\n{summary}", False
+        else:
+            return f"No matches found for '{text_pattern}' in files matching '{file_pattern}' in '{root_dir}'", False
+            
+    except Exception as e:
+        return f"Error searching text: {str(e)}", 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) as e:
+        # 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

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

@@ -0,0 +1,43 @@
+"""
+Main module for implementing the Claude text editor functionality.
+"""
+from typing import Dict, Any, Tuple
+from .handlers import (
+    handle_create,
+    handle_view,
+    handle_str_replace,
+    handle_insert,
+    handle_undo_edit
+)
+from .utils import normalize_path
+from janito.tools.decorators import tool_meta
+
+@tool_meta(label="Editing file: {file_path} ({command})")
+def str_replace_editor(**kwargs) -> Tuple[str, bool]:
+    """
+    Handle text editor tool requests from Claude.
+    Implements the Claude text editor tool specification.
+    
+    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 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.py

@@ -0,0 +1,338 @@
+"""
+Command handlers for the str_replace_editor package.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from .utils import normalize_path, _file_history, backup_file, get_backup_info
+
+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", "")
+    
+    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
+    if file_path.exists():
+        return (f"File {path} already exists", 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)
+        # 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)
+        return (f"Successfully created file {display_path}", False)
+    except Exception as e:
+        return (f"Error creating file {path}: {str(e)}", True)
+
+
+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")
+    
+    if not path:
+        return ("Missing required parameter: path", True)
+    
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
+    
+    if not file_path.exists():
+        return (f"File or directory {path} does not exist", True)
+    
+    # If the path is a directory, list its contents
+    if file_path.is_dir():
+        try:
+            # Get all files and directories in the directory
+            items = list(file_path.iterdir())
+            
+            # Sort items (directories first, then files)
+            dirs = [item.name + "/" for item in items if item.is_dir()]
+            files = [item.name for item in items if item.is_file()]
+            
+            dirs.sort()
+            files.sort()
+            
+            # Combine the lists
+            contents = dirs + files
+            
+            if not contents:
+                return (f"Directory {path} is empty", False)
+            
+            # Add count information to the output
+            dir_count = len(dirs)
+            file_count = len(files)
+            count_info = f"Total: {len(contents)} ({dir_count} directories, {file_count} files)"
+            
+            return ("\n".join(contents) + f"\n{count_info}", False)
+        except Exception as e:
+            return (f"Error listing directory {path}: {str(e)}", True)
+    
+    # If the path is a file, view its contents
+    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]
+            
+            # Add line numbers to each line
+            numbered_content = []
+            for i, line in enumerate(content):
+                line_number = start_line + i + 1  # Convert back to 1-indexed
+                numbered_content.append(f"{line_number}: {line}")
+            
+            # Add line count information
+            line_count = end_line - start_line
+            
+            # 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)
+            line_info = f"Viewed {line_count} lines from {display_path}"
+            
+            return ("".join(numbered_content) + f"\n{line_info}", False)
+        else:
+            # Add line numbers to each line
+            numbered_content = []
+            for i, line in enumerate(content):
+                line_number = i + 1  # 1-indexed line numbers
+                numbered_content.append(f"{line_number}: {line}")
+            
+            # Add line count information
+            # 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)
+            line_info = f"Viewed {len(content)} lines from {display_path}"
+            
+            return ("".join(numbered_content) + f"\n{line_info}", False)
+    except Exception as e:
+        return (f"Error viewing file {path}: {str(e)}", True)
+
+
+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
+            - 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")
+    
+    if not path:
+        return ("Missing required parameter: path", True)
+    if old_str is None:
+        return ("Missing required parameter: old_str", True)
+    if new_str is None:
+        return ("Missing required parameter: new_str", True)
+    
+    path = normalize_path(path)
+    file_path = pathlib.Path(path)
+    
+    if not file_path.exists():
+        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()
+        
+        # Backup the file before making changes
+        backup_file(path, content)
+        
+        # Save the current content for undo (legacy approach, will be deprecated)
+        if path not in _file_history:
+            _file_history[path] = []
+        _file_history[path].append(content)
+        
+        # Check if old_str exists in the content
+        if old_str not in content:
+            return ("Error: No match found for replacement. Please check your text and try again.", True)
+        
+        # Count occurrences to check for multiple matches
+        match_count = content.count(old_str)
+        if match_count > 1:
+            return (f"Error: Found {match_count} matches for replacement text. Please provide more context to make a unique match.", True)
+        
+        # Replace the string
+        new_content = content.replace(old_str, new_str)
+        
+        # Write the new content
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+        
+        return (f"Successfully replaced string in file {path}", False)
+    except Exception as e:
+        return (f"Error replacing string in file {path}: {str(e)}", True)
+
+
+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")
+    
+    if not path:
+        return ("Missing required parameter: path", True)
+    if insert_line is None:
+        return ("Missing required parameter: insert_line", True)
+    if new_str is None:
+        return ("Missing required parameter: new_str", True)
+    
+    # Get the workspace directory from config
+    workspace_dir = get_config().workspace_dir
+    
+    # Make path absolute if it's not already
+    if not os.path.isabs(path):
+        path = os.path.join(workspace_dir, path)
+    
+    file_path = pathlib.Path(path)
+    
+    if not file_path.exists():
+        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)
+        
+        # Backup the file before making changes
+        backup_file(path, content)
+        
+        # Save the current content for undo (legacy approach, will be deprecated)
+        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):
+            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)
+        
+        # Write the new content
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.writelines(lines)
+        
+        return (f"Successfully inserted text at line {insert_line} in file {path}", False)
+    except Exception as e:
+        return (f"Error inserting text in file {path}: {str(e)}", True)
+
+
+def handle_undo_edit(args: Dict[str, Any]) -> Tuple[str, bool]:
+    """
+    Undo the last edit made to a file.
+    
+    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")
+    
+    if not path:
+        return ("Missing required parameter: path", True)
+    
+    # Get the workspace directory from config
+    workspace_dir = get_config().workspace_dir
+    
+    # Make path absolute if it's not already
+    if not os.path.isabs(path):
+        path = os.path.join(workspace_dir, path)
+    
+    # First try to use the file-based backup system
+    backup_info = get_backup_info()
+    if backup_info:
+        backup_path = backup_info['path']
+        backup_content = backup_info['content']
+        
+        # If a path was provided, check if it matches the backup
+        if path != backup_path:
+            return (f"No backup found for file {path}. Last edited file was {backup_path}", True)
+        
+        try:
+            # Write the backup content back to the file
+            with open(path, 'w', encoding='utf-8') as f:
+                f.write(backup_content)
+            
+            return (f"Successfully undid last edit to file {path}", False)
+        except Exception as e:
+            return (f"Error undoing edit to file {path}: {str(e)}", True)
+    
+    # Fall back to the in-memory history if no file backup exists
+    if path not in _file_history or not _file_history[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)
+        
+        return (f"Successfully undid last edit to file {path}", False)
+    except Exception as e:
+        return (f"Error undoing edit to file {path}: {str(e)}", True)

janito/tools/str_replace_editor/utils.py

@@ -0,0 +1,88 @@
+"""
+Utility functions for the str_replace_editor package.
+"""
+import os
+import pathlib
+from typing import Dict, Any, Optional
+from janito.config import get_config
+
+def normalize_path(path: str) -> str:
+    """
+    Normalizes a path relative to the workspace directory.
+    
+    Args:
+        path: The original path
+        
+    Returns:
+        The normalized path relative to the workspace directory
+    """
+    # 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:]
+    
+    # For relative paths, we should keep them relative
+    # Only prepend workspace_dir if we need to resolve the path
+    # against the workspace directory
+    return path
+
+def backup_file(file_path: str, content: str) -> None:
+    """
+    Backup a file before editing it.
+    
+    Args:
+        file_path: Path to the file being edited
+        content: Current content of the file
+    """
+    # Get workspace directory
+    workspace_dir = get_config().workspace_dir
+    
+    # Create .janito/undo directory in the workspace if it doesn't exist
+    backup_dir = pathlib.Path(workspace_dir) / ".janito" / "undo"
+    backup_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Store the original path
+    path_file = backup_dir / "path"
+    with open(path_file, 'w', encoding='utf-8') as f:
+        f.write(file_path)
+    
+    # Store the original content
+    content_file = backup_dir / "content"
+    with open(content_file, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+def get_backup_info() -> Optional[Dict[str, str]]:
+    """
+    Get the backup information for the last edited file.
+    
+    Returns:
+        Dictionary with 'path' and 'content' keys, or None if no backup exists
+    """
+    # Get workspace directory
+    workspace_dir = get_config().workspace_dir
+    
+    path_file = pathlib.Path(workspace_dir) / ".janito" / "undo" / "path"
+    content_file = pathlib.Path(workspace_dir) / ".janito" / "undo" / "content"
+    
+    if not path_file.exists() or not content_file.exists():
+        return None
+    
+    try:
+        with open(path_file, 'r', encoding='utf-8') as f:
+            path = f.read()
+        
+        with open(content_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        return {
+            'path': path,
+            'content': content
+        }
+    except Exception:
+        return None
+
+# Store file history for undo operations (in-memory backup, will be deprecated)
+_file_history = {}

{janito-0.8.0.dist-info/licenses → janito-0.9.0.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 João Pinto
+Copyright (c) [year] [copyright holder]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,7 +9,7 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and permission notice shall be included in all
+The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR