aider-ce 0.87.13.dev3__py3-none-any.whl → 0.88.0__py3-none-any.whl

aider/tools/grep.py

@@ -1,9 +1,54 @@
-import shlex
 import shutil
 from pathlib import Path
 
+import oslex
+
 from aider.run_cmd import run_cmd_subprocess
 
+grep_schema = {
+    "type": "function",
+    "function": {
+        "name": "Grep",
+        "description": "Search for a pattern in files.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "The pattern to search for.",
+                },
+                "file_pattern": {
+                    "type": "string",
+                    "description": "Glob pattern for files to search. Defaults to '*'.",
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Directory to search in. Defaults to '.'.",
+                },
+                "use_regex": {
+                    "type": "boolean",
+                    "description": "Whether to use regex. Defaults to False.",
+                },
+                "case_insensitive": {
+                    "type": "boolean",
+                    "description": (
+                        "Whether to perform a case-insensitive search. Defaults to False."
+                    ),
+                },
+                "context_before": {
+                    "type": "integer",
+                    "description": "Number of lines to show before a match. Defaults to 5.",
+                },
+                "context_after": {
+                    "type": "integer",
+                    "description": "Number of lines to show after a match. Defaults to 5.",
+                },
+            },
+            "required": ["pattern"],
+        },
+    },
+}
+
 
 def _find_search_tool():
     """Find the best available command-line search tool (rg, ag, grep)."""
@@ -117,7 +162,7 @@ def _execute_grep(
         cmd_args.extend([pattern, str(search_dir_path)])
 
         # Convert list to command string for run_cmd_subprocess
-        command_string = shlex.join(cmd_args)
+        command_string = oslex.join(cmd_args)
 
         coder.io.tool_output(f"⚙️ Executing {tool_name}: {command_string}")
 

aider/tools/indent_lines.py

@@ -10,6 +10,29 @@ from .tool_utils import (
     validate_file_for_edit,
 )
 
+indent_lines_schema = {
+    "type": "function",
+    "function": {
+        "name": "IndentLines",
+        "description": "Indent a block of lines in a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "start_pattern": {"type": "string"},
+                "end_pattern": {"type": "string"},
+                "line_count": {"type": "integer"},
+                "indent_levels": {"type": "integer", "default": 1},
+                "near_context": {"type": "string"},
+                "occurrence": {"type": "integer", "default": 1},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "start_pattern"],
+        },
+    },
+}
+
 
 def _execute_indent_lines(
     coder,
@@ -138,6 +161,8 @@ def _execute_indent_lines(
             change_id,
         )
 
+        coder.files_edited_by_tools.add(rel_path)
+
         # 8. Format and return result
         action_past = "Indented" if indent_levels > 0 else "Unindented"
         success_message = (

aider/tools/insert_block.py

@@ -12,6 +12,30 @@ from .tool_utils import (
     validate_file_for_edit,
 )
 
+insert_block_schema = {
+    "type": "function",
+    "function": {
+        "name": "InsertBlock",
+        "description": "Insert a block of content into a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "content": {"type": "string"},
+                "after_pattern": {"type": "string"},
+                "before_pattern": {"type": "string"},
+                "occurrence": {"type": "integer", "default": 1},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+                "position": {"type": "string", "enum": ["top", "bottom"]},
+                "auto_indent": {"type": "boolean", "default": True},
+                "use_regex": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "content"],
+        },
+    },
+}
+
 
 def _execute_insert_block(
     coder,
@@ -187,6 +211,8 @@ def _execute_insert_block(
             change_id,
         )
 
+        coder.files_edited_by_tools.add(rel_path)
+
         # 9. Format and return result
         if position:
             success_message = f"Inserted block {pattern_type} {file_path}"

aider/tools/list_changes.py

@@ -1,6 +1,21 @@
 import traceback
 from datetime import datetime
 
+list_changes_schema = {
+    "type": "function",
+    "function": {
+        "name": "ListChanges",
+        "description": "List recent changes made.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "limit": {"type": "integer", "default": 10},
+            },
+        },
+    },
+}
+
 
 def _execute_list_changes(coder, file_path=None, limit=10):
     """

aider/tools/ls.py

@@ -1,7 +1,30 @@
 import os
 
+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"],
+        },
+    },
+}
 
-def execute_ls(coder, dir_path):
+
+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.
 

aider/tools/make_editable.py

@@ -1,5 +1,23 @@
 import os
 
+make_editable_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"],
+        },
+    },
+}
+
 
 # Keep the underscore prefix as this function is primarily for internal coder use
 def _execute_make_editable(coder, file_path):

aider/tools/make_readonly.py

@@ -1,3 +1,22 @@
+make_readonly_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"],
+        },
+    },
+}
+
+
 def _execute_make_readonly(coder, file_path):
     """
     Convert an editable file to a read-only file.

