aider-ce 0.88.20__py3-none-any.whl

aider/tools/undo_change.py

@@ -0,0 +1,95 @@
+import traceback
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "UndoChange",
+        "description": "Undo a previously applied change.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "change_id": {"type": "string"},
+                "file_path": {"type": "string"},
+            },
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "undochange"
+
+
+def _execute_undo_change(coder, change_id=None, file_path=None):
+    """
+    Undo a specific change by ID, or the last change to a file.
+
+    Parameters:
+    - coder: The Coder instance
+    - change_id: ID of the change to undo
+    - file_path: Path to file where the last change should be undone
+
+    Returns a result message.
+    """
+    # Note: Undo does not have a dry_run parameter as it's inherently about reverting a previous action.
+    try:
+        # Validate parameters
+        if change_id is None and file_path is None:
+            coder.io.tool_error("Must specify either change_id or file_path for UndoChange")
+            return "Error: Must specify either change_id or file_path"
+
+        # If file_path is specified, get the most recent change for that file
+        if file_path:
+            abs_path = coder.abs_root_path(file_path)
+            rel_path = coder.get_rel_fname(abs_path)
+
+            change_id = coder.change_tracker.get_last_change(rel_path)
+            if not change_id:
+                coder.io.tool_error(f"No tracked changes found for file '{file_path}' to undo.")
+                return f"Error: No changes found for file '{file_path}'"
+
+        # Attempt to get undo information from the tracker
+        success, message, change_info = coder.change_tracker.undo_change(change_id)
+
+        if not success:
+            coder.io.tool_error(f"Failed to undo change '{change_id}': {message}")
+            return f"Error: {message}"
+
+        # Apply the undo by restoring the original content
+        if change_info:
+            file_path = change_info["file_path"]
+            abs_path = coder.abs_root_path(file_path)
+            # Write the original content back to the file
+            coder.io.write_text(abs_path, change_info["original"])
+            coder.aider_edited_files.add(file_path)  # Track that the file was modified by the undo
+
+            change_type = change_info["type"]
+            coder.io.tool_output(f"✅ Undid {change_type} change '{change_id}' in {file_path}")
+            return f"Successfully undid {change_type} change '{change_id}'."
+        else:
+            # This case should ideally not be reached if tracker returns success
+            coder.io.tool_error(
+                f"Failed to undo change '{change_id}': Change info missing after successful tracker"
+                " update."
+            )
+            return f"Error: Failed to undo change '{change_id}' (missing change info)"
+
+    except Exception as e:
+        coder.io.tool_error(f"Error in UndoChange: {str(e)}\n{traceback.format_exc()}")
+        return f"Error: {str(e)}"
+
+
+def process_response(coder, params):
+    """
+    Process the UndoChange tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    change_id = params.get("change_id")
+    file_path = params.get("file_path")
+
+    return _execute_undo_change(coder, change_id, file_path)

aider/tools/update_todo_list.py

@@ -0,0 +1,156 @@
+from .tool_utils import (
+    ToolError,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+)
+
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "updatetodolist"
+
+
+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)
+
+
+def process_response(coder, params):
+    """
+    Process the UpdateTodoList tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    content = params.get("content")
+    append = params.get("append", False)
+    change_id = params.get("change_id")
+    dry_run = params.get("dry_run", False)
+
+    if content is not None:
+        return _execute_update_todo_list(coder, content, append, change_id, dry_run)
+    else:
+        return "Error: Missing required 'content' parameter for UpdateTodoList"

aider/tools/view.py

@@ -0,0 +1,57 @@
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "view"
+
+
+def execute_view(coder, file_path):
+    """
+    Explicitly add a file to context as read-only.
+
+    This gives the LLM explicit control over what files to view,
+    rather than relying on indirect mentions.
+    """
+    try:
+        # Use the coder's helper, marking it as an explicit view request
+        return coder._add_file_to_context(file_path, explicit=True)
+    except Exception as e:
+        coder.io.tool_error(f"Error viewing file: {str(e)}")
+        return f"Error: {str(e)}"
+
+
+def process_response(coder, params):
+    """
+    Process the View 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_view(coder, file_path)
+    else:
+        return "Error: Missing 'file_path' parameter for View"

aider/tools/view_files_matching.py

@@ -0,0 +1,141 @@
+import fnmatch
+import re
+
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "viewfilesmatching"
+
+
+def execute_view_files_matching(coder, pattern, file_pattern=None, regex=False):
+    """
+    Search for pattern (literal string or regex) in files and return matching files as text.
+
+    Args:
+        coder: The Coder instance.
+        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 pattern as a regular expression.
+            Defaults to False.
+
+    This tool lets the LLM search for content within files, mimicking
+    how a developer would use grep or regex search to find relevant code.
+    """
+    try:
+        # Get list of files to search
+        if file_pattern:
+            # Use glob pattern to filter files
+            all_files = coder.get_all_relative_files()
+            files_to_search = []
+            for file in all_files:
+                if fnmatch.fnmatch(file, file_pattern):
+                    files_to_search.append(file)
+
+            if not files_to_search:
+                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()
+
+        # Search for pattern in files
+        matches = {}
+        for file in files_to_search:
+            abs_path = coder.abs_root_path(file)
+            try:
+                with open(abs_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                    match_count = 0
+                    if regex:
+                        try:
+                            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 '{pattern}': {e}")
+                            # Skip this file for this search if regex is invalid
+                            continue
+                    else:
+                        # Exact string matching
+                        match_count = content.count(pattern)
+
+                    if match_count > 0:
+                        matches[file] = match_count
+            except Exception:
+                # Skip files that can't be read (binary, etc.)
+                pass
+
+        # 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]
+
+            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:
+                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 '{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)}")
+        return f"Error: {str(e)}"
+
+
+def process_response(coder, params):
+    """
+    Process the ViewFilesMatching tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    pattern = params.get("pattern")
+    file_pattern = params.get("file_pattern")
+    regex = params.get("regex", False)
+
+    if pattern is not None:
+        return execute_view_files_matching(coder, pattern, file_pattern, regex)
+    else:
+        return "Error: Missing 'pattern' parameter for ViewFilesMatching"

