aider-ce 0.88.20__py3-none-any.whl → 0.88.38__py3-none-any.whl

aider/tools/ls.py

@@ -1,93 +1,77 @@
 import os
 
-schema = {
-    "type": "function",
-    "function": {
-        "name": "Ls",
-        "description": "List files in a directory.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "directory": {
-                    "type": "string",
-                    "description": "The directory to list.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "ls"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "Ls",
+            "description": "List files in a directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "directory": {
+                        "type": "string",
+                        "description": "The directory to list.",
+                    },
                 },
+                "required": ["directory"],
             },
-            "required": ["directory"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "ls"
-
-
-def execute_ls(coder, dir_path=None, directory=None):
-    # Handle both positional and keyword arguments for backward compatibility
-    if dir_path is None and directory is not None:
-        dir_path = directory
-    elif dir_path is None:
-        return "Error: Missing directory parameter"
-    """
-    List files in directory and optionally add some to context.
+    }
 
-    This provides information about the structure of the codebase,
-    similar to how a developer would explore directories.
-    """
-    try:
-        # Make the path relative to root if it's absolute
-        if dir_path.startswith("/"):
-            rel_dir = os.path.relpath(dir_path, coder.root)
-        else:
-            rel_dir = dir_path
+    @classmethod
+    def execute(cls, coder, dir_path=None, directory=None):
+        # Handle both positional and keyword arguments for backward compatibility
+        if dir_path is None and directory is not None:
+            dir_path = directory
+        elif dir_path is None:
+            return "Error: Missing directory parameter"
+        """
+        List files in directory and optionally add some to context.
 
-        # Get absolute path
-        abs_dir = coder.abs_root_path(rel_dir)
-
-        # Check if path exists
-        if not os.path.exists(abs_dir):
-            coder.io.tool_output(f"⚠️ Directory '{dir_path}' not found")
-            return "Directory not found"
-
-        # Get directory contents
-        contents = []
+        This provides information about the structure of the codebase,
+        similar to how a developer would explore directories.
+        """
         try:
-            with os.scandir(abs_dir) as entries:
-                for entry in entries:
-                    if entry.is_file() and not entry.name.startswith("."):
-                        rel_path = os.path.join(rel_dir, entry.name)
-                        contents.append(rel_path)
-        except NotADirectoryError:
-            # If it's a file, just return the file
-            contents = [rel_dir]
-
-        if contents:
-            coder.io.tool_output(f"📋 Listed {len(contents)} file(s) in '{dir_path}'")
-            if len(contents) > 10:
-                return f"Found {len(contents)} files: {', '.join(contents[:10])}..."
+            # Make the path relative to root if it's absolute
+            if dir_path.startswith("/"):
+                rel_dir = os.path.relpath(dir_path, coder.root)
             else:
-                return f"Found {len(contents)} files: {', '.join(contents)}"
-        else:
-            coder.io.tool_output(f"📋 No files found in '{dir_path}'")
-            return "No files found in directory"
-    except Exception as e:
-        coder.io.tool_error(f"Error in ls: {str(e)}")
-        return f"Error: {str(e)}"
+                rel_dir = dir_path
 
+            # Get absolute path
+            abs_dir = coder.abs_root_path(rel_dir)
 
-def process_response(coder, params):
-    """
-    Process the Ls tool response.
+            # Check if path exists
+            if not os.path.exists(abs_dir):
+                coder.io.tool_output(f"⚠️ Directory '{dir_path}' not found")
+                return "Directory not found"
 
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
+            # Get directory contents
+            contents = []
+            try:
+                with os.scandir(abs_dir) as entries:
+                    for entry in entries:
+                        if entry.is_file() and not entry.name.startswith("."):
+                            rel_path = os.path.join(rel_dir, entry.name)
+                            contents.append(rel_path)
+            except NotADirectoryError:
+                # If it's a file, just return the file
+                contents = [rel_dir]
 
-    Returns:
-        str: Result message
-    """
-    directory = params.get("directory")
-    if directory is not None:
-        return execute_ls(coder, directory)
-    else:
-        return "Error: Missing 'directory' parameter for Ls"
+            if contents:
+                coder.io.tool_output(f"📋 Listed {len(contents)} file(s) in '{dir_path}'")
+                if len(contents) > 10:
+                    return f"Found {len(contents)} files: {', '.join(contents[:10])}..."
+                else:
+                    return f"Found {len(contents)} files: {', '.join(contents)}"
+            else:
+                coder.io.tool_output(f"📋 No files found in '{dir_path}'")
+                return "No files found in directory"
+        except Exception as e:
+            coder.io.tool_error(f"Error in ls: {str(e)}")
+            return f"Error: {str(e)}"

aider/tools/make_editable.py

@@ -1,85 +1,69 @@
 import os
 
-schema = {
-    "type": "function",
-    "function": {
-        "name": "MakeEditable",
-        "description": "Make a read-only file editable.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "file_path": {
-                    "type": "string",
-                    "description": "The path to the file to make editable.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "makeeditable"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "MakeEditable",
+            "description": "Make a read-only file editable.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "The path to the file to make editable.",
+                    },
                 },
+                "required": ["file_path"],
             },
