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

aider/tools/extract_lines.py

@@ -0,0 +1,276 @@
+import os
+import traceback
+
+from .tool_utils import generate_unified_diff_snippet
+
+
+def _execute_extract_lines(
+    coder,
+    source_file_path,
+    target_file_path,
+    start_pattern,
+    end_pattern=None,
+    line_count=None,
+    near_context=None,
+    occurrence=1,
+    dry_run=False,
+):
+    """
+    Extract a range of lines from a source file and move them to a target file.
+
+    Parameters:
+    - coder: The Coder instance
+    - source_file_path: Path to the file to extract lines from
+    - target_file_path: Path to the file to append extracted lines to (will be created if needed)
+    - start_pattern: Pattern marking the start of the block to extract
+    - end_pattern: Optional pattern marking the end of the block
+    - line_count: Optional number of lines to extract (alternative to end_pattern)
+    - near_context: Optional text nearby to help locate the correct instance of the start_pattern
+    - occurrence: Which occurrence of the start_pattern to use (1-based index, or -1 for last)
+    - dry_run: If True, simulate the change without modifying files
+
+    Returns a result message.
+    """
+    try:
+        # --- Validate Source File ---
+        abs_source_path = coder.abs_root_path(source_file_path)
+        rel_source_path = coder.get_rel_fname(abs_source_path)
+
+        if not os.path.isfile(abs_source_path):
+            coder.io.tool_error(f"Source file '{source_file_path}' not found")
+            return "Error: Source file not found"
+
+        if abs_source_path not in coder.abs_fnames:
+            if abs_source_path in coder.abs_read_only_fnames:
+                coder.io.tool_error(
+                    f"Source file '{source_file_path}' is read-only. Use MakeEditable first."
+                )
+                return "Error: Source file is read-only. Use MakeEditable first."
+            else:
+                coder.io.tool_error(f"Source file '{source_file_path}' not in context")
+                return "Error: Source file not in context"
+
+        # --- Validate Target File ---
+        abs_target_path = coder.abs_root_path(target_file_path)
+        rel_target_path = coder.get_rel_fname(abs_target_path)
+        target_exists = os.path.isfile(abs_target_path)
+        target_is_editable = abs_target_path in coder.abs_fnames
+        target_is_readonly = abs_target_path in coder.abs_read_only_fnames
+
+        if target_exists and not target_is_editable:
+            if target_is_readonly:
+                coder.io.tool_error(
+                    f"Target file '{target_file_path}' exists but is read-only. Use MakeEditable"
+                    " first."
+                )
+                return "Error: Target file exists but is read-only. Use MakeEditable first."
+            else:
+                # This case shouldn't happen if file exists, but handle defensively
+                coder.io.tool_error(
+                    f"Target file '{target_file_path}' exists but is not in context. Add it first."
+                )
+                return "Error: Target file exists but is not in context."
+
+        # --- Read Source Content ---
+        source_content = coder.io.read_text(abs_source_path)
+        if source_content is None:
+            coder.io.tool_error(
+                f"Could not read source file '{source_file_path}' before ExtractLines operation."
+            )
+            return f"Error: Could not read source file '{source_file_path}'"
+
+        # --- Find Extraction Range ---
+        if end_pattern and line_count:
+            coder.io.tool_error("Cannot specify both end_pattern and line_count")
+            return "Error: Cannot specify both end_pattern and line_count"
+
+        source_lines = source_content.splitlines()
+        original_source_content = source_content
+
+        start_pattern_line_indices = []
+        for i, line in enumerate(source_lines):
+            if start_pattern in line:
+                if near_context:
+                    context_window_start = max(0, i - 5)
+                    context_window_end = min(len(source_lines), i + 6)
+                    context_block = "\n".join(source_lines[context_window_start:context_window_end])
+                    if near_context in context_block:
+                        start_pattern_line_indices.append(i)
+                else:
+                    start_pattern_line_indices.append(i)
+
+        if not start_pattern_line_indices:
+            err_msg = f"Start pattern '{start_pattern}' not found"
+            if near_context:
+                err_msg += f" near context '{near_context}'"
+            err_msg += f" in source file '{source_file_path}'."
+            coder.io.tool_error(err_msg)
+            return f"Error: {err_msg}"
+
+        num_occurrences = len(start_pattern_line_indices)
+        try:
+            occurrence = int(occurrence)
+            if occurrence == -1:
+                target_idx = num_occurrences - 1
+            elif occurrence > 0 and occurrence <= num_occurrences:
+                target_idx = occurrence - 1
+            else:
+                err_msg = (
+                    f"Occurrence number {occurrence} is out of range for start pattern"
+                    f" '{start_pattern}'. Found {num_occurrences} occurrences"
+                )
+                if near_context:
+                    err_msg += f" near '{near_context}'"
+                err_msg += f" in '{source_file_path}'."
+                coder.io.tool_error(err_msg)
+                return f"Error: {err_msg}"
+        except ValueError:
+            coder.io.tool_error(f"Invalid occurrence value: '{occurrence}'. Must be an integer.")
+            return f"Error: Invalid occurrence value '{occurrence}'"
+
+        start_line = start_pattern_line_indices[target_idx]
+        occurrence_str = f"occurrence {occurrence} of " if num_occurrences > 1 else ""
+
+        end_line = -1
+        if end_pattern:
+            for i in range(start_line, len(source_lines)):
+                if end_pattern in source_lines[i]:
+                    end_line = i
+                    break
+            if end_line == -1:
+                err_msg = (
+                    f"End pattern '{end_pattern}' not found after {occurrence_str}start pattern"
+                    f" '{start_pattern}' (line {start_line + 1}) in '{source_file_path}'."
+                )
+                coder.io.tool_error(err_msg)
+                return f"Error: {err_msg}"
+        elif line_count:
+            try:
+                line_count = int(line_count)
+                if line_count <= 0:
+                    raise ValueError("Line count must be positive")
+                end_line = min(start_line + line_count - 1, len(source_lines) - 1)
+            except ValueError:
+                coder.io.tool_error(
+                    f"Invalid line_count value: '{line_count}'. Must be a positive integer."
+                )
+                return f"Error: Invalid line_count value '{line_count}'"
+        else:
+            end_line = start_line  # Extract just the start line if no end specified
+
+        # --- Prepare Content Changes ---
+        extracted_lines = source_lines[start_line : end_line + 1]
+        new_source_lines = source_lines[:start_line] + source_lines[end_line + 1 :]
+        new_source_content = "\n".join(new_source_lines)
+
+        target_content = ""
+        if target_exists:
+            target_content = coder.io.read_text(abs_target_path)
+            if target_content is None:
+                coder.io.tool_error(f"Could not read existing target file '{target_file_path}'.")
+                return f"Error: Could not read target file '{target_file_path}'"
+        original_target_content = target_content  # For tracking
+
+        # Append extracted lines to target content, ensuring a newline if target wasn't empty
+        extracted_block = "\n".join(extracted_lines)
+        if target_content and not target_content.endswith("\n"):
+            target_content += "\n"  # Add newline before appending if needed
+        new_target_content = target_content + extracted_block
+
+        # --- Generate Diffs ---
+        source_diff_snippet = generate_unified_diff_snippet(
+            original_source_content, new_source_content, rel_source_path
+        )
+        target_insertion_line = len(target_content.splitlines()) if target_content else 0
+        target_diff_snippet = generate_unified_diff_snippet(
+            original_target_content, new_target_content, rel_target_path
+        )
+
+        # --- Handle Dry Run ---
+        if dry_run:
+            num_extracted = end_line - start_line + 1
+            target_action = "append to" if target_exists else "create"
+            coder.io.tool_output(
+                f"Dry run: Would extract {num_extracted} lines (from {occurrence_str}start pattern"
+                f" '{start_pattern}') in {source_file_path} and {target_action} {target_file_path}"
+            )
+            # Provide more informative dry run response with diffs
+            return (
+                f"Dry run: Would extract {num_extracted} lines from {rel_source_path} and"
+                f" {target_action} {rel_target_path}.\nSource Diff"
+                f" (Deletion):\n{source_diff_snippet}\nTarget Diff"
+                f" (Insertion):\n{target_diff_snippet}"
+            )
+
+        # --- Apply Changes (Not Dry Run) ---
+        coder.io.write_text(abs_source_path, new_source_content)
+        coder.io.write_text(abs_target_path, new_target_content)
+
+        # --- Track Changes ---
+        source_change_id = "TRACKING_FAILED"
+        target_change_id = "TRACKING_FAILED"
+        try:
+            source_metadata = {
+                "start_line": start_line + 1,
+                "end_line": end_line + 1,
+                "start_pattern": start_pattern,
+                "end_pattern": end_pattern,
+                "line_count": line_count,
+                "near_context": near_context,
+                "occurrence": occurrence,
+                "extracted_content": extracted_block,
+                "target_file": rel_target_path,
+            }
+            source_change_id = coder.change_tracker.track_change(
+                file_path=rel_source_path,
+                change_type="extractlines_source",
+                original_content=original_source_content,
+                new_content=new_source_content,
+                metadata=source_metadata,
+            )
+        except Exception as track_e:
+            coder.io.tool_error(f"Error tracking source change for ExtractLines: {track_e}")
+
+        try:
+            target_metadata = {
+                "insertion_line": target_insertion_line + 1,
+                "inserted_content": extracted_block,
+                "source_file": rel_source_path,
+            }
+            target_change_id = coder.change_tracker.track_change(
+                file_path=rel_target_path,
+                change_type="extractlines_target",
+                original_content=original_target_content,
+                new_content=new_target_content,
+                metadata=target_metadata,
+            )
+        except Exception as track_e:
+            coder.io.tool_error(f"Error tracking target change for ExtractLines: {track_e}")
+
+        # --- Update Context ---
+        coder.aider_edited_files.add(rel_source_path)
+        coder.aider_edited_files.add(rel_target_path)
+        if not target_exists:
+            # Add the newly created file to editable context
+            coder.abs_fnames.add(abs_target_path)
+            coder.io.tool_output(f"✨ Created and added '{target_file_path}' to editable context.")
+
+        # --- Return Result ---
+        num_extracted = end_line - start_line + 1
+        target_action = "appended to" if target_exists else "created"
+        coder.io.tool_output(
+            f"✅ Extracted {num_extracted} lines from {rel_source_path} (change_id:"
+            f" {source_change_id}) and {target_action} {rel_target_path} (change_id:"
+            f" {target_change_id})"
+        )
+        # Provide more informative success response with change IDs and diffs
+        return (
+            f"Successfully extracted {num_extracted} lines from {rel_source_path} and"
+            f" {target_action} {rel_target_path}.\nSource Change ID: {source_change_id}\nSource"
+            f" Diff (Deletion):\n{source_diff_snippet}\nTarget Change ID:"
+            f" {target_change_id}\nTarget Diff (Insertion):\n{target_diff_snippet}"
+        )
+
+    except Exception as e:
+        coder.io.tool_error(f"Error in ExtractLines: {str(e)}\n{traceback.format_exc()}")
+        return f"Error: {str(e)}"