aider/tools/remove.py

@@ -1,5 +1,27 @@
 import time
 
+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"],
+        },
+    },
+}
+
 
 def _execute_remove(coder, file_path):
     """

aider/tools/replace_all.py

@@ -7,6 +7,25 @@ from .tool_utils import (
     validate_file_for_edit,
 )
 
+replace_all_schema = {
+    "type": "function",
+    "function": {
+        "name": "ReplaceAll",
+        "description": "Replace all occurrences of text in a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "find_text": {"type": "string"},
+                "replace_text": {"type": "string"},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "find_text", "replace_text"],
+        },
+    },
+}
+
 
 def _execute_replace_all(coder, file_path, find_text, replace_text, change_id=None, dry_run=False):
     """
@@ -63,6 +82,8 @@ def _execute_replace_all(coder, file_path, find_text, replace_text, change_id=No
             change_id,
         )
 
+        coder.files_edited_by_tools.add(rel_path)
+
         # 7. Format and return result
         success_message = f"Replaced {count} occurrences in {file_path}"
         return format_tool_result(

aider/tools/replace_line.py

@@ -1,6 +1,25 @@
 import os
 import traceback
 
+replace_line_schema = {
+    "type": "function",
+    "function": {
+        "name": "ReplaceLine",
+        "description": "Replace a single line in a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "line_number": {"type": "integer"},
+                "new_content": {"type": "string"},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "line_number", "new_content"],
+        },
+    },
+}
+
 
 def _execute_replace_line(
     coder, file_path, line_number, new_content, change_id=None, dry_run=False
@@ -112,7 +131,7 @@ def _execute_replace_line(
             coder.io.tool_error(f"Error tracking change for ReplaceLine: {track_e}")
             change_id = "TRACKING_FAILED"
 
-        coder.aider_edited_files.add(rel_path)
+        coder.files_edited_by_tools.add(rel_path)
 
         # Improve feedback
         coder.io.tool_output(

aider/tools/replace_lines.py

@@ -8,6 +8,26 @@ from .tool_utils import (
     handle_tool_error,
 )
 
+replace_lines_schema = {
+    "type": "function",
+    "function": {
+        "name": "ReplaceLines",
+        "description": "Replace a range of lines in a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "start_line": {"type": "integer"},
+                "end_line": {"type": "integer"},
+                "new_content": {"type": "string"},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "start_line", "end_line", "new_content"],
+        },
+    },
+}
+
 
 def _execute_replace_lines(
     coder, file_path, start_line, end_line, new_content, change_id=None, dry_run=False
@@ -139,7 +159,7 @@ def _execute_replace_lines(
             change_id,
         )
 
-        coder.aider_edited_files.add(rel_path)
+        coder.files_edited_by_tools.add(rel_path)
         replaced_count = end_line - start_line + 1
         new_count = len(new_lines)
 

aider/tools/replace_text.py

@@ -7,6 +7,27 @@ from .tool_utils import (
     validate_file_for_edit,
 )
 
+replace_text_schema = {
+    "type": "function",
+    "function": {
+        "name": "ReplaceText",
+        "description": "Replace text in a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "find_text": {"type": "string"},
+                "replace_text": {"type": "string"},
+                "near_context": {"type": "string"},
+                "occurrence": {"type": "integer", "default": 1},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "find_text", "replace_text"],
+        },
+    },
+}
+
 
 def _execute_replace_text(
     coder,
@@ -111,6 +132,7 @@ def _execute_replace_text(
             change_id,
         )
 
+        coder.files_edited_by_tools.add(rel_path)
         # 8. Format and return result
         success_message = f"Replaced {occurrence_str} in {file_path}"
         return format_tool_result(

aider/tools/show_numbered_context.py

@@ -2,6 +2,24 @@ import os
 
 from .tool_utils import ToolError, handle_tool_error, resolve_paths
 
+show_numbered_context_schema = {
+    "type": "function",
+    "function": {
+        "name": "ShowNumberedContext",
+        "description": "Show numbered lines of context around a pattern or line number.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "pattern": {"type": "string"},
+                "line_number": {"type": "integer"},
+                "context_lines": {"type": "integer", "default": 3},
+            },
+            "required": ["file_path"],
+        },
+    },
+}
+
 
 def execute_show_numbered_context(
     coder, file_path, pattern=None, line_number=None, context_lines=3

aider/tools/undo_change.py

@@ -1,5 +1,20 @@
 import traceback
 
+undo_change_schema = {
+    "type": "function",
+    "function": {
+        "name": "UndoChange",
+        "description": "Undo a previously applied change.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "change_id": {"type": "string"},
+                "file_path": {"type": "string"},
+            },
+        },
+    },
+}
+
 
 def _execute_undo_change(coder, change_id=None, file_path=None):
     """

aider/tools/update_todo_list.py

@@ -0,0 +1,131 @@
+from .tool_utils import (
+    ToolError,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+)
+
+update_todo_list_schema = {
+    "type": "function",
+    "function": {
+        "name": "UpdateTodoList",
+        "description": "Update the todo list with new items or modify existing ones.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "content": {
+                    "type": "string",
+                    "description": "The new content for the todo list.",
+                },
+                "append": {
+                    "type": "boolean",
+                    "description": (
+                        "Whether to append to existing content instead of replacing it. Defaults to"
+                        " False."
+                    ),
+                },
+                "change_id": {
+                    "type": "string",
+                    "description": "Optional change ID for tracking.",
+                },
+                "dry_run": {
+                    "type": "boolean",
+                    "description": (
+                        "Whether to perform a dry run without actually updating the file. Defaults"
+                        " to False."
+                    ),
+                },
+            },
+            "required": ["content"],
+        },
+    },
+}
+
+
+def _execute_update_todo_list(coder, content, append=False, change_id=None, dry_run=False):
+    """
+    Update the todo list file (.aider.todo.txt) with new content.
+    Can either replace the entire content or append to it.
+    """
+    tool_name = "UpdateTodoList"
+    try:
+        # Define the todo file path
+        todo_file_path = ".aider.todo.txt"
+        abs_path = coder.abs_root_path(todo_file_path)
+
+        # Get existing content if appending
+        existing_content = ""
+        import os
+
+        if os.path.isfile(abs_path):
+            existing_content = coder.io.read_text(abs_path) or ""
+
+        # Prepare new content
+        if append:
+            if existing_content and not existing_content.endswith("\n"):
+                existing_content += "\n"
+            new_content = existing_content + content
+        else:
+            new_content = content
+
+        # Check if content exceeds 4096 characters and warn
+        if len(new_content) > 4096:
+            coder.io.tool_warning(
+                "⚠️ Todo list content exceeds 4096 characters. Consider summarizing the plan before"
+                " proceeding."
+            )
+
+        # Check if content actually changed
+        if existing_content == new_content:
+            coder.io.tool_warning("No changes made: new content is identical to existing")
+            return "Warning: No changes made (content identical to existing)"
+
+        # Generate diff for feedback
+        diff_snippet = generate_unified_diff_snippet(existing_content, new_content, todo_file_path)
+
+        # Handle dry run
+        if dry_run:
+            action = "append to" if append else "replace"
+            dry_run_message = f"Dry run: Would {action} todo list in {todo_file_path}."
+            return format_tool_result(
+                coder,
+                tool_name,
+                "",
+                dry_run=True,
+                dry_run_message=dry_run_message,
+                diff_snippet=diff_snippet,
+            )
+
+        # Apply change
+        metadata = {
+            "append": append,
+            "existing_length": len(existing_content),
+            "new_length": len(new_content),
+        }
+
+        # Write the file directly since it's a special file
+        coder.io.write_text(abs_path, new_content)
+
+        # Track the change
+        final_change_id = coder.change_tracker.track_change(
+            file_path=todo_file_path,
+            change_type="updatetodolist",
+            original_content=existing_content,
+            new_content=new_content,
+            metadata=metadata,
+            change_id=change_id,
+        )
+
+        coder.aider_edited_files.add(todo_file_path)
+
+        # Format and return result
+        action = "appended to" if append else "updated"
+        success_message = f"Successfully {action} todo list in {todo_file_path}"
+        return format_tool_result(
+            coder, tool_name, success_message, change_id=final_change_id, diff_snippet=diff_snippet
+        )
+
+    except ToolError as e:
+        return handle_tool_error(coder, tool_name, e, add_traceback=False)
+    except Exception as e:
+        return handle_tool_error(coder, tool_name, e)

aider/tools/view.py

@@ -1,3 +1,26 @@
+view_schema = {
+    "type": "function",
+    "function": {
+        "name": "View",
+        "description": (
+            "View a specific file and add it to context."
+            "Only use this when the file is not already in the context "
+            "and when editing the file is necessary to accomplish the goal."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The path to the file to view.",
+                },
+            },
+            "required": ["file_path"],
+        },
+    },
+}
+
+
 def execute_view(coder, file_path):
     """
     Explicitly add a file to context as read-only.