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

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.

aider/tools/view_files_at_glob.py

@@ -1,10 +1,28 @@
 import fnmatch
 import os
 
+view_files_at_glob_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewFilesAtGlob",
+        "description": "View files matching a glob pattern.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "The glob pattern to match files.",
+                },
+            },
+            "required": ["pattern"],
+        },
+    },
+}
+
 
 def execute_view_files_at_glob(coder, pattern):
     """
-    Execute a glob pattern and add matching files to context as read-only.
+    Execute a glob pattern and return matching files as text.
 
     This tool helps the LLM find files by pattern matching, similar to
     how a developer would use glob patterns to find files.
@@ -25,38 +43,25 @@ def execute_view_files_at_glob(coder, pattern):
             if fnmatch.fnmatch(file, pattern):
                 matching_files.append(file)
 
-        # Limit the number of files added if there are too many matches
-        if len(matching_files) > coder.max_files_per_glob:
-            coder.io.tool_output(
-                f"⚠️ Found {len(matching_files)} files matching '{pattern}', "
-                f"limiting to {coder.max_files_per_glob} most relevant files."
-            )
-            # Sort by modification time (most recent first)
-            matching_files.sort(
-                key=lambda f: os.path.getmtime(coder.abs_root_path(f)), reverse=True
-            )
-            matching_files = matching_files[: coder.max_files_per_glob]
-
-        # Add files to context
-        for file in matching_files:
-            # Use the coder's internal method to add files
-            coder._add_file_to_context(file)
-
-        # Return a user-friendly result
+        # Return formatted text instead of adding to context
         if matching_files:
             if len(matching_files) > 10:
-                brief = ", ".join(matching_files[:5]) + f", and {len(matching_files) - 5} more"
-                coder.io.tool_output(
-                    f"📂 Added {len(matching_files)} files matching '{pattern}': {brief}"
+                result = (
+                    f"Found {len(matching_files)} files matching '{pattern}':"
+                    f" {', '.join(matching_files[:10])} and {len(matching_files) - 10} more"
                 )
+                coder.io.tool_output(f"📂 Found {len(matching_files)} files matching '{pattern}'")
             else:
+                result = (
+                    f"Found {len(matching_files)} files matching '{pattern}':"
+                    f" {', '.join(matching_files)}"
+                )
                 coder.io.tool_output(
-                    f"📂 Added files matching '{pattern}': {', '.join(matching_files)}"
+                    f"📂 Found files matching '{pattern}':"
+                    f" {', '.join(matching_files[:5])}{' and more' if len(matching_files) > 5 else ''}"
                 )
-            return (
-                f"Added {len(matching_files)} files:"
-                f" {', '.join(matching_files[:5])}{' and more' if len(matching_files) > 5 else ''}"
-            )
+
+            return result
         else:
             coder.io.tool_output(f"⚠️ No files found matching '{pattern}'")
             return f"No files found matching '{pattern}'"

aider/tools/view_files_matching.py

@@ -1,18 +1,46 @@
 import fnmatch
 import re
 
+view_files_matching_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewFilesMatching",
+        "description": "View files containing a specific pattern.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "The pattern to search for in file contents.",
+                },
+                "file_pattern": {
+                    "type": "string",
+                    "description": "An optional glob pattern to filter which files are searched.",
+                },
+                "regex": {
+                    "type": "boolean",
+                    "description": (
+                        "Whether the pattern is a regular expression. Defaults to False."
+                    ),
+                },
+            },
+            "required": ["pattern"],
+        },
+    },
+}
 
-def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=False):
+
+def execute_view_files_matching(coder, pattern, file_pattern=None, regex=False):
     """
-    Search for pattern (literal string or regex) in files and add matching files to context as read-only.
+    Search for pattern (literal string or regex) in files and return matching files as text.
 
     Args:
         coder: The Coder instance.
-        search_pattern (str): The pattern to search for.
+        pattern (str): The pattern to search for.
             Treated as a literal string by default.
         file_pattern (str, optional): Glob pattern to filter which files are searched.
             Defaults to None (search all files).
-        regex (bool, optional): If True, treat search_pattern as a regular expression.
+        regex (bool, optional): If True, treat pattern as a regular expression.
             Defaults to False.
 
     This tool lets the LLM search for content within files, mimicking
@@ -29,9 +57,7 @@ def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=
                     files_to_search.append(file)
 
             if not files_to_search:
-                return (
-                    f"No files matching '{file_pattern}' to search for pattern '{search_pattern}'"
-                )
+                return f"No files matching '{file_pattern}' to search for pattern '{pattern}'"
         else:
             # Search all files if no pattern provided
             files_to_search = coder.get_all_relative_files()
@@ -46,16 +72,16 @@ def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=
                     match_count = 0
                     if regex:
                         try:
-                            matches_found = re.findall(search_pattern, content)
+                            matches_found = re.findall(pattern, content)
                             match_count = len(matches_found)
                         except re.error as e:
                             # Handle invalid regex patterns gracefully