-            "required": ["file_path"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "makeeditable"
-
-
-# Keep the underscore prefix as this function is primarily for internal coder use
-def _execute_make_editable(coder, file_path):
-    """
-    Convert a read-only file to an editable file.
-
-    This allows the LLM to upgrade a file from read-only to editable
-    when it determines it needs to make changes to that file.
-    """
-    try:
-        # Get absolute path
-        abs_path = coder.abs_root_path(file_path)
-
-        # Check if file is already editable
-        if abs_path in coder.abs_fnames:
-            coder.io.tool_output(f"📝 File '{file_path}' is already editable")
-            return "File is already editable"
-
-        # Check if file exists on disk
-        if not os.path.isfile(abs_path):
-            coder.io.tool_output(f"⚠️ File '{file_path}' not found")
-            return "Error: File not found"
+    }
 
-        # File exists, is not editable, might be read-only or not in context yet
-        was_read_only = False
-        if abs_path in coder.abs_read_only_fnames:
-            coder.abs_read_only_fnames.remove(abs_path)
-            was_read_only = True
+    # Keep the underscore prefix as this function is primarily for internal coder use
+    @classmethod
+    def execute(cls, coder, file_path):
+        """
+        Convert a read-only file to an editable file.
 
-        # Add to editable files
-        coder.abs_fnames.add(abs_path)
+        This allows the LLM to upgrade a file from read-only to editable
+        when it determines it needs to make changes to that file.
+        """
+        try:
+            # Get absolute path
+            abs_path = coder.abs_root_path(file_path)
 
-        if was_read_only:
-            coder.io.tool_output(f"📝 Moved '{file_path}' from read-only to editable")
-            return "File is now editable (moved from read-only)"
-        else:
-            # File was not previously in context at all
-            coder.io.tool_output(f"📝 Added '{file_path}' directly to editable context")
-            # Track if added during exploration? Maybe not needed for direct MakeEditable.
-            # coder.files_added_in_exploration.add(rel_path) # Consider if needed
-            return "File is now editable (added directly)"
-    except Exception as e:
-        coder.io.tool_error(f"Error in MakeEditable for '{file_path}': {str(e)}")
-        return f"Error: {str(e)}"
+            # Check if file is already editable
+            if abs_path in coder.abs_fnames:
+                coder.io.tool_output(f"📝 File '{file_path}' is already editable")
+                return "File is already editable"
 
+            # Check if file exists on disk
+            if not os.path.isfile(abs_path):
+                coder.io.tool_output(f"⚠️ File '{file_path}' not found")
+                return "Error: File not found"
 
-def process_response(coder, params):
-    """
-    Process the MakeEditable tool response.
+            # File exists, is not editable, might be read-only or not in context yet
+            was_read_only = False
+            if abs_path in coder.abs_read_only_fnames:
+                coder.abs_read_only_fnames.remove(abs_path)
+                was_read_only = True
 
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
+            # Add to editable files
+            coder.abs_fnames.add(abs_path)
 
-    Returns:
-        str: Result message
-    """
-    file_path = params.get("file_path")
-    if file_path is not None:
-        return _execute_make_editable(coder, file_path)
-    else:
-        return "Error: Missing 'file_path' parameter for MakeEditable"
+            if was_read_only:
+                coder.io.tool_output(f"📝 Moved '{file_path}' from read-only to editable")
+                return "File is now editable (moved from read-only)"
+            else:
+                # File was not previously in context at all
+                coder.io.tool_output(f"📝 Added '{file_path}' directly to editable context")
+                # Track if added during exploration? Maybe not needed for direct MakeEditable.
+                # coder.files_added_in_exploration.add(rel_path) # Consider if needed
+                return "File is now editable (added directly)"
+        except Exception as e:
+            coder.io.tool_error(f"Error in MakeEditable for '{file_path}': {str(e)}")
+            return f"Error: {str(e)}"

