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

aider/tools/insert_block.py

@@ -0,0 +1,211 @@
+import re
+import traceback
+
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    find_pattern_indices,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    select_occurrence_index,
+    validate_file_for_edit,
+)
+
+
+def _execute_insert_block(
+    coder,
+    file_path,
+    content,
+    after_pattern=None,
+    before_pattern=None,
+    occurrence=1,
+    change_id=None,
+    dry_run=False,
+    position=None,
+    auto_indent=True,
+    use_regex=False,
+):
+    """
+    Insert a block of text after or before a specified pattern using utility functions.
+
+    Args:
+        coder: The coder instance
+        file_path: Path to the file to modify
+        content: The content to insert
+        after_pattern: Pattern to insert after (mutually exclusive with before_pattern and position)
+        before_pattern: Pattern to insert before (mutually exclusive with after_pattern and position)
+        occurrence: Which occurrence of the pattern to use (1-based, or -1 for last)
+        change_id: Optional ID for tracking changes
+        dry_run: If True, only simulate the change
+        position: Special position like "start_of_file" or "end_of_file"
+        auto_indent: If True, automatically adjust indentation of inserted content
+        use_regex: If True, treat patterns as regular expressions
+    """
+    tool_name = "InsertBlock"
+    try:
+        # 1. Validate parameters
+        if sum(x is not None for x in [after_pattern, before_pattern, position]) != 1:
+            raise ToolError(
+                "Must specify exactly one of: after_pattern, before_pattern, or position"
+            )
+
+        # 2. Validate file and get content
+        abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+        lines = original_content.splitlines()
+
+        # Handle empty files
+        if not lines:
+            lines = [""]
+
+        # 3. Determine insertion point
+        insertion_line_idx = 0
+        pattern_type = ""
+        pattern_desc = ""
+        occurrence_str = ""
+
+        if position:
+            # Handle special positions
+            if position == "start_of_file":
+                insertion_line_idx = 0
+                pattern_type = "at start of"
+            elif position == "end_of_file":
+                insertion_line_idx = len(lines)
+                pattern_type = "at end of"
+            else:
+                raise ToolError(
+                    f"Invalid position: '{position}'. Valid values are 'start_of_file' or"
+                    " 'end_of_file'"
+                )
+        else:
+            # Handle pattern-based insertion
+            pattern = after_pattern if after_pattern else before_pattern
+            pattern_type = "after" if after_pattern else "before"
+            pattern_desc = f"Pattern '{pattern}'"
+
+            # Find pattern matches
+            pattern_line_indices = find_pattern_indices(lines, pattern, use_regex=use_regex)
+
+            # Select the target occurrence
+            target_line_idx = select_occurrence_index(
+                pattern_line_indices, occurrence, pattern_desc
+            )
+
+            # Determine insertion point
+            insertion_line_idx = target_line_idx
+            if pattern_type == "after":
+                insertion_line_idx += 1  # Insert on the line *after* the matched line
+
+            # Format occurrence info for output
+            num_occurrences = len(pattern_line_indices)
+            occurrence_str = f"occurrence {occurrence} of " if num_occurrences > 1 else ""
+
+        # 4. Handle indentation if requested
+        content_lines = content.splitlines()
+
+        if auto_indent and content_lines:
+            # Determine base indentation level
+            base_indent = ""
+            if insertion_line_idx > 0 and lines:
+                # Use indentation from the line before insertion point
+                reference_line_idx = min(insertion_line_idx - 1, len(lines) - 1)
+                reference_line = lines[reference_line_idx]
+                base_indent = re.match(r"^(\s*)", reference_line).group(1)
+
+            # Apply indentation to content lines, preserving relative indentation
+            if content_lines:
+                # Find minimum indentation in content to preserve relative indentation
+                content_indents = [
+                    len(re.match(r"^(\s*)", line).group(1))
+                    for line in content_lines
+                    if line.strip()
+                ]
+                min_content_indent = min(content_indents) if content_indents else 0
+
+                # Apply base indentation while preserving relative indentation
+                indented_content_lines = []
+                for line in content_lines:
+                    if not line.strip():  # Empty or whitespace-only line
+                        indented_content_lines.append("")
+                    else:
+                        # Remove existing indentation and add new base indentation
+                        stripped_line = (
+                            line[min_content_indent:] if min_content_indent <= len(line) else line
+                        )
+                        indented_content_lines.append(base_indent + stripped_line)
+
+                content_lines = indented_content_lines
+
+        # 5. Prepare the insertion
+        new_lines = lines[:insertion_line_idx] + content_lines + lines[insertion_line_idx:]
+        new_content = "\n".join(new_lines)
+
+        if original_content == new_content:
+            coder.io.tool_warning("No changes made: insertion would not change file")
+            return "Warning: No changes made (insertion would not change file)"
+
+        # 6. Generate diff for feedback
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+
+        # 7. Handle dry run
+        if dry_run:
+            if position:
+                dry_run_message = f"Dry run: Would insert block {pattern_type} {file_path}."
+            else:
+                dry_run_message = (
+                    f"Dry run: Would insert block {pattern_type} {occurrence_str}pattern"
+                    f" '{pattern}' in {file_path} at line {insertion_line_idx + 1}."
+                )
+            return format_tool_result(
+                coder,
+                tool_name,
+                "",
+                dry_run=True,
+                dry_run_message=dry_run_message,
+                diff_snippet=diff_snippet,
+            )
+
+        # 8. Apply Change (Not dry run)
+        metadata = {
+            "insertion_line_idx": insertion_line_idx,
+            "after_pattern": after_pattern,
+            "before_pattern": before_pattern,
+            "position": position,
+            "occurrence": occurrence,
+            "content": content,
+            "auto_indent": auto_indent,
+            "use_regex": use_regex,
+        }
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "insertblock",
+            metadata,
+            change_id,
+        )
+
+        # 9. Format and return result
+        if position:
+            success_message = f"Inserted block {pattern_type} {file_path}"
+        else:
+            success_message = (
+                f"Inserted block {pattern_type} {occurrence_str}pattern in {file_path} at line"
+                f" {insertion_line_idx + 1}"
+            )
+
+        return format_tool_result(
+            coder, tool_name, success_message, change_id=final_change_id, diff_snippet=diff_snippet
+        )
+
+    except ToolError as e:
+        # Handle errors raised by utility functions (expected errors)
+        return handle_tool_error(coder, tool_name, e, add_traceback=False)
+
+    except Exception as e:
+        coder.io.tool_error(
+            f"Error in InsertBlock: {str(e)}\n{traceback.format_exc()}"
+        )  # Add traceback
+        return f"Error: {str(e)}"