-                            coder.io.tool_error(f"Invalid regex pattern '{search_pattern}': {e}")
+                            coder.io.tool_error(f"Invalid regex pattern '{pattern}': {e}")
                             # Skip this file for this search if regex is invalid
                             continue
                     else:
                         # Exact string matching
-                        match_count = content.count(search_pattern)
+                        match_count = content.count(pattern)
 
                     if match_count > 0:
                         matches[file] = match_count
@@ -63,40 +89,28 @@ def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=
                 # Skip files that can't be read (binary, etc.)
                 pass
 
-        # Limit the number of files added if there are too many matches
-        if len(matches) > coder.max_files_per_glob:
-            coder.io.tool_output(
-                f"⚠️ Found '{search_pattern}' in {len(matches)} files, "
-                f"limiting to {coder.max_files_per_glob} files with most matches."
-            )
-            # Sort by number of matches (most matches first)
-            sorted_matches = sorted(matches.items(), key=lambda x: x[1], reverse=True)
-            matches = dict(sorted_matches[: coder.max_files_per_glob])
-
-        # Add matching files to context
-        for file in matches:
-            coder._add_file_to_context(file)
-
-        # Return a user-friendly result
+        # Return formatted text instead of adding to context
         if matches:
             # Sort by number of matches (most matches first)
             sorted_matches = sorted(matches.items(), key=lambda x: x[1], reverse=True)
-            match_list = [f"{file} ({count} matches)" for file, count in sorted_matches[:5]]
+            match_list = [f"{file} ({count} matches)" for file, count in sorted_matches]
 
-            if len(sorted_matches) > 5:
-                coder.io.tool_output(
-                    f"🔍 Found '{search_pattern}' in {len(matches)} files:"
-                    f" {', '.join(match_list)} and {len(matches) - 5} more"
-                )
-                return (
-                    f"Found in {len(matches)} files: {', '.join(match_list)} and"
-                    f" {len(matches) - 5} more"
+            if len(matches) > 10:
+                result = (
+                    f"Found '{pattern}' in {len(matches)} files: {', '.join(match_list[:10])} and"
+                    f" {len(matches) - 10} more"
                 )
+                coder.io.tool_output(f"🔍 Found '{pattern}' in {len(matches)} files")
             else:
-                coder.io.tool_output(f"🔍 Found '{search_pattern}' in: {', '.join(match_list)}")
-                return f"Found in {len(matches)} files: {', '.join(match_list)}"
+                result = f"Found '{pattern}' in {len(matches)} files: {', '.join(match_list)}"
+                coder.io.tool_output(
+                    f"🔍 Found '{pattern}' in:"
+                    f" {', '.join(match_list[:5])}{' and more' if len(matches) > 5 else ''}"
+                )
+
+            return result
         else:
-            coder.io.tool_output(f"⚠️ Pattern '{search_pattern}' not found in any files")
+            coder.io.tool_output(f"⚠️ Pattern '{pattern}' not found in any files")
             return "Pattern not found in any files"
     except Exception as e:
         coder.io.tool_error(f"Error in ViewFilesMatching: {str(e)}")

aider/tools/view_files_with_symbol.py

@@ -1,9 +1,25 @@
-import os
+view_files_with_symbol_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewFilesWithSymbol",
+        "description": "View files that contain a specific symbol (e.g., class, function).",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "symbol": {
+                    "type": "string",
+                    "description": "The symbol to search for.",
+                },
+            },
+            "required": ["symbol"],
+        },
+    },
+}
 
 
 def _execute_view_files_with_symbol(coder, symbol):
     """
-    Find files containing a symbol using RepoMap and add them to context.
+    Find files containing a symbol using RepoMap and return them as text.
     Checks files already in context first.
     """
     if not coder.repo_map:
@@ -13,7 +29,6 @@ def _execute_view_files_with_symbol(coder, symbol):
     if not symbol:
         return "Error: Missing 'symbol' parameter for ViewFilesWithSymbol"
 
-    # --- Start Modification ---
     # 1. Check files already in context
     files_in_context = list(coder.abs_fnames) + list(coder.abs_read_only_fnames)
     found_in_context = []
@@ -34,20 +49,11 @@ def _execute_view_files_with_symbol(coder, symbol):
     if found_in_context:
         # Symbol found in already loaded files. Report this and stop.
         file_list = ", ".join(sorted(list(set(found_in_context))))
-        coder.io.tool_output(
-            f"Symbol '{symbol}' found in already loaded file(s): {file_list}. No external search"
-            " performed."
-        )
-        return (
-            f"Symbol '{symbol}' found in already loaded file(s): {file_list}. No external search"
-            " performed."
-        )
-    # --- End Modification ---
+        coder.io.tool_output(f"Symbol '{symbol}' found in already loaded file(s): {file_list}")
+        return f"Symbol '{symbol}' found in already loaded file(s): {file_list}"
 
     # 2. If not found in context, search the repository using RepoMap
-    coder.io.tool_output(
-        f"🔎 Searching for symbol '{symbol}' in repository (excluding current context)..."
-    )
+    coder.io.tool_output(f"🔎 Searching for symbol '{symbol}' in repository...")
     try:
         found_files = set()
         current_context_files = coder.abs_fnames | coder.abs_read_only_fnames