aider/tools/grep.py

@@ -0,0 +1,171 @@
+import shlex
+import shutil
+from pathlib import Path
+
+from aider.run_cmd import run_cmd_subprocess
+
+
+def _find_search_tool():
+    """Find the best available command-line search tool (rg, ag, grep)."""
+    if shutil.which("rg"):
+        return "rg", shutil.which("rg")
+    elif shutil.which("ag"):
+        return "ag", shutil.which("ag")
+    elif shutil.which("grep"):
+        return "grep", shutil.which("grep")
+    else:
+        return None, None
+
+
+def _execute_grep(
+    coder,
+    pattern,
+    file_pattern="*",
+    directory=".",
+    use_regex=False,
+    case_insensitive=False,
+    context_before=5,
+    context_after=5,
+):
+    """
+    Search for lines matching a pattern in files within the project repository.
+    Uses rg (ripgrep), ag (the silver searcher), or grep, whichever is available.
+
+    Args:
+        coder: The Coder instance.
+        pattern (str): The pattern to search for.
+        file_pattern (str, optional): Glob pattern to filter files. Defaults to "*".
+        directory (str, optional): Directory to search within relative to repo root. Defaults to ".".
+        use_regex (bool, optional): Whether the pattern is a regular expression. Defaults to False.
+        case_insensitive (bool, optional): Whether the search should be case-insensitive. Defaults to False.
+        context_before (int, optional): Number of context lines to show before matches. Defaults to 5.
+        context_after (int, optional): Number of context lines to show after matches. Defaults to 5.
+
+    Returns:
+        str: Formatted result indicating success or failure, including matching lines or error message.
+    """
+    repo = coder.repo
+    if not repo:
+        coder.io.tool_error("Not in a git repository.")
+        return "Error: Not in a git repository."
+
+    tool_name, tool_path = _find_search_tool()
+    if not tool_path:
+        coder.io.tool_error("No search tool (rg, ag, grep) found in PATH.")
+        return "Error: No search tool (rg, ag, grep) found."
+
+    try:
+        search_dir_path = Path(repo.root) / directory
+        if not search_dir_path.is_dir():
+            coder.io.tool_error(f"Directory not found: {directory}")
+            return f"Error: Directory not found: {directory}"
+
+        # Build the command arguments based on the available tool
+        cmd_args = [tool_path]
+
+        # Common options or tool-specific equivalents
+        if tool_name in ["rg", "grep"]:
+            cmd_args.append("-n")  # Line numbers for rg and grep
+        # ag includes line numbers by default
+
+        # Context lines (Before and After)
+        if context_before > 0:
+            # All tools use -B for lines before
+            cmd_args.extend(["-B", str(context_before)])
+        if context_after > 0:
+            # All tools use -A for lines after
+            cmd_args.extend(["-A", str(context_after)])
+
+        # Case sensitivity
+        if case_insensitive:
+            cmd_args.append("-i")  # Add case-insensitivity flag for all tools
+
+        # Pattern type (regex vs fixed string)
+        if use_regex:
+            if tool_name == "grep":
+                cmd_args.append("-E")  # Use extended regex for grep
+            # rg and ag use regex by default, no flag needed for basic ERE
+        else:
+            if tool_name == "rg":
+                cmd_args.append("-F")  # Fixed strings for rg
+            elif tool_name == "ag":
+                cmd_args.append("-Q")  # Literal/fixed strings for ag
+            elif tool_name == "grep":
+                cmd_args.append("-F")  # Fixed strings for grep
+
+        # File filtering
+        if (
+            file_pattern != "*"
+        ):  # Avoid adding glob if it's the default '*' which might behave differently
+            if tool_name == "rg":
+                cmd_args.extend(["-g", file_pattern])
+            elif tool_name == "ag":
+                cmd_args.extend(["-G", file_pattern])
+            elif tool_name == "grep":
+                # grep needs recursive flag when filtering
+                cmd_args.append("-r")
+                cmd_args.append(f"--include={file_pattern}")
+        elif tool_name == "grep":
+            # grep needs recursive flag even without include filter
+            cmd_args.append("-r")
+
+        # Directory exclusion (rg and ag respect .gitignore/.git by default)
+        if tool_name == "grep":
+            cmd_args.append("--exclude-dir=.git")
+
+        # Add pattern and directory path
+        cmd_args.extend([pattern, str(search_dir_path)])
+
+        # Convert list to command string for run_cmd_subprocess
+        command_string = shlex.join(cmd_args)
+
+        coder.io.tool_output(f"⚙️ Executing {tool_name}: {command_string}")
+
+        # Use run_cmd_subprocess for execution
+        # Note: rg, ag, and grep return 1 if no matches are found, which is not an error for this tool.
+        exit_status, combined_output = run_cmd_subprocess(
+            command_string, verbose=coder.verbose, cwd=coder.root  # Execute in the project root
+        )
+
+        # Format the output for the result message
+        output_content = combined_output or ""
+
+        # Handle exit codes (consistent across rg, ag, grep)
+        if exit_status == 0:
+            # Limit output size if necessary
+            max_output_lines = 50  # Consider making this configurable
+            output_lines = output_content.splitlines()
+            if len(output_lines) > max_output_lines:
+                truncated_output = "\n".join(output_lines[:max_output_lines])
+                result_message = (
+                    f"Found matches (truncated):\n```text\n{truncated_output}\n..."
+                    f" ({len(output_lines) - max_output_lines} more lines)\n```"
+                )
+            elif not output_content:
+                # Should not happen if return code is 0, but handle defensively
+                coder.io.tool_warning(f"{tool_name} returned 0 but produced no output.")
+                result_message = "No matches found (unexpected)."
+            else:
+                result_message = f"Found matches:\n```text\n{output_content}\n```"
+            return result_message
+
+        elif exit_status == 1:
+            # Exit code 1 means no matches found - this is expected behavior, not an error.
+            return "No matches found."
+        else:
+            # Exit code > 1 indicates an actual error
+            error_message = f"{tool_name.capitalize()} command failed with exit code {exit_status}."
+            if output_content:
+                # Truncate error output as well if it's too long
+                error_limit = 1000  # Example limit for error output
+                if len(output_content) > error_limit:
+                    output_content = output_content[:error_limit] + "\n... (error output truncated)"
+                error_message += f" Output:\n{output_content}"
+            coder.io.tool_error(error_message)
+            return f"Error: {error_message}"
+
+    except Exception as e:
+        # Add command_string to the error message if it's defined
+        cmd_str_info = f"'{command_string}' " if "command_string" in locals() else ""
+        coder.io.tool_error(f"Error executing {tool_name} command {cmd_str_info}: {str(e)}")
+        return f"Error executing {tool_name}: {str(e)}"

