aider-ce 0.87.2.dev9__py3-none-any.whl

aider/tools/undo_change.py

@@ -0,0 +1,60 @@
+import traceback
+
+
+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)}"

aider/tools/view.py

@@ -0,0 +1,13 @@
+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)}"

aider/tools/view_files_at_glob.py

@@ -0,0 +1,65 @@
+import fnmatch
+import os
+
+
+def execute_view_files_at_glob(coder, pattern):
+    """
+    Execute a glob pattern and add matching files to context as read-only.
+
+    This tool helps the LLM find files by pattern matching, similar to
+    how a developer would use glob patterns to find files.
+    """
+    try:
+        # Find files matching the pattern
+        matching_files = []
+
+        # Make the pattern relative to root if it's absolute
+        if pattern.startswith("/"):
+            pattern = os.path.relpath(pattern, coder.root)
+
+        # Get all files in the repo
+        all_files = coder.get_all_relative_files()
+
+        # Find matches with pattern matching
+        for file in all_files:
+            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
+        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}"
+                )
+            else:
+                coder.io.tool_output(
+                    f"📂 Added files matching '{pattern}': {', '.join(matching_files)}"
+                )
+            return (
+                f"Added {len(matching_files)} files:"
+                f" {', '.join(matching_files[:5])}{' and more' if len(matching_files) > 5 else ''}"
+            )
+        else:
+            coder.io.tool_output(f"⚠️ No files found matching '{pattern}'")
+            return f"No files found matching '{pattern}'"
+    except Exception as e:
+        coder.io.tool_error(f"Error in ViewFilesAtGlob: {str(e)}")
+        return f"Error: {str(e)}"

aider/tools/view_files_matching.py

@@ -0,0 +1,103 @@
+import fnmatch
+import re
+
+
+def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=False):
+    """
+    Search for pattern (literal string or regex) in files and add matching files to context as read-only.
+
+    Args:
+        coder: The Coder instance.
+        search_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.
+            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 '{search_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(search_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}")
+                            # Skip this file for this search if regex is invalid
+                            continue
+                    else:
+                        # Exact string matching
+                        match_count = content.count(search_pattern)
+
+                    if match_count > 0:
+                        matches[file] = match_count
+            except Exception:
+                # 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
+        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]]
+
+            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"
+                )
+            else:
+                coder.io.tool_output(f"🔍 Found '{search_pattern}' in: {', '.join(match_list)}")
+                return f"Found in {len(matches)} files: {', '.join(match_list)}"
+        else:
+            coder.io.tool_output(f"⚠️ Pattern '{search_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)}"

aider/tools/view_files_with_symbol.py

@@ -0,0 +1,121 @@
+import os
+
+
+def _execute_view_files_with_symbol(coder, symbol):
+    """
+    Find files containing a symbol using RepoMap and add them to context.
+    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"
+
+    # --- Start Modification ---
+    # 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}. No external search"
+            " performed."
+        )
+        return (
+            f"Symbol '{symbol}' found in already loaded file(s): {file_list}. No external search"
+            " performed."
+        )
+    # --- End Modification ---
+
+    # 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)..."
+    )
+    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(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}")
+            else:
+                coder.io.tool_output(
+                    f"🔎 Found '{symbol}' and added files: {', '.join(added_files_rel)}"
+                )
+            return f"Found symbol '{symbol}' and added {added_count} files as read-only."
+        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)."
+
+    except Exception as e:
+        coder.io.tool_error(f"Error in ViewFilesWithSymbol: {str(e)}")
+        return f"Error: {str(e)}"

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/Aider-AI/aider/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"