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

janito/tools/decorators.py

@@ -1,84 +1,101 @@
-"""
-Decorators for janito tools.
-"""
-import functools
-import inspect
-import string
-from typing import Any, Callable, Dict, Optional, Tuple
-
-
-class ToolMetaFormatter(string.Formatter):
-    """Custom string formatter that handles conditional expressions in format strings."""
-    
-    def get_value(self, key, args, kwargs):
-        """Override to handle conditional expressions."""
-        if key in kwargs:
-            return kwargs[key]
-        
-        # Try to evaluate the key as a Python expression
-        try:
-            # Create a safe local namespace with only the parameters
-            return eval(key, {"__builtins__": {}}, kwargs)
-        except Exception:
-            return f"[{key}]"
-
-
-def tool_meta(label: str):
-    """
-    Decorator to add metadata to a tool function.
-    
-    Args:
-        label: A format string that can reference function parameters.
-              Example: "Finding files {pattern}, on {root_dir}"
-              
-    Returns:
-        Decorated function with metadata attached
-    """
-    def decorator(func: Callable):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-        
-        # Attach metadata to the function
-        wrapper._tool_meta = {
-            'label': label
-        }
-        
-        return wrapper
-    
-    return decorator
-
-
-def format_tool_label(func: Callable, tool_input: Dict[str, Any]) -> Optional[str]:
-    """
-    Format the tool label using the function's parameters.
-    
-    Args:
-        func: The tool function
-        tool_input: Input parameters for the tool
-        
-    Returns:
-        Formatted label string or None if no label is defined
-    """
-    if not hasattr(func, '_tool_meta') or 'label' not in func._tool_meta:
-        return None
-    
-    # Get the label template
-    label_template = func._tool_meta['label']
-    
-    # Special handling for str_replace_editor which uses **kwargs
-    if func.__name__ == 'str_replace_editor':
-        # Extract command and file_path from tool_input if they exist
-        command = tool_input.get('command', 'unknown')
-        file_path = tool_input.get('file_path', '')
-        
-        # Simple string replacement for the common case
-        if '{command}' in label_template and '{file_path}' in label_template:
-            return label_template.replace('{command}', command).replace('{file_path}', file_path)
-    
-    # Format the label with the parameters
-    try:
-        formatter = ToolMetaFormatter()
-        return formatter.format(label_template, **tool_input)
-    except Exception as e:
-        return f"{func.__name__}"
+"""
+Decorators for janito tools.
+"""
+import functools
+import inspect
+import string
+from typing import Any, Callable, Dict, Optional, Tuple
+
+
+class ToolMetaFormatter(string.Formatter):
+    """Custom string formatter that handles conditional expressions in format strings."""
+    
+    def get_value(self, key, args, kwargs):
+        """Override to handle conditional expressions."""
+        if key in kwargs:
+            return kwargs[key]
+        
+        # Try to evaluate the key as a Python expression
+        try:
+            # Create a safe local namespace with only the parameters
+            return eval(key, {"__builtins__": {}}, kwargs)
+        except Exception:
+            return f"[{key}]"
+
+
+def tool_meta(label: str):
+    """
+    Decorator to add metadata to a tool function.
+    
+    Args:
+        label: A format string that can reference function parameters.
+              Example: "Finding files {pattern}, on {root_dir}"
+              
+    Returns:
+        Decorated function with metadata attached
+    """
+    def decorator(func: Callable):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        
+        # Attach metadata to the function
+        wrapper._tool_meta = {
+            'label': label
+        }
+        
+        return wrapper
+    
+    return decorator
+
+
+def tool(func: Callable):
+    """
+    Basic decorator for tool functions.
+    
+    This decorator marks a function as a tool and can be used for
+    simpler tools that don't need additional metadata.
+    
+    Returns:
+        Decorated function
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    
+    return wrapper
+
+
+def format_tool_label(func: Callable, tool_input: Dict[str, Any]) -> Optional[str]:
+    """
+    Format the tool label using the function's parameters.
+    
+    Args:
+        func: The tool function
+        tool_input: Input parameters for the tool
+        
+    Returns:
+        Formatted label string or None if no label is defined
+    """
+    if not hasattr(func, '_tool_meta') or 'label' not in func._tool_meta:
+        return None
+    
+    # Get the label template
+    label_template = func._tool_meta['label']
+    
+    # Special handling for str_replace_editor which uses **kwargs
+    if func.__name__ == 'str_replace_editor':
+        # Extract command and file_path from tool_input if they exist
+        command = tool_input.get('command', 'unknown')
+        file_path = tool_input.get('file_path', '')
+        
+        # Simple string replacement for the common case
+        if '{command}' in label_template and '{file_path}' in label_template:
+            return label_template.replace('{command}', command).replace('{file_path}', file_path)
+    
+    # Format the label with the parameters
+    try:
+        formatter = ToolMetaFormatter()
+        return formatter.format(label_template, **tool_input)
+    except Exception as e:
+        return f"{func.__name__}"

janito/tools/delete_file.py

@@ -1,44 +1,47 @@
-"""
-Tool for deleting files through the claudine agent.
-"""
-import os
-from pathlib import Path
-from typing import Dict, Any, Tuple
-from janito.config import get_config
-from janito.tools.str_replace_editor.utils import normalize_path
-from janito.tools.decorators import tool_meta
-
-
-@tool_meta(label="Deleting file {file_path}")
-def delete_file(
-    file_path: str,
-) -> Tuple[str, bool]:
-    """
-    Delete an existing file.
-    
-    Args:
-        file_path: Path to the file to delete, relative to the workspace directory
-        
-    Returns:
-        A tuple containing (message, is_error)
-    """
-    # Normalize the file path
-    path = normalize_path(file_path)
-    
-    # Convert to Path object for better path handling
-    path_obj = Path(path)
-    
-    # Check if the file exists
-    if not path_obj.exists():
-        return (f"File {path} does not exist.", True)
-    
-    # Check if it's a directory
-    if path_obj.is_dir():
-        return (f"{path} is a directory, not a file. Use delete_directory for directories.", True)
-    
-    # Delete the file
-    try:
-        path_obj.unlink()
-        return (f"Successfully deleted file {path}", False)
-    except Exception as e:
-        return (f"Error deleting file {path}: {str(e)}", True)
+"""
+Tool for deleting files through the claudine agent.
+"""
+import os
+from pathlib import Path
+from typing import Dict, Any, Tuple
+from janito.config import get_config
+from janito.tools.str_replace_editor.utils import normalize_path
+from janito.tools.decorators import tool_meta
+
+
+@tool_meta(label="Deleting file {file_path}")
+def delete_file(
+    file_path: str,
+) -> Tuple[str, bool]:
+    """
+    Delete an existing file.
+    
+    Args:
+        file_path: Path to the file to delete, relative to the workspace directory
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    # Store the original path for display purposes
+    original_path = file_path
+    
+    # Normalize the file path (converts to absolute path)
+    path = normalize_path(file_path)
+    
+    # Convert to Path object for better path handling
+    path_obj = Path(path)
+    
+    # Check if the file exists
+    if not path_obj.exists():
+        return (f"File {original_path} does not exist.", True)
+    
+    # Check if it's a directory
+    if path_obj.is_dir():
+        return (f"{original_path} is a directory, not a file. Use delete_directory for directories.", True)
+    
+    # Delete the file
+    try:
+        path_obj.unlink()
+        return (f"Successfully deleted file {original_path}", False)
+    except Exception as e:
+        return (f"Error deleting file {original_path}: {str(e)}", True)

