aider-ce 0.88.20__py3-none-any.whl

aider/tools/command_interactive.py

@@ -0,0 +1,122 @@
+# Import necessary functions
+import asyncio
+
+from aider.run_cmd import run_cmd
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "CommandInteractive",
+        "description": "Execute a shell command interactively.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command_string": {
+                    "type": "string",
+                    "description": "The interactive shell command to execute.",
+                },
+            },
+            "required": ["command_string"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "commandinteractive"
+
+
+async def _execute_command_interactive(coder, command_string):
+    """
+    Execute an interactive shell command using run_cmd (which uses pexpect/PTY).
+    """
+    try:
+        confirmed = (
+            True
+            if coder.skip_cli_confirmations
+            else await coder.io.confirm_ask(
+                "Allow execution of this command?",
+                subject=command_string,
+                explicit_yes_required=True,  # Require explicit 'yes' or 'always'
+                allow_never=True,  # Enable the 'Always' option
+                group_response="Command Interactive Tool",
+            )
+        )
+
+        if not confirmed:
+            # This happens if the user explicitly says 'no' this time.
+            # If 'Always' was chosen previously, confirm_ask returns True directly.
+            coder.io.tool_output(f"Skipped execution of shell command: {command_string}")
+            return "Shell command execution skipped by user."
+
+        coder.io.tool_output(f"⚙️ Starting interactive shell command: {command_string}")
+        coder.io.tool_output(">>> You may need to interact with the command below <<<")
+        coder.io.tool_output(" \n")
+
+        await coder.io.cancel_input_task()
+        await asyncio.sleep(1)
+
+        # Use run_cmd which handles PTY logic
+        exit_status, combined_output = run_cmd(
+            command_string,
+            verbose=coder.verbose,  # Pass verbose flag
+            error_print=coder.io.tool_error,  # Use io for error printing
+            cwd=coder.root,  # Execute in the project root
+        )
+
+        await asyncio.sleep(1)
+
+        coder.io.tool_output(" \n")
+        coder.io.tool_output(" \n")
+        coder.io.tool_output(">>> Interactive command finished <<<")
+
+        await coder.io.recreate_input()
+
+        # Format the output for the result message, include more content
+        output_content = combined_output or ""
+        # Use the existing token threshold constant as the character limit for truncation
+        output_limit = coder.large_file_token_threshold
+        if len(output_content) > output_limit:
+            # Truncate and add a clear message using the constant value
+            output_content = (
+                output_content[:output_limit]
+                + f"\n... (output truncated at {output_limit} characters, based on"
+                " large_file_token_threshold)"
+            )
+
+        if exit_status == 0:
+            return (
+                "Interactive command finished successfully (exit code 0)."
+                f" Output:\n{output_content}"
+            )
+        else:
+            return (
+                f"Interactive command finished with exit code {exit_status}."
+                f" Output:\n{output_content}"
+            )
+
+    except Exception as e:
+        coder.io.tool_error(
+            f"Error executing interactive shell command '{command_string}': {str(e)}"
+        )
+        # Optionally include traceback for debugging if verbose
+        # if coder.verbose:
+        #     coder.io.tool_error(traceback.format_exc())
+        return f"Error executing interactive command: {str(e)}"
+
+
+async def process_response(coder, params):
+    """
+    Process the CommandInteractive tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    command_string = params.get("command_string")
+    if command_string is not None:
+        return await _execute_command_interactive(coder, command_string)
+    else:
+        return "Error: Missing 'command_string' parameter for CommandInteractive"

aider/tools/delete_block.py

@@ -0,0 +1,182 @@
+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,
+)
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "DeleteBlock",
+        "description": "Delete a block of lines from a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "start_pattern": {"type": "string"},
+                "end_pattern": {"type": "string"},
+                "line_count": {"type": "integer"},
+                "near_context": {"type": "string"},
+                "occurrence": {"type": "integer", "default": 1},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "start_pattern"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "deleteblock"
+
+
+def _execute_delete_block(
+    coder,
+    file_path,
+    start_pattern,
+    end_pattern=None,
+    line_count=None,
+    near_context=None,
+    occurrence=1,
+    change_id=None,
+    dry_run=False,
+):
+    """
+    Delete a block of text between start_pattern and end_pattern (inclusive).
+    Uses utility functions for validation, finding lines, and applying changes.
+    """
+    tool_name = "DeleteBlock"
+    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, passing pattern_desc for better error messages
+        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,  # DeleteBlock uses patterns, not symbols
+            pattern_desc=pattern_desc,
+        )
+
+        # 4. Prepare the deletion
+        deleted_lines = lines[start_line : end_line + 1]
+        new_lines = lines[:start_line] + lines[end_line + 1 :]
+        new_content = "\n".join(new_lines)
+
+        if original_content == new_content:
+            coder.io.tool_warning("No changes made: deletion would not change file")
+            return "Warning: No changes made (deletion would not change file)"
+
+        # 5. Generate diff for feedback
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+        num_deleted = end_line - start_line + 1
+        num_occurrences = len(start_pattern_indices)
+        occurrence_str = f"occurrence {occurrence} of " if num_occurrences > 1 else ""
+
+        # 6. Handle dry run
+        if dry_run:
+            dry_run_message = (
+                f"Dry run: Would delete {num_deleted} lines ({start_line + 1}-{end_line + 1}) based"
+                f" on {occurrence_str}start pattern '{start_pattern}' 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,
+            "near_context": near_context,
+            "occurrence": occurrence,
+            "deleted_content": "\n".join(deleted_lines),
+        }
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "deleteblock",
+            metadata,
+            change_id,
+        )
+
+        coder.files_edited_by_tools.add(rel_path)
+        # 8. Format and return result, adding line range to success message
+        success_message = (
+            f"Deleted {num_deleted} lines ({start_line + 1}-{end_line + 1}) (from"
+            f" {occurrence_str}start 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)
+
+
+def process_response(coder, params):
+    """
+    Process the DeleteBlock tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    file_path = params.get("file_path")
+    start_pattern = params.get("start_pattern")
+    end_pattern = params.get("end_pattern")
+    line_count = params.get("line_count")
+    near_context = params.get("near_context")
+    occurrence = params.get("occurrence", 1)
+    change_id = params.get("change_id")
+    dry_run = params.get("dry_run", False)
+
+    if file_path is not None and start_pattern is not None:
+        return _execute_delete_block(
+            coder,
+            file_path,
+            start_pattern,
+            end_pattern,
+            line_count,
+            near_context,
+            occurrence,
+            change_id,
+            dry_run,
+        )
+    else:
+        return "Error: Missing required parameters for DeleteBlock (file_path, start_pattern)"

aider/tools/delete_line.py

@@ -0,0 +1,155 @@
+import os
+
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+)
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "DeleteLine",
+        "description": "Delete a single line from a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "line_number": {"type": "integer"},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "line_number"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "deleteline"
+
+
+def _execute_delete_line(coder, file_path, line_number, change_id=None, dry_run=False):
+    """
+    Delete a specific line number (1-based).
+
+    Parameters:
+    - coder: The Coder instance
+    - file_path: Path to the file to modify
+    - line_number: The 1-based line number to delete
+    - 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 = "DeleteLine"
+    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}'")
+
+        lines = file_content.splitlines()
+        original_content = file_content
+
+        # Validate line number
+        try:
+            line_num_int = int(line_number)
+            if line_num_int < 1 or line_num_int > len(lines):
+                raise ToolError(f"Line number {line_num_int} is out of range (1-{len(lines)})")
+            line_idx = line_num_int - 1  # Convert to 0-based index
+        except ValueError:
+            raise ToolError(f"Invalid line_number value: '{line_number}'. Must be an integer.")
+
+        # Prepare the deletion
+        deleted_line = lines[line_idx]
+        new_lines = lines[:line_idx] + lines[line_idx + 1 :]
+        new_content = "\n".join(new_lines)
+
+        if original_content == new_content:
+            coder.io.tool_warning(
+                f"No changes made: deleting line {line_num_int} would not change file"
+            )
+            return f"Warning: No changes made (deleting line {line_num_int} would not change file)"
+
+        # Generate diff snippet
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+
+        # Handle dry run
+        if dry_run:
+            dry_run_message = f"Dry run: Would delete line {line_num_int} 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 = {"line_number": line_num_int, "deleted_content": deleted_line}
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "deleteline",
+            metadata,
+            change_id,
+        )
+
+        coder.files_edited_by_tools.add(rel_path)
+
+        # Format and return result
+        success_message = f"Deleted line {line_num_int} 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 DeleteLine 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")
+    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:
+        return _execute_delete_line(coder, file_path, line_number, change_id, dry_run)
+    else:
+        return "Error: Missing required parameters for DeleteLine (file_path, line_number)"

aider/tools/delete_lines.py

@@ -0,0 +1,184 @@
+import os
+
+from .tool_utils import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+)
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "DeleteLines",
+        "description": "Delete a range of lines from a file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "start_line": {"type": "integer"},
+                "end_line": {"type": "integer"},
+                "change_id": {"type": "string"},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["file_path", "start_line", "end_line"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "deletelines"
+
+
+def _execute_delete_lines(coder, file_path, start_line, end_line, change_id=None, dry_run=False):
+    """
+    Delete a range of lines (1-based, inclusive).
+
+    Parameters:
+    - coder: The Coder instance
+    - file_path: Path to the file to modify
+    - start_line: The 1-based starting line number to delete
+    - end_line: The 1-based ending line number to delete
+    - 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 = "DeleteLines"
+    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}'")
+
+        lines = file_content.splitlines()
+        original_content = file_content
+
+        # Validate line numbers
+        try:
+            start_line_int = int(start_line)
+            end_line_int = int(end_line)
+
+            if start_line_int < 1 or start_line_int > len(lines):
+                raise ToolError(f"Start line {start_line_int} is out of range (1-{len(lines)})")
+            if end_line_int < 1 or end_line_int > len(lines):
+                raise ToolError(f"End line {end_line_int} is out of range (1-{len(lines)})")
+            if start_line_int > end_line_int:
+                raise ToolError(
+                    f"Start line {start_line_int} cannot be after end line {end_line_int}"
+                )
+
+            start_idx = start_line_int - 1  # Convert to 0-based index
+            end_idx = end_line_int - 1  # Convert to 0-based index
+        except ValueError:
+            raise ToolError(
+                f"Invalid line numbers: '{start_line}', '{end_line}'. Must be integers."
+            )
+
+        # Prepare the deletion
+        deleted_lines = lines[start_idx : end_idx + 1]
+        new_lines = lines[:start_idx] + lines[end_idx + 1 :]
+        new_content = "\n".join(new_lines)
+
+        if original_content == new_content:
+            coder.io.tool_warning(
+                f"No changes made: deleting lines {start_line_int}-{end_line_int} would not change"
+                " file"
+            )
+            return (
+                f"Warning: No changes made (deleting lines {start_line_int}-{end_line_int} would"
+                " not change file)"
+            )
+
+        # Generate diff snippet
+        diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+
+        # Handle dry run
+        if dry_run:
+            dry_run_message = (
+                f"Dry run: Would delete lines {start_line_int}-{end_line_int} 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_int,
+            "end_line": end_line_int,
+            "deleted_content": "\n".join(deleted_lines),
+        }
+
+        final_change_id = apply_change(
+            coder,
+            abs_path,
+            rel_path,
+            original_content,
+            new_content,
+            "deletelines",
+            metadata,
+            change_id,
+        )
+
+        coder.files_edited_by_tools.add(rel_path)
+        num_deleted = end_idx - start_idx + 1
+        # Format and return result
+        success_message = (
+            f"Deleted {num_deleted} lines ({start_line_int}-{end_line_int}) 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 DeleteLines 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")
+    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:
+        return _execute_delete_lines(coder, file_path, start_line, end_line, change_id, dry_run)
+    else:
+        return (
+            "Error: Missing required parameters for DeleteLines (file_path, start_line, end_line)"
+        )