aider/tools/view_files_with_symbol.py

@@ -0,0 +1,129 @@
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "viewfileswithsymbol"
+
+
+def _execute_view_files_with_symbol(coder, symbol):
+    """
+    Find files containing a symbol using RepoMap and return them as text.
+    Checks files already in context first.
+    """
+    if not coder.repo_map:
+        coder.io.tool_output("⚠️ Repo map not available, cannot use ViewFilesWithSymbol tool.")
+        return "Repo map not available"
+
+    if not symbol:
+        return "Error: Missing 'symbol' parameter for ViewFilesWithSymbol"
+
+    # 1. Check files already in context
+    files_in_context = list(coder.abs_fnames) + list(coder.abs_read_only_fnames)
+    found_in_context = []
+    for abs_fname in files_in_context:
+        rel_fname = coder.get_rel_fname(abs_fname)
+        try:
+            # Use get_tags for consistency with RepoMap usage elsewhere for now.
+            tags = coder.repo_map.get_tags(abs_fname, rel_fname)
+            for tag in tags:
+                if tag.name == symbol:
+                    found_in_context.append(rel_fname)
+                    break  # Found in this file, move to next
+        except Exception as e:
+            coder.io.tool_warning(
+                f"Could not get symbols for {rel_fname} while checking context: {e}"
+            )
+
+    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}")
+        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...")
+    try:
+        found_files = set()
+        current_context_files = coder.abs_fnames | coder.abs_read_only_fnames
+        files_to_search = set(coder.get_all_abs_files()) - current_context_files
+
+        rel_fname_to_abs = {}
+        all_tags = []
+
+        for fname in files_to_search:
+            rel_fname = coder.get_rel_fname(fname)
+            rel_fname_to_abs[rel_fname] = fname
+            try:
+                tags = coder.repo_map.get_tags(fname, rel_fname)
+                all_tags.extend(tags)
+            except Exception as e:
+                coder.io.tool_warning(f"Could not get tags for {rel_fname}: {e}")
+
+        # Find matching symbols
+        for tag in all_tags:
+            if tag.name == 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(coder.get_rel_fname(abs_fname))
+
+        # 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}' in files:"
+                    f" {', '.join(found_files_list[:5])}{' and more' if len(found_files) > 5 else ''}"
+                )
+
+            return result
+        else:
+            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)}")
+        return f"Error: {str(e)}"
+
+
+def process_response(coder, params):
+    """
+    Process the ViewFilesWithSymbol tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    symbol = params.get("symbol")
+    if symbol is not None:
+        return _execute_view_files_with_symbol(coder, symbol)
+    else:
+        return "Error: Missing 'symbol' parameter for ViewFilesWithSymbol"

aider/urls.py

@@ -0,0 +1,17 @@
+website = "https://aider.chat/"
+add_all_files = "https://aider.chat/docs/faq.html#how-can-i-add-all-the-files-to-the-chat"
+edit_errors = "https://aider.chat/docs/troubleshooting/edit-errors.html"
+git = "https://aider.chat/docs/git.html"
+enable_playwright = "https://aider.chat/docs/install/optional.html#enable-playwright"
+favicon = "https://aider.chat/assets/icons/favicon-32x32.png"
+model_warnings = "https://aider.chat/docs/llms/warnings.html"
+token_limits = "https://aider.chat/docs/troubleshooting/token-limits.html"
+llms = "https://aider.chat/docs/llms.html"
+large_repos = "https://aider.chat/docs/faq.html#can-i-use-aider-in-a-large-mono-repo"
+github_issues = "https://github.com/dwash96/aider-ce/issues/new"
+git_index_version = "https://github.com/Aider-AI/aider/issues/211"
+install_properly = "https://aider.chat/docs/troubleshooting/imports.html"
+analytics = "https://aider.chat/docs/more/analytics.html"
+release_notes = "https://aider.chat/HISTORY.html#release-notes"
+edit_formats = "https://aider.chat/docs/more/edit-formats.html"
+models_and_keys = "https://aider.chat/docs/troubleshooting/models-and-keys.html"