janito/tools/find_files.py

@@ -4,13 +4,13 @@ from typing import List, Dict, Any, Tuple
 from janito.tools.decorators import tool_meta
 
 
-@tool_meta(label="Finding files {pattern}, on {root_dir} ({recursive and 'recursive' or 'non-recursive'}, {respect_gitignore and 'respecting gitignore' or 'ignoring gitignore'})")
+@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]:
     """
-    Find files whose name matches a glob pattern.
+    Find files whose path matches a glob pattern.
     
     Args:
-        pattern: pattern to match file names against
+        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)
@@ -39,7 +39,7 @@ def find_files(pattern: str, root_dir: str = ".", recursive: bool = True, respec
                 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, pattern):
+                for filename in filenames:
                     file_path = os.path.join(dirpath, filename)
                     
                     # Skip ignored files
@@ -48,10 +48,12 @@ def find_files(pattern: str, root_dir: str = ".", recursive: bool = True, respec
                     
                     # Convert to relative path from root_dir
                     rel_path = os.path.relpath(file_path, abs_root)
-                    matching_files.append(rel_path)
+                    # Match against the relative path, not just the filename
+                    if fnmatch.fnmatch(rel_path, pattern):
+                        matching_files.append(rel_path)
         else:
             # Non-recursive mode - only search in the specified directory
-            for filename in fnmatch.filter(os.listdir(abs_root), pattern):
+            for filename in os.listdir(abs_root):
                 file_path = os.path.join(abs_root, filename)
                 
                 # Skip ignored files
@@ -61,7 +63,9 @@ def find_files(pattern: str, root_dir: str = ".", recursive: bool = True, respec
                 if os.path.isfile(file_path):
                     # Convert to relative path from root_dir
                     rel_path = os.path.relpath(file_path, abs_root)
-                    matching_files.append(rel_path)
+                    # Match against the relative path, not just the filename
+                    if fnmatch.fnmatch(rel_path, pattern):
+                        matching_files.append(rel_path)
         
         # Sort the files for consistent output
         matching_files.sort()

janito/tools/prompt_user.py

@@ -0,0 +1,26 @@
+"""
+Tool for prompting the user for input through the claudine agent.
+"""
+from typing import Tuple
+from janito.tools.decorators import tool_meta
+
+
+@tool_meta(label="Prompting user with '{prompt_text}'")
+def prompt_user(
+    prompt_text: str,
+) -> Tuple[str, bool]:
+    """
+    Prompt the user for input and return their response.
+    
+    Args:
+        prompt_text: Text to display to the user as a prompt
+        
+    Returns:
+        A tuple containing (user_response, is_error)
+    """
+    try:
+        # Print the prompt and get user input
+        user_response = input(f"{prompt_text}")
+        return (user_response, False)
+    except Exception as e:
+        return (f"Error prompting user: {str(e)}", True)

janito/tools/replace_file.py

@@ -0,0 +1,36 @@
+"""
+Replace file tool that overwrites a file with new content.
+"""
+import os
+from typing import Tuple
+
+from janito.tools.decorators import tool
+
+
+@tool
+def replace_file(file_path: str, new_content: str) -> Tuple[str, bool]:
+    """
+    Replace an existing file with new content.
+    
+    Args:
+        file_path: Path to the file to replace, relative to the workspace directory
+        new_content: New content to write to the file
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    try:
+        # 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
+            
+        # 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
+    except Exception as e:
+        return f"Error replacing file '{file_path}': {str(e)}", True

janito/tools/str_replace_editor/editor.py

@@ -1,43 +1,52 @@
-"""
-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)
+"""
+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="File Command: ({command})")
+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`
+
+    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 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)