aider-ce 0.88.20__py3-none-any.whl

aider/tools/insert_block.py

@@ -0,0 +1,288 @@
+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,
+)
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "InsertBlock",
+        "description": "Insert a block of content into a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "content": {"type": "string"},
+                "after_pattern": {"type": "string"},
+                "before_pattern": {"type": "string"},
+                "occurrence": {"type": "integer", "default": 1},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+                "position": {"type": "string", "enum": ["top", "bottom"]},
+                "auto_indent": {"type": "boolean", "default": True},
+                "use_regex": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "content"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "insertblock"
+
+
+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" or position == "top":
+                insertion_line_idx = 0
+                pattern_type = "at start of"
+            elif position == "end_of_file" or position == "bottom":
+                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,
+        )
+
+        coder.files_edited_by_tools.add(rel_path)
+
+        # 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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the InsertBlock tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    file_path = params.get("file_path")
+    content = params.get("content")
+    after_pattern = params.get("after_pattern")
+    before_pattern = params.get("before_pattern")
+    occurrence = params.get("occurrence", 1)
+    change_id = params.get("change_id")
+    dry_run = params.get("dry_run", False)
+    position = params.get("position")
+    auto_indent = params.get("auto_indent", True)
+    use_regex = params.get("use_regex", False)
+
+    if (
+        file_path is not None
+        and content is not None
+        and (after_pattern is not None or before_pattern is not None or position is not None)
+    ):
+        return _execute_insert_block(
+            coder,
+            file_path,
+            content,
+            after_pattern,
+            before_pattern,
+            occurrence,
+            change_id,
+            dry_run,
+            position,
+            auto_indent,
+            use_regex,
+        )
+
+    else:
+        return (
+            "Error: Missing required parameters for InsertBlock (file_path,"
+            " content, and either after_pattern or before_pattern)"
+        )

aider/tools/list_changes.py

@@ -0,0 +1,86 @@
+import traceback
+from datetime import datetime
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "ListChanges",
+        "description": "List recent changes made.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "limit": {"type": "integer", "default": 10},
+            },
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "listchanges"
+
+
+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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the ListChanges tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    file_path = params.get("file_path")
+    limit = params.get("limit", 10)
+
+    return _execute_list_changes(coder, file_path, limit)

aider/tools/ls.py

@@ -0,0 +1,93 @@
+import os
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "Ls",
+        "description": "List files in a directory.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "directory": {
+                    "type": "string",
+                    "description": "The directory to list.",
+                },
+            },
+            "required": ["directory"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "ls"
+
+
+def execute_ls(coder, dir_path=None, directory=None):
+    # Handle both positional and keyword arguments for backward compatibility
+    if dir_path is None and directory is not None:
+        dir_path = directory
+    elif dir_path is None:
+        return "Error: Missing directory parameter"
+    """
+    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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the Ls tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    directory = params.get("directory")
+    if directory is not None:
+        return execute_ls(coder, directory)
+    else:
+        return "Error: Missing 'directory' parameter for Ls"

aider/tools/make_editable.py

@@ -0,0 +1,85 @@
+import os
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "MakeEditable",
+        "description": "Make a read-only file editable.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The path to the file to make editable.",
+                },
+            },
+            "required": ["file_path"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "makeeditable"
+
+
+# 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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the MakeEditable 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_make_editable(coder, file_path)
+    else:
+        return "Error: Missing 'file_path' parameter for MakeEditable"

aider/tools/make_readonly.py

@@ -0,0 +1,69 @@
+schema = {
+    "type": "function",
+    "function": {
+        "name": "MakeReadonly",
+        "description": "Make an editable file read-only.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The path to the file to make read-only.",
+                },
+            },
+            "required": ["file_path"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "makereadonly"
+
+
+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)}"
+
+
+def process_response(coder, params):
+    """
+    Process the MakeReadonly 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_make_readonly(coder, file_path)
+    else:
+        return "Error: Missing 'file_path' parameter for MakeReadonly"