aider/tools/indent_lines.py

@@ -0,0 +1,155 @@
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    determine_line_range,
+    find_pattern_indices,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    select_occurrence_index,
+    validate_file_for_edit,
+)
+
+
+def _execute_indent_lines(
+    coder,
+    file_path,
+    start_pattern,
+    end_pattern=None,
+    line_count=None,
+    indent_levels=1,
+    near_context=None,
+    occurrence=1,
+    change_id=None,
+    dry_run=False,
+):
+    """
+    Indent or unindent a block of lines in a file using utility functions.
+
+    Parameters:
+    - coder: The Coder instance
+    - file_path: Path to the file to modify
+    - start_pattern: Pattern marking the start of the block to indent (line containing this pattern)
+    - end_pattern: Optional pattern marking the end of the block (line containing this pattern)
+    - line_count: Optional number of lines to indent (alternative to end_pattern)
+    - indent_levels: Number of levels to indent (positive) or unindent (negative)
+    - near_context: Optional text nearby to help locate the correct instance of the start_pattern
+    - occurrence: Which occurrence of the start_pattern to use (1-based index, or -1 for last)
+    - 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 = "IndentLines"
+    try:
+        # 1. Validate file and get content
+        abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+        lines = original_content.splitlines()
+
+        # 2. Find the start line
+        pattern_desc = f"Start pattern '{start_pattern}'"
+        if near_context:
+            pattern_desc += f" near context '{near_context}'"
+        start_pattern_indices = find_pattern_indices(lines, start_pattern, near_context)
+        start_line_idx = select_occurrence_index(start_pattern_indices, occurrence, pattern_desc)
+
+        # 3. Determine the end line
+        start_line, end_line = determine_line_range(
+            coder=coder,
+            file_path=rel_path,
+            lines=lines,
+            start_pattern_line_index=start_line_idx,
+            end_pattern=end_pattern,
+            line_count=line_count,
+            target_symbol=None,  # IndentLines uses patterns, not symbols
+            pattern_desc=pattern_desc,
+        )
+
+        # 4. Validate and prepare indentation
+        try:
+            indent_levels = int(indent_levels)
+        except ValueError:
+            raise ToolError(f"Invalid indent_levels value: '{indent_levels}'. Must be an integer.")
+
+        indent_str = " " * 4  # Assume 4 spaces per level
+        modified_lines = list(lines)
+
+        # Apply indentation logic (core logic remains)
+        for i in range(start_line, end_line + 1):
+            if indent_levels > 0:
+                modified_lines[i] = (indent_str * indent_levels) + modified_lines[i]
+            elif indent_levels < 0:
+                spaces_to_remove = abs(indent_levels) * len(indent_str)
+                current_leading_spaces = len(modified_lines[i]) - len(modified_lines[i].lstrip(" "))
+                actual_remove = min(spaces_to_remove, current_leading_spaces)
+                if actual_remove > 0:
+                    modified_lines[i] = modified_lines[i][actual_remove:]
+
+        new_content = "\n".join(modified_lines)
+
+        if original_content == new_content:
+            coder.io.tool_warning("No changes made: indentation would not change file")
+            return "Warning: No changes made (indentation would not change file)"
+
+        # 5. Generate diff for feedback
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+        num_occurrences = len(start_pattern_indices)
+        occurrence_str = f"occurrence {occurrence} of " if num_occurrences > 1 else ""
+        action = "indent" if indent_levels > 0 else "unindent"
+        levels = abs(indent_levels)
+        level_text = "level" if levels == 1 else "levels"
+        num_lines = end_line - start_line + 1
+
+        # 6. Handle dry run
+        if dry_run:
+            dry_run_message = (
+                f"Dry run: Would {action} {num_lines} lines ({start_line + 1}-{end_line + 1}) by"
+                f" {levels} {level_text} (based on {occurrence_str}start pattern '{start_pattern}')"
+                f" 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_line": start_line + 1,
+            "end_line": end_line + 1,
+            "start_pattern": start_pattern,
+            "end_pattern": end_pattern,
+            "line_count": line_count,
+            "indent_levels": indent_levels,
+            "near_context": near_context,
+            "occurrence": occurrence,
+        }
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "indentlines",
+            metadata,
+            change_id,
+        )
+
+        # 8. Format and return result
+        action_past = "Indented" if indent_levels > 0 else "Unindented"
+        success_message = (
+            f"{action_past} {num_lines} lines by {levels} {level_text} (from {occurrence_str}start"
+            f" pattern) 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)