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

aider/tools/replace_lines.py

@@ -0,0 +1,160 @@
+import os
+
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+)
+
+
+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.aider_edited_files.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)

aider/tools/replace_text.py

@@ -0,0 +1,125 @@
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    validate_file_for_edit,
+)
+
+
+def _execute_replace_text(
+    coder,
+    file_path,
+    find_text,
+    replace_text,
+    near_context=None,
+    occurrence=1,
+    change_id=None,
+    dry_run=False,
+):
+    """
+    Replace specific text with new text, optionally using nearby context for disambiguation.
+    Uses utility functions for validation, finding occurrences, and applying changes.
+    """
+    tool_name = "ReplaceText"
+    try:
+        # 1. Validate file and get content
+        abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+
+        # 2. Find occurrences using helper function
+        # Note: _find_occurrences is currently on the Coder class, not in tool_utils
+        occurrences = coder._find_occurrences(original_content, find_text, near_context)
+
+        if not occurrences:
+            err_msg = f"Text '{find_text}' not found"
+            if near_context:
+                err_msg += f" near context '{near_context}'"
+            err_msg += f" in file '{file_path}'."
+            raise ToolError(err_msg)
+
+        # 3. Select the occurrence index
+        num_occurrences = len(occurrences)
+        try:
+            occurrence = int(occurrence)
+            if occurrence == -1:
+                if num_occurrences == 0:
+                    raise ToolError(f"Text '{find_text}' not found, cannot select last occurrence.")
+                target_idx = num_occurrences - 1
+            elif 1 <= occurrence <= num_occurrences:
+                target_idx = occurrence - 1  # Convert 1-based to 0-based
+            else:
+                err_msg = (
+                    f"Occurrence number {occurrence} is out of range. Found"
+                    f" {num_occurrences} occurrences of '{find_text}'"
+                )
+                if near_context:
+                    err_msg += f" near '{near_context}'"
+                err_msg += f" in '{file_path}'."
+                raise ToolError(err_msg)
+        except ValueError:
+            raise ToolError(f"Invalid occurrence value: '{occurrence}'. Must be an integer.")
+
+        start_index = occurrences[target_idx]
+
+        # 4. Perform the replacement
+        new_content = (
+            original_content[:start_index]
+            + replace_text
+            + original_content[start_index + len(find_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)"
+
+        # 5. Generate diff for feedback
+        # Note: _generate_diff_snippet is currently on the Coder class
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+        occurrence_str = f"occurrence {occurrence}" if num_occurrences > 1 else "text"
+
+        # 6. Handle dry run
+        if dry_run:
+            dry_run_message = (
+                f"Dry run: Would replace {occurrence_str} 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_snippet,
+            )
+
+        # 7. Apply Change (Not dry run)
+        metadata = {
+            "start_index": start_index,
+            "find_text": find_text,
+            "replace_text": replace_text,
+            "near_context": near_context,
+            "occurrence": occurrence,
+        }
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "replacetext",
+            metadata,
+            change_id,
+        )
+
+        # 8. Format and return result
+        success_message = f"Replaced {occurrence_str} 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 or explicitly raised here
+        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/show_numbered_context.py

@@ -0,0 +1,101 @@
+import os
+
+from .tool_utils import ToolError, handle_tool_error, resolve_paths
+
+
+def execute_show_numbered_context(
+    coder, file_path, pattern=None, line_number=None, context_lines=3
+):
+    """
+    Displays numbered lines from file_path centered around a target location
+    (pattern or line_number), without adding the file to context.
+    Uses utility functions for path resolution and error handling.
+    """
+    tool_name = "ShowNumberedContext"
+    try:
+        # 1. Validate arguments
+        if not (pattern is None) ^ (line_number is None):
+            raise ToolError("Provide exactly one of 'pattern' or 'line_number'.")
+
+        # 2. Resolve path
+        abs_path, rel_path = resolve_paths(coder, file_path)
+        if not os.path.exists(abs_path):
+            # Check existence after resolving, as resolve_paths doesn't guarantee existence
+            raise ToolError(f"File not found: {file_path}")
+
+        # 3. Read file content
+        content = coder.io.read_text(abs_path)
+        if content is None:
+            raise ToolError(f"Could not read file: {file_path}")
+        lines = content.splitlines()
+        num_lines = len(lines)
+
+        # 4. Determine center line index
+        center_line_idx = -1
+        found_by = ""
+
+        if line_number is not None:
+            try:
+                line_number_int = int(line_number)
+                if 1 <= line_number_int <= num_lines:
+                    center_line_idx = line_number_int - 1  # Convert to 0-based index
+                    found_by = f"line {line_number_int}"
+                else:
+                    raise ToolError(
+                        f"Line number {line_number_int} is out of range (1-{num_lines}) for"
+                        f" {file_path}."
+                    )
+            except ValueError:
+                raise ToolError(f"Invalid line number '{line_number}'. Must be an integer.")
+
+        elif pattern is not None:
+            # TODO: Update this section for multiline pattern support later
+            first_match_line_idx = -1
+            for i, line in enumerate(lines):
+                if pattern in line:
+                    first_match_line_idx = i
+                    break
+
+            if first_match_line_idx != -1:
+                center_line_idx = first_match_line_idx
+                found_by = f"pattern '{pattern}' on line {center_line_idx + 1}"
+            else:
+                raise ToolError(f"Pattern '{pattern}' not found in {file_path}.")
+
+        if center_line_idx == -1:
+            # Should not happen if logic above is correct, but as a safeguard
+            raise ToolError("Internal error: Could not determine center line.")
+
+        # 5. Calculate context window
+        try:
+            context_lines_int = int(context_lines)
+            if context_lines_int < 0:
+                raise ValueError("Context lines must be non-negative")
+        except ValueError:
+            coder.io.tool_warning(
+                f"Invalid context_lines value '{context_lines}', using default 3."
+            )
+            context_lines_int = 3
+
+        start_line_idx = max(0, center_line_idx - context_lines_int)
+        end_line_idx = min(num_lines - 1, center_line_idx + context_lines_int)
+
+        # 6. Format output
+        # Use rel_path for user-facing messages
+        output_lines = [f"Displaying context around {found_by} in {rel_path}:"]
+        max_line_num_width = len(str(end_line_idx + 1))  # Width for padding
+
+        for i in range(start_line_idx, end_line_idx + 1):
+            line_num_str = str(i + 1).rjust(max_line_num_width)
+            output_lines.append(f"{line_num_str} | {lines[i]}")
+
+        # Log success and return the formatted context directly
+        coder.io.tool_output(f"Successfully retrieved context for {rel_path}")
+        return "\n".join(output_lines)
+
+    except ToolError as e:
+        # Handle expected errors raised by utility functions or validation
+        return handle_tool_error(coder, tool_name, e, add_traceback=False)
+    except Exception as e:
+        # Handle unexpected errors during processing
+        return handle_tool_error(coder, tool_name, e)

aider/tools/tool_utils.py

@@ -0,0 +1,313 @@
+import difflib
+import os
+import re
+import traceback
+
+
+class ToolError(Exception):
+    """Custom exception for tool-specific errors that should be reported to the LLM."""
+
+    pass
+
+
+def resolve_paths(coder, file_path):
+    """Resolves absolute and relative paths for a given file path."""
+    try:
+        abs_path = coder.abs_root_path(file_path)
+        rel_path = coder.get_rel_fname(abs_path)
+        return abs_path, rel_path
+    except Exception as e:
+        # Wrap unexpected errors during path resolution
+        raise ToolError(f"Error resolving path '{file_path}': {e}")
+
+
+def validate_file_for_edit(coder, file_path):
+    """
+    Validates if a file exists, is in context, and is editable.
+    Reads and returns original content if valid.
+    Raises ToolError on failure.
+
+    Returns:
+        tuple: (absolute_path, relative_path, original_content)
+    """
+    abs_path, rel_path = resolve_paths(coder, file_path)
+
+    if not os.path.isfile(abs_path):
+        raise ToolError(f"File '{file_path}' not found")
+
+    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:
+            # File exists but is not in context at all
+            raise ToolError(f"File '{file_path}' not in context. Use View or MakeEditable first.")
+
+    # Reread content immediately before potential modification
+    content = coder.io.read_text(abs_path)
+    if content is None:
+        # This indicates an issue reading a file we know exists and is in context
+        coder.io.tool_error(
+            f"Internal error: Could not read file '{file_path}' which should be accessible."
+        )
+        raise ToolError(f"Could not read file '{file_path}'")
+
+    return abs_path, rel_path, content
+
+
+def find_pattern_indices(lines, pattern, use_regex=False):
+    """Finds all line indices matching a pattern."""
+    indices = []
+    for i, line in enumerate(lines):
+        if (use_regex and re.search(pattern, line)) or (not use_regex and pattern in line):
+            indices.append(i)
+    return indices
+
+
+def select_occurrence_index(indices, occurrence, pattern_desc="Pattern"):
+    """
+    Selects the target 0-based index from a list of indices based on the 1-based occurrence parameter.
+    Raises ToolError if the pattern wasn't found or the occurrence is invalid.
+    """
+    num_occurrences = len(indices)
+    if not indices:
+        raise ToolError(f"{pattern_desc} not found")
+
+    try:
+        occurrence = int(occurrence)  # Ensure occurrence is an integer
+        if occurrence == -1:  # Last occurrence
+            if num_occurrences == 0:
+                raise ToolError(f"{pattern_desc} not found, cannot select last occurrence.")
+            target_idx = num_occurrences - 1
+        elif 1 <= occurrence <= num_occurrences:
+            target_idx = occurrence - 1  # Convert 1-based to 0-based
+        else:
+            raise ToolError(
+                f"Occurrence number {occurrence} is out of range for {pattern_desc}. Found"
+                f" {num_occurrences} occurrences."
+            )
+    except ValueError:
+        raise ToolError(f"Invalid occurrence value: '{occurrence}'. Must be an integer.")
+
+    return indices[target_idx]
+
+
+def determine_line_range(
+    coder,
+    file_path,
+    lines,
+    start_pattern_line_index=None,  # Made optional
+    end_pattern=None,
+    line_count=None,
+    target_symbol=None,
+    pattern_desc="Block",
+):
+    """
+    Determines the end line index based on end_pattern or line_count.
+    Raises ToolError if end_pattern is not found or line_count is invalid.
+    """
+    # Parameter validation: Ensure only one targeting method is used
+    targeting_methods = [
+        target_symbol is not None,
+        start_pattern_line_index is not None,
+        # Note: line_count and end_pattern depend on start_pattern_line_index
+    ]
+    if sum(targeting_methods) > 1:
+        raise ToolError("Cannot specify target_symbol along with start_pattern.")
+    if sum(targeting_methods) == 0:
+        raise ToolError(
+            "Must specify either target_symbol or start_pattern."
+        )  # Or line numbers for line-based tools, handled elsewhere
+
+    if target_symbol:
+        if end_pattern or line_count:
+            raise ToolError("Cannot specify end_pattern or line_count when using target_symbol.")
+        try:
+            # Use repo_map to find the symbol's definition range
+            start_line, end_line = coder.repo_map.get_symbol_definition_location(
+                file_path, target_symbol
+            )
+            return start_line, end_line
+        except AttributeError:  # Use specific exception
+            # Check if repo_map exists and is initialized before accessing methods
+            if not hasattr(coder, "repo_map") or coder.repo_map is None:
+                raise ToolError("RepoMap is not available or not initialized.")
+            # If repo_map exists, the error might be from get_symbol_definition_location itself
+            # Re-raise ToolErrors directly
+            raise
+        except ToolError as e:
+            # Propagate specific ToolErrors from repo_map (not found, ambiguous, etc.)
+            raise e
+        except Exception as e:
+            # Catch other unexpected errors during symbol lookup
+            raise ToolError(f"Unexpected error looking up symbol '{target_symbol}': {e}")
+
+    # --- Existing logic for pattern/line_count based targeting ---
+    # Ensure start_pattern_line_index is provided if not using target_symbol
+    if start_pattern_line_index is None:
+        raise ToolError(
+            "Internal error: start_pattern_line_index is required when not using target_symbol."
+        )
+
+    # Assign start_line here for the pattern-based logic path
+    start_line = start_pattern_line_index  # Start of existing logic
+    start_line = start_pattern_line_index
+    end_line = -1
+
+    if end_pattern and line_count:
+        raise ToolError("Cannot specify both end_pattern and line_count")
+
+    if end_pattern:
+        found_end = False
+        # Search from the start_line onwards for the end_pattern
+        for i in range(start_line, len(lines)):
+            if end_pattern in lines[i]:
+                end_line = i
+                found_end = True
+                break
+        if not found_end:
+            raise ToolError(
+                f"End pattern '{end_pattern}' not found after start pattern on line"
+                f" {start_line + 1}"
+            )
+    elif line_count:
+        try:
+            line_count = int(line_count)
+            if line_count <= 0:
+                raise ValueError("Line count must be positive")
+            # Calculate end line index, ensuring it doesn't exceed file bounds
+            end_line = min(start_line + line_count - 1, len(lines) - 1)
+        except ValueError:
+            raise ToolError(
+                f"Invalid line_count value: '{line_count}'. Must be a positive integer."
+            )
+    else:
+        # If neither end_pattern nor line_count is given, the range is just the start line
+        end_line = start_line
+
+    return start_line, end_line
+
+
+def generate_unified_diff_snippet(original_content, new_content, file_path, context_lines=3):
+    """
+    Generates a unified diff snippet between original and new content.
+
+    Args:
+        original_content (str): The original file content.
+        new_content (str): The modified file content.
+        file_path (str): The relative path to the file (for display in diff header).
+        context_lines (int): Number of context lines to show around changes.
+
+    Returns:
+        str: A formatted unified diff snippet, or an empty string if no changes.
+    """
+    if original_content == new_content:
+        return ""
+
+    original_lines = original_content.splitlines(keepends=True)
+    new_lines = new_content.splitlines(keepends=True)
+
+    diff = difflib.unified_diff(
+        original_lines,
+        new_lines,
+        fromfile=f"a/{file_path}",
+        tofile=f"b/{file_path}",
+        n=context_lines,  # Number of context lines
+    )
+
+    # Join the diff lines, potentially skipping the header if desired,
+    # but let's keep it for standard format.
+    diff_snippet = "".join(diff)
+
+    # Ensure snippet ends with a newline for cleaner formatting in results
+    if diff_snippet and not diff_snippet.endswith("\n"):
+        diff_snippet += "\n"
+
+    return diff_snippet
+
+
+def apply_change(
+    coder, abs_path, rel_path, original_content, new_content, change_type, metadata, change_id=None
+):
+    """
+    Writes the new content, tracks the change, and updates coder state.
+    Returns the final change ID. Raises ToolError on tracking failure.
+    """
+    coder.io.write_text(abs_path, new_content)
+    try:
+        final_change_id = coder.change_tracker.track_change(
+            file_path=rel_path,
+            change_type=change_type,
+            original_content=original_content,
+            new_content=new_content,
+            metadata=metadata,
+            change_id=change_id,
+        )
+    except Exception as track_e:
+        # Log the error but also raise ToolError to inform the LLM
+        coder.io.tool_error(f"Error tracking change for {change_type}: {track_e}")
+        raise ToolError(f"Failed to track change: {track_e}")
+
+    coder.aider_edited_files.add(rel_path)
+    return final_change_id
+
+
+def handle_tool_error(coder, tool_name, e, add_traceback=True):
+    """Logs tool errors and returns a formatted error message for the LLM."""
+    error_message = f"Error in {tool_name}: {str(e)}"
+    if add_traceback:
+        error_message += f"\n{traceback.format_exc()}"
+    coder.io.tool_error(error_message)
+    # Return only the core error message to the LLM for brevity
+    return f"Error: {str(e)}"
+
+
+def format_tool_result(
+    coder,
+    tool_name,
+    success_message,
+    change_id=None,
+    diff_snippet=None,
+    dry_run=False,
+    dry_run_message=None,
+):
+    """Formats the result message for tool execution."""
+    if dry_run:
+        full_message = dry_run_message or f"Dry run: Would execute {tool_name}."
+        if diff_snippet:
+            full_message += f" Diff snippet:\n{diff_snippet}"
+        coder.io.tool_output(full_message)  # Log the dry run action
+        return full_message
+    else:
+        # Use the provided success message, potentially adding change_id and diff
+        full_message = f"✅ {success_message}"
+        if change_id:
+            full_message += f" (change_id: {change_id})"
+        coder.io.tool_output(full_message)  # Log the success action
+
+        result_for_llm = f"Successfully executed {tool_name}."
+        if change_id:
+            result_for_llm += f" Change ID: {change_id}."
+        if diff_snippet:
+            result_for_llm += f" Diff snippet:\n{diff_snippet}"
+        return result_for_llm
+
+
+# Example usage within a hypothetical tool:
+# try:
+#     abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+#     # ... tool specific logic to determine new_content and metadata ...
+#     if dry_run:
+#         return format_tool_result(coder, "MyTool", "", dry_run=True, diff_snippet=diff)
+#
+#     change_id = apply_change(coder, abs_path, rel_path, original_content, new_content, 'mytool', metadata)
+#     return format_tool_result(
+#       coder,
+#       "MyTool",
+#       f"Applied change to {file_path}",
+#       change_id=change_id,
+#       diff_snippet=diff
+#     )
+# except ToolError as e:
+#     return handle_tool_error(coder, "MyTool", e, add_traceback=False) # Don't need traceback for ToolErrors
+# except Exception as e:
+#     return handle_tool_error(coder, "MyTool", e)