aider/tools/list_changes.py

@@ -0,0 +1,51 @@
+import traceback
+from datetime import datetime
+
+
+def _execute_list_changes(coder, file_path=None, limit=10):
+    """
+    List recent changes made to files.
+
+    Parameters:
+    - coder: The Coder instance
+    - file_path: Optional path to filter changes by file
+    - limit: Maximum number of changes to list
+
+    Returns a formatted list of changes.
+    """
+    try:
+        # If file_path is specified, get the absolute path
+        rel_file_path = None
+        if file_path:
+            abs_path = coder.abs_root_path(file_path)
+            rel_file_path = coder.get_rel_fname(abs_path)
+
+        # Get the list of changes
+        changes = coder.change_tracker.list_changes(rel_file_path, limit)
+
+        if not changes:
+            if file_path:
+                return f"No changes found for file '{file_path}'"
+            else:
+                return "No changes have been made yet"
+
+        # Format the changes into a readable list
+        result = "Recent changes:\n"
+        for i, change in enumerate(changes):
+            change_time = datetime.fromtimestamp(change["timestamp"]).strftime("%H:%M:%S")
+            change_type = change["type"]
+            file_path = change["file_path"]
+            change_id = change["id"]
+
+            result += (
+                f"{i + 1}. [{change_id}] {change_time} - {change_type.upper()} on {file_path}\n"
+            )
+
+        coder.io.tool_output(result)  # Also print to console for user
+        return result
+
+    except Exception as e:
+        coder.io.tool_error(
+            f"Error in ListChanges: {str(e)}\n{traceback.format_exc()}"
+        )  # Add traceback
+        return f"Error: {str(e)}"

aider/tools/ls.py

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

@@ -0,0 +1,46 @@
+import os
+
+
+# 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
+
+        # Add to editable files
+        coder.abs_fnames.add(abs_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)}"

aider/tools/make_readonly.py

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

aider/tools/remove.py

@@ -0,0 +1,48 @@
+import time
+
+
+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()}
+
+        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)}"

aider/tools/replace_all.py

@@ -0,0 +1,77 @@
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    validate_file_for_edit,
+)
+
+
+def _execute_replace_all(coder, file_path, find_text, replace_text, change_id=None, dry_run=False):
+    """
+    Replace all occurrences of text in a file using utility functions.
+    """
+    # Get absolute file path
+    abs_path = coder.abs_root_path(file_path)
+    rel_path = coder.get_rel_fname(abs_path)
+    tool_name = "ReplaceAll"
+    try:
+        # 1. Validate file and get content
+        abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+
+        # 2. Count occurrences
+        count = original_content.count(find_text)
+        if count == 0:
+            coder.io.tool_warning(f"Text '{find_text}' not found in file '{file_path}'")
+            return "Warning: Text not found in file"
+
+        # 3. Perform the replacement
+        new_content = original_content.replace(find_text, replace_text)
+
+        if original_content == new_content:
+            coder.io.tool_warning("No changes made: replacement text is identical to original")
+            return "Warning: No changes made (replacement identical to original)"
+
+        # 4. Generate diff for feedback
+        diff_examples = generate_unified_diff_snippet(original_content, new_content, rel_path)
+
+        # 5. Handle dry run
+        if dry_run:
+            dry_run_message = (
+                f"Dry run: Would replace {count} occurrences of '{find_text}' in {file_path}."
+            )
+            return format_tool_result(
+                coder,
+                tool_name,
+                "",
+                dry_run=True,
+                dry_run_message=dry_run_message,
+                diff_snippet=diff_examples,
+            )
+
+        # 6. Apply Change (Not dry run)
+        metadata = {"find_text": find_text, "replace_text": replace_text, "occurrences": count}
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "replaceall",
+            metadata,
+            change_id,
+        )
+
+        # 7. Format and return result
+        success_message = f"Replaced {count} occurrences in {file_path}"
+        return format_tool_result(
+            coder, tool_name, success_message, change_id=final_change_id, diff_snippet=diff_examples
+        )
+
+    except ToolError as e:
+        # Handle errors raised by utility functions
+        return handle_tool_error(coder, tool_name, e, add_traceback=False)
+    except Exception as e:
+        # Handle unexpected errors
+        return handle_tool_error(coder, tool_name, e)