@@ -71,50 +77,31 @@ def _execute_view_files_with_symbol(coder, symbol):
                 # Use absolute path directly if available, otherwise resolve from relative path
                 abs_fname = rel_fname_to_abs.get(tag.rel_fname) or coder.abs_root_path(tag.fname)
                 if abs_fname in files_to_search:  # Ensure we only add files we intended to search
-                    found_files.add(abs_fname)
+                    found_files.add(coder.get_rel_fname(abs_fname))
 
-        # Limit the number of files added
-        if len(found_files) > coder.max_files_per_glob:
-            coder.io.tool_output(
-                f"⚠️ Found symbol '{symbol}' in {len(found_files)} files, "
-                f"limiting to {coder.max_files_per_glob} most relevant files."
-            )
-            # Sort by modification time (most recent first) - approximate relevance
-            sorted_found_files = sorted(
-                list(found_files), key=lambda f: os.path.getmtime(f), reverse=True
-            )
-            found_files = set(sorted_found_files[: coder.max_files_per_glob])
-
-        # Add files to context (as read-only)
-        added_count = 0
-        added_files_rel = []
-        for abs_file_path in found_files:
-            rel_path = coder.get_rel_fname(abs_file_path)
-            # Double check it's not already added somehow
-            if (
-                abs_file_path not in coder.abs_fnames
-                and abs_file_path not in coder.abs_read_only_fnames
-            ):
-                # Use explicit=True for clear output, even though it's an external search result
-                add_result = coder._add_file_to_context(rel_path, explicit=True)
-                if "Added" in add_result or "Viewed" in add_result:  # Count successful adds/views
-                    added_count += 1
-                    added_files_rel.append(rel_path)
-
-        if added_count > 0:
-            if added_count > 5:
-                brief = ", ".join(added_files_rel[:5]) + f", and {added_count - 5} more"
-                coder.io.tool_output(f"🔎 Found '{symbol}' and added {added_count} files: {brief}")
+        # Return formatted text instead of adding to context
+        if found_files:
+            found_files_list = sorted(list(found_files))
+            if len(found_files) > 10:
+                result = (
+                    f"Found symbol '{symbol}' in {len(found_files)} files:"
+                    f" {', '.join(found_files_list[:10])} and {len(found_files) - 10} more"
+                )
+                coder.io.tool_output(f"🔎 Found '{symbol}' in {len(found_files)} files")
             else:
+                result = (
+                    f"Found symbol '{symbol}' in {len(found_files)} files:"
+                    f" {', '.join(found_files_list)}"
+                )
                 coder.io.tool_output(
-                    f"🔎 Found '{symbol}' and added files: {', '.join(added_files_rel)}"
+                    f"🔎 Found '{symbol}' in files:"
+                    f" {', '.join(found_files_list[:5])}{' and more' if len(found_files) > 5 else ''}"
                 )
-            return f"Found symbol '{symbol}' and added {added_count} files as read-only."
+
+            return result
         else:
-            coder.io.tool_output(
-                f"⚠️ Symbol '{symbol}' not found in searchable files (outside current context)."
-            )
-            return f"Symbol '{symbol}' not found in searchable files (outside current context)."
+            coder.io.tool_output(f"⚠️ Symbol '{symbol}' not found in searchable files")
+            return f"Symbol '{symbol}' not found in searchable files"
 
     except Exception as e:
         coder.io.tool_error(f"Error in ViewFilesWithSymbol: {str(e)}")

aider/tools/view_todo_list.py

@@ -0,0 +1,57 @@
+from .tool_utils import ToolError, format_tool_result, handle_tool_error
+
+view_todo_list_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewTodoList",
+        "description": "View the current todo list for tracking conversation steps and progress.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        },
+    },
+}
+
+
+def _execute_view_todo_list(coder):
+    """
+    View the current todo list from .aider.todo.txt file.
+    Returns the todo list content or creates an empty one if it doesn't exist.
+    """
+    tool_name = "ViewTodoList"
+    try:
+        # Define the todo file path
+        todo_file_path = ".aider.todo.txt"
+        abs_path = coder.abs_root_path(todo_file_path)
+
+        # Check if file exists
+        import os
+
+        if os.path.isfile(abs_path):
+            # Read existing todo list
+            content = coder.io.read_text(abs_path)
+            if content is None:
+                raise ToolError(f"Could not read todo list file: {todo_file_path}")
+
+            # Check if content exceeds 4096 characters and warn
+            if len(content) > 4096:
+                coder.io.tool_warning(
+                    "⚠️ Todo list content exceeds 4096 characters. Consider summarizing the plan"
+                    " before proceeding."
+                )
+
+            if content.strip():
+                result_message = f"Current todo list:\n```\n{content}\n```"
+            else:
+                result_message = "Todo list is empty. Use UpdateTodoList to add items."
+        else:
+            # Create empty todo list
+            result_message = "Todo list is empty. Use UpdateTodoList to add items."
+
+        return format_tool_result(coder, tool_name, result_message)
+
+    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)