aider-ce 0.88.20__py3-none-any.whl

aider/tools/remove.py

@@ -0,0 +1,91 @@
+import time
+
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "remove"
+
+
+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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the Remove 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_remove(coder, file_path)
+    else:
+        return "Error: Missing 'file_path' parameter for Remove"

aider/tools/replace_all.py

@@ -0,0 +1,126 @@
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    validate_file_for_edit,
+)
+
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "replaceall"
+
+
+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,
+        )
+
+        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(
+            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)
+
+
+def process_response(coder, params):
+    """
+    Process the ReplaceAll tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    file_path = params.get("file_path")
+    find_text = params.get("find_text")
+    replace_text = params.get("replace_text")
+    change_id = params.get("change_id")
+    dry_run = params.get("dry_run", False)
+
+    if file_path is not None and find_text is not None and replace_text is not None:
+        return _execute_replace_all(coder, file_path, find_text, replace_text, change_id, dry_run)
+    else:
+        return (
+            "Error: Missing required parameters for ReplaceAll (file_path, find_text, replace_text)"
+        )

aider/tools/replace_line.py

@@ -0,0 +1,173 @@
+import os
+import traceback
+
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "replaceline"
+
+
+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.files_edited_by_tools.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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the ReplaceLine tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    file_path = params.get("file_path")
+    line_number = params.get("line_number")
+    new_content = params.get("new_content")
+    change_id = params.get("change_id")
+    dry_run = params.get("dry_run", False)
+
+    if file_path is not None and line_number is not None and new_content is not None:
+        return _execute_replace_line(coder, file_path, line_number, new_content, change_id, dry_run)
+    else:
+        return (
+            "Error: Missing required parameters for ReplaceLine (file_path,"
+            " line_number, new_content)"
+        )

aider/tools/replace_lines.py

@@ -0,0 +1,217 @@
+import os
+
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+)
+
+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"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "replacelines"
+
+
+def _execute_replace_lines(
+    coder, file_path, start_line, end_line, new_content, change_id=None, dry_run=False
+):
+    """
+    Replace a range of lines identified by line numbers.
+    Useful for fixing errors identified by error messages or linters.
+
+    Parameters:
+    - file_path: Path to the file to modify
+    - start_line: The first line number to replace (1-based)
+    - end_line: The last line number to replace (1-based)
+    - new_content: New content for the lines (can be multi-line)
+    - change_id: Optional ID for tracking the change
+    - dry_run: If True, simulate the change without modifying the file
+
+    Returns a result message.
+    """
+    tool_name = "ReplaceLines"
+    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):
+            raise ToolError(f"File '{file_path}' 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:
+                raise ToolError(f"File '{file_path}' is read-only. Use MakeEditable first.")
+            else:
+                raise ToolError(f"File '{file_path}' not in context")
+
+        # Reread file content immediately before modification
+        file_content = coder.io.read_text(abs_path)
+        if file_content is None:
+            raise ToolError(f"Could not read file '{file_path}'")
+
+        # Convert line numbers to integers if needed
+        try:
+            start_line = int(start_line)
+        except ValueError:
+            raise ToolError(f"Invalid start_line value: '{start_line}'. Must be an integer.")
+
+        try:
+            end_line = int(end_line)
+        except ValueError:
+            raise ToolError(f"Invalid end_line value: '{end_line}'. Must be an integer.")
+
+        # Split into lines
+        lines = file_content.splitlines()
+
+        # Convert 1-based line numbers to 0-based indices
+        start_idx = start_line - 1
+        end_idx = end_line - 1
+
+        # Validate line numbers
+        if start_idx < 0 or start_idx >= len(lines):
+            raise ToolError(
+                f"Start line {start_line} is out of range for file '{file_path}' (has"
+                f" {len(lines)} lines)."
+            )
+
+        if end_idx < start_idx or end_idx >= len(lines):
+            raise ToolError(
+                f"End line {end_line} is out of range for file '{file_path}' (must be >= start line"
+                f" {start_line} and <= {len(lines)})."
+            )
+
+        # Store original content for change tracking
+        original_content = file_content
+        replaced_lines = lines[start_idx : end_idx + 1]
+
+        # Split the new content into lines
+        new_lines = new_content.splitlines()
+
+        # Perform the replacement
+        new_full_lines = lines[:start_idx] + new_lines + lines[end_idx + 1 :]
+        new_content_full = "\n".join(new_full_lines)
+
+        if original_content == new_content_full:
+            coder.io.tool_warning("No changes made: new content is identical to original")
+            return "Warning: No changes made (new content identical to original)"
+
+        # Generate diff snippet
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content_full, rel_path)
+
+        # Create a readable diff for the lines replacement
+        diff = f"Lines {start_line}-{end_line}:\n"
+        # Add removed lines with - prefix
+        for line in replaced_lines:
+            diff += f"- {line}\n"
+        # Add separator
+        diff += "---\n"
+        # Add new lines with + prefix
+        for line in new_lines:
+            diff += f"+ {line}\n"
+
+        # Handle dry run
+        if dry_run:
+            dry_run_message = f"Dry run: Would replace lines {start_line}-{end_line} in {file_path}"
+            return format_tool_result(
+                coder,
+                tool_name,
+                "",
+                dry_run=True,
+                dry_run_message=dry_run_message,
+                diff_snippet=diff_snippet,
+            )
+
+        # --- Apply Change (Not dry run) ---
+        metadata = {
+            "start_line": start_line,
+            "end_line": end_line,
+            "replaced_lines": replaced_lines,
+            "new_lines": new_lines,
+        }
+
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content_full,
+            "replacelines",
+            metadata,
+            change_id,
+        )
+
+        coder.files_edited_by_tools.add(rel_path)
+        replaced_count = end_line - start_line + 1
+        new_count = len(new_lines)
+
+        # Format and return result
+        success_message = (
+            f"Replaced lines {start_line}-{end_line} ({replaced_count} lines) with {new_count} new"
+            f" lines in {file_path}"
+        )
+        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:
+        # Handle unexpected errors
+        return handle_tool_error(coder, tool_name, e)
+
+
+def process_response(coder, params):
+    """
+    Process the ReplaceLines tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    file_path = params.get("file_path")
+    start_line = params.get("start_line")
+    end_line = params.get("end_line")
+    new_content = params.get("new_content")
+    change_id = params.get("change_id")
+    dry_run = params.get("dry_run", False)
+
+    if (
+        file_path is not None
+        and start_line is not None
+        and end_line is not None
+        and new_content is not None
+    ):
+        return _execute_replace_lines(
+            coder, file_path, start_line, end_line, new_content, change_id, dry_run
+        )
+    else:
+        return (
+            "Error: Missing required parameters for ReplaceLines (file_path,"
+            " start_line, end_line, new_content)"
+        )