aider/tools/make_readonly.py

@@ -1,69 +1,53 @@
-schema = {
-    "type": "function",
-    "function": {
-        "name": "MakeReadonly",
-        "description": "Make an editable file read-only.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "file_path": {
-                    "type": "string",
-                    "description": "The path to the file to make read-only.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "makereadonly"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "MakeReadonly",
+            "description": "Make an editable file read-only.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "The path to the file to make read-only.",
+                    },
                 },
+                "required": ["file_path"],
             },
-            "required": ["file_path"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "makereadonly"
-
-
-def _execute_make_readonly(coder, file_path):
-    """
-    Convert an editable file to a read-only file.
-
-    This allows the LLM to downgrade a file from editable to read-only
-    when it determines it no longer needs to make changes to that file.
-    """
-    try:
-        # Get absolute path
-        abs_path = coder.abs_root_path(file_path)
-
-        # Check if file is in editable context
-        if abs_path not in coder.abs_fnames:
-            if abs_path in coder.abs_read_only_fnames:
-                coder.io.tool_output(f"📚 File '{file_path}' is already read-only")
-                return "File is already read-only"
-            else:
-                coder.io.tool_output(f"⚠️ File '{file_path}' not in context")
-                return "File not in context"
-
-        # Move from editable to read-only
-        coder.abs_fnames.remove(abs_path)
-        coder.abs_read_only_fnames.add(abs_path)
-
-        coder.io.tool_output(f"📚 Made '{file_path}' read-only")
-        return "File is now read-only"
-    except Exception as e:
-        coder.io.tool_error(f"Error making file read-only: {str(e)}")
-        return f"Error: {str(e)}"
-
-
-def process_response(coder, params):
-    """
-    Process the MakeReadonly tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    file_path = params.get("file_path")
-    if file_path is not None:
-        return _execute_make_readonly(coder, file_path)
-    else:
-        return "Error: Missing 'file_path' parameter for MakeReadonly"
+    }
+
+    @classmethod
+    def execute(cls, coder, file_path):
+        """
+        Convert an editable file to a read-only file.
+
+        This allows the LLM to downgrade a file from editable to read-only
+        when it determines it no longer needs to make changes to that file.
+        """
+        try:
+            # Get absolute path
+            abs_path = coder.abs_root_path(file_path)
+
+            # Check if file is in editable context
+            if abs_path not in coder.abs_fnames:
+                if abs_path in coder.abs_read_only_fnames:
+                    coder.io.tool_output(f"📚 File '{file_path}' is already read-only")
+                    return "File is already read-only"
+                else:
+                    coder.io.tool_output(f"⚠️ File '{file_path}' not in context")
+                    return "File not in context"
+
+            # Move from editable to read-only
+            coder.abs_fnames.remove(abs_path)
+            coder.abs_read_only_fnames.add(abs_path)
+
+            coder.io.tool_output(f"📚 Made '{file_path}' read-only")
+            return "File is now read-only"
+        except Exception as e:
+            coder.io.tool_error(f"Error making file read-only: {str(e)}")
+            return f"Error: {str(e)}"

aider/tools/remove.py

@@ -1,91 +1,75 @@
 import time
 
-schema = {
-    "type": "function",
-    "function": {
-        "name": "Remove",
-        "description": (
-            "Remove a file from the chat context. Should be used proactively to keep con"
-            "Should be used after editing a file when all edits are done "
-            "and the file is no longer necessary in context."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "file_path": {
-                    "type": "string",
-                    "description": "The path to the file to remove.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "remove"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "Remove",
+            "description": (
+                "Remove a file from the chat context. Should be used proactively to keep con"
+                "Should be used after editing a file when all edits are done "
+                "and the file is no longer necessary in context."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "The path to the file to remove.",
+                    },
                 },
+                "required": ["file_path"],
             },
-            "required": ["file_path"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "remove"
-
-
-def _execute_remove(coder, file_path):
-    """
-    Explicitly remove a file from context.
-
-    This allows the LLM to clean up its context when files are no
-    longer needed, keeping the context focused and efficient.
-    """
-    try:
-        # Get absolute path
-        abs_path = coder.abs_root_path(file_path)
-        rel_path = coder.get_rel_fname(abs_path)
-
-        # Check if file is in context (either editable or read-only)
-        removed = False
-        if abs_path in coder.abs_fnames:
-            # Don't remove if it's the last editable file and there are no read-only files
-            if len(coder.abs_fnames) <= 1 and not coder.abs_read_only_fnames:
-                coder.io.tool_output(
-                    f"⚠️ Cannot remove '{file_path}' - it's the only file in context"
-                )
-                return "Cannot remove - last file in context"
-            coder.abs_fnames.remove(abs_path)
-            removed = True
-        elif abs_path in coder.abs_read_only_fnames:
-            # Don't remove if it's the last read-only file and there are no editable files
-            if len(coder.abs_read_only_fnames) <= 1 and not coder.abs_fnames:
-                coder.io.tool_output(
-                    f"⚠️ Cannot remove '{file_path}' - it's the only file in context"
-                )
-                return "Cannot remove - last file in context"
-            coder.abs_read_only_fnames.remove(abs_path)
-            removed = True
-
-        if not removed:
-            coder.io.tool_output(f"⚠️ File '{file_path}' not in context")
-            return "File not in context"
+    }
 
-        # Track in recently removed
-        coder.recently_removed[rel_path] = {"removed_at": time.time()}
+    @classmethod
+    def execute(cls, coder, file_path):
+        """
+        Explicitly remove a file from context.
 
-        coder.io.tool_output(f"🗑️ Explicitly removed '{file_path}' from context")
-        return "Removed file from context"
-    except Exception as e:
-        coder.io.tool_error(f"Error removing file: {str(e)}")
-        return f"Error: {str(e)}"
+        This allows the LLM to clean up its context when files are no
+        longer needed, keeping the context focused and efficient.
+        """
+        try:
+            # Get absolute path
+            abs_path = coder.abs_root_path(file_path)
+            rel_path = coder.get_rel_fname(abs_path)
 
+            # Check if file is in context (either editable or read-only)
+            removed = False
+            if abs_path in coder.abs_fnames:
+                # Don't remove if it's the last editable file and there are no read-only files
+                if len(coder.abs_fnames) <= 1 and not coder.abs_read_only_fnames:
+                    coder.io.tool_output(
+                        f"⚠️ Cannot remove '{file_path}' - it's the only file in context"
+                    )
+                    return "Cannot remove - last file in context"
+                coder.abs_fnames.remove(abs_path)
+                removed = True
+            elif abs_path in coder.abs_read_only_fnames:
+                # Don't remove if it's the last read-only file and there are no editable files
+                if len(coder.abs_read_only_fnames) <= 1 and not coder.abs_fnames:
+                    coder.io.tool_output(
+                        f"⚠️ Cannot remove '{file_path}' - it's the only file in context"
+                    )
+                    return "Cannot remove - last file in context"
+                coder.abs_read_only_fnames.remove(abs_path)
+                removed = True
 
-def process_response(coder, params):
-    """
-    Process the Remove tool response.
+            if not removed:
+                coder.io.tool_output(f"⚠️ File '{file_path}' not in context")
+                return "File not in context"
 
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
+            # Track in recently removed
+            coder.recently_removed[rel_path] = {"removed_at": time.time()}
 
-    Returns:
-        str: Result message
-    """
-    file_path = params.get("file_path")
-    if file_path is not None:
-        return _execute_remove(coder, file_path)
-    else:
-        return "Error: Missing 'file_path' parameter for Remove"
+            coder.io.tool_output(f"🗑️ Explicitly removed '{file_path}' from context")
+            return "Removed file from context"
+        except Exception as e:
+            coder.io.tool_error(f"Error removing file: {str(e)}")
+            return f"Error: {str(e)}"