aider/tools/replace_line.py

@@ -0,0 +1,125 @@
+import os
+import traceback
+
+
+def _execute_replace_line(
+    coder, file_path, line_number, new_content, change_id=None, dry_run=False
+):
+    """
+    Replace a specific line identified by line number.
+    Useful for fixing errors identified by error messages or linters.
+
+    Parameters:
+    - coder: The Coder instance
+    - file_path: Path to the file to modify
+    - line_number: The line number to replace (1-based)
+    - new_content: New content for the line
+    - change_id: Optional ID for tracking the change
+    - dry_run: If True, simulate the change without modifying the file
+
+    Returns a result message.
+    """
+    try:
+        # Get absolute file path
+        abs_path = coder.abs_root_path(file_path)
+        rel_path = coder.get_rel_fname(abs_path)
+
+        # Check if file exists
+        if not os.path.isfile(abs_path):
+            coder.io.tool_error(f"File '{file_path}' not found")
+            return "Error: File not found"
+
+        # 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_error(f"File '{file_path}' is read-only. Use MakeEditable first.")
+                return "Error: File is read-only. Use MakeEditable first."
+            else:
+                coder.io.tool_error(f"File '{file_path}' not in context")
+                return "Error: File not in context"
+
+        # Reread file content immediately before modification
+        file_content = coder.io.read_text(abs_path)
+        if file_content is None:
+            coder.io.tool_error(f"Could not read file '{file_path}' before ReplaceLine operation.")
+            return f"Error: Could not read file '{file_path}'"
+
+        # Split into lines
+        lines = file_content.splitlines()
+
+        # Validate line number
+        if not isinstance(line_number, int):
+            try:
+                line_number = int(line_number)
+            except ValueError:
+                coder.io.tool_error(f"Line number must be an integer, got '{line_number}'")
+                coder.io.tool_error(
+                    f"Invalid line_number value: '{line_number}'. Must be an integer."
+                )
+                return f"Error: Invalid line_number value '{line_number}'"
+
+        # Convert 1-based line number to 0-based index
+        idx = line_number - 1
+
+        if idx < 0 or idx >= len(lines):
+            coder.io.tool_error(
+                f"Line number {line_number} is out of range for file '{file_path}' (has"
+                f" {len(lines)} lines)."
+            )
+            return f"Error: Line number {line_number} out of range"
+
+        # Store original content for change tracking
+        original_content = file_content
+        original_line = lines[idx]
+
+        # Replace the line
+        lines[idx] = new_content
+
+        # Join lines back into a string
+        new_content_full = "\n".join(lines)
+
+        if original_content == new_content_full:
+            coder.io.tool_warning("No changes made: new line content is identical to original")
+            return "Warning: No changes made (new content identical to original)"
+
+        # Create a readable diff for the line replacement
+        diff = f"Line {line_number}:\n- {original_line}\n+ {new_content}"
+
+        # Handle dry run
+        if dry_run:
+            coder.io.tool_output(f"Dry run: Would replace line {line_number} in {file_path}")
+            return f"Dry run: Would replace line {line_number}. Diff:\n{diff}"
+
+        # --- Apply Change (Not dry run) ---
+        coder.io.write_text(abs_path, new_content_full)
+
+        # Track the change
+        try:
+            metadata = {
+                "line_number": line_number,
+                "original_line": original_line,
+                "new_line": new_content,
+            }
+            change_id = coder.change_tracker.track_change(
+                file_path=rel_path,
+                change_type="replaceline",
+                original_content=original_content,
+                new_content=new_content_full,
+                metadata=metadata,
+                change_id=change_id,
+            )
+        except Exception as track_e:
+            coder.io.tool_error(f"Error tracking change for ReplaceLine: {track_e}")
+            change_id = "TRACKING_FAILED"
+
+        coder.aider_edited_files.add(rel_path)
+
+        # Improve feedback
+        coder.io.tool_output(
+            f"✅ Replaced line {line_number} in {file_path} (change_id: {change_id})"
+        )
+        return f"Successfully replaced line {line_number} (change_id: {change_id}). Diff:\n{diff}"
+
+    except Exception as e:
+        coder.io.tool_error(f"Error in ReplaceLine: {str(e)}\n{traceback.format_exc()}")
+        return f"Error: {str(e)}"