aider-ce 0.87.13__py3-none-any.whl → 0.88.0__py3-none-any.whl

aider/sendchat.py

@@ -6,13 +6,52 @@ def sanity_check_messages(messages):
     """Check if messages alternate between user and assistant roles.
     System messages can be interspersed anywhere.
     Also verifies the last non-system message is from the user.
+    Validates tool message sequences.
     Returns True if valid, False otherwise."""
     last_role = None
     last_non_system_role = None
+    i = 0
+    n = len(messages)
 
-    for msg in messages:
+    while i < n:
+        msg = messages[i]
         role = msg.get("role")
+
+        # Handle tool sequences atomically
+        if role == "assistant" and "tool_calls" in msg and msg["tool_calls"]:
+            # Validate tool sequence
+            expected_ids = {call["id"] for call in msg["tool_calls"]}
+            i += 1
+
+            # Check for tool responses
+            while i < n and expected_ids:
+                next_msg = messages[i]
+                if next_msg.get("role") == "tool" and next_msg.get("tool_call_id") in expected_ids:
+                    expected_ids.discard(next_msg.get("tool_call_id"))
+                    i += 1
+                else:
+                    break
+
+            # If we still have expected IDs, the tool sequence is incomplete
+            if expected_ids:
+                turns = format_messages(messages)
+                raise ValueError(
+                    "Incomplete tool sequence - missing responses for tool calls:\n\n" + turns
+                )
+
+            # Continue to next message after tool sequence
+            continue
+
+        elif role == "tool":
+            # Orphaned tool message without preceding assistant tool_calls
+            turns = format_messages(messages)
+            raise ValueError(
+                "Orphaned tool message without preceding assistant tool_calls:\n\n" + turns
+            )
+
+        # Handle normal role alternation
         if role == "system":
+            i += 1
             continue
 
         if last_role and role == last_role:
@@ -21,16 +60,84 @@ def sanity_check_messages(messages):
 
         last_role = role
         last_non_system_role = role
+        i += 1
 
     # Ensure last non-system message is from user
     return last_non_system_role == "user"
 
 
+def clean_orphaned_tool_messages(messages):
+    """Remove orphaned tool messages and incomplete tool sequences.
+
+    This function removes:
+    - Tool messages without a preceding assistant message containing tool_calls
+    - Assistant messages with tool_calls that don't have complete tool responses
+
+    Args:
+        messages: List of message dictionaries
+
+    Returns:
+        Cleaned list of messages with orphaned tool sequences removed
+    """
+    if not messages:
+        return messages
+
+    cleaned = []
+    i = 0
+    n = len(messages)
+
+    while i < n:
+        msg = messages[i]
+        role = msg.get("role")
+
+        # If it's an assistant message with tool_calls, check if we have complete responses
+        if role == "assistant" and "tool_calls" in msg and msg["tool_calls"]:
+            # Start of potential tool sequence
+            tool_sequence = [msg]
+            expected_ids = {call["id"] for call in msg["tool_calls"]}
+            j = i + 1
+
+            # Collect tool responses
+            while j < n and expected_ids:
+                next_msg = messages[j]
+                if next_msg.get("role") == "tool" and next_msg.get("tool_call_id") in expected_ids:
+                    tool_sequence.append(next_msg)
+                    expected_ids.discard(next_msg.get("tool_call_id"))
+                    j += 1
+                else:
+                    break
+
+            # If we have all tool responses, keep the sequence
+            if not expected_ids:
+                cleaned.extend(tool_sequence)
+                i = j
+            else:
+                # Incomplete sequence - skip the entire tool sequence
+                i = j
+                # Don't add anything to cleaned
+                continue
+
+        elif role == "tool":
+            # Orphaned tool message without preceding assistant tool_calls - skip it
+            i += 1
+            continue
+        else:
+            # Regular message - add it
+            cleaned.append(msg)
+            i += 1
+
+    return cleaned
+
+
 def ensure_alternating_roles(messages):
     """Ensure messages alternate between 'assistant' and 'user' roles.
 
     Inserts empty messages of the opposite role when consecutive messages
-    of the same role are found.
+    of the same 'user' or 'assistant' role are found. Messages with other
+    roles (e.g. 'system', 'tool') are ignored by the alternation logic.
+
+    Also handles tool call sequences properly - when an assistant message
+    contains tool_calls, processes the complete tool sequence atomically.
 
     Args:
         messages: List of message dictionaries with 'role' and 'content' keys.
@@ -41,21 +148,84 @@ def ensure_alternating_roles(messages):
     if not messages:
         return messages
 
-    fixed_messages = []
+    # First clean orphaned tool messages
+    messages = clean_orphaned_tool_messages(messages)
+
+    result = []
+    i = 0
+    n = len(messages)
     prev_role = None
 
-    for msg in messages:
-        current_role = msg.get("role")  # Get 'role', None if missing
+    while i < n:
+        msg = messages[i]
+        role = msg.get("role")
 
-        # If current role same as previous, insert empty message
-        # of the opposite role
-        if current_role == prev_role:
-            if current_role == "user":
-                fixed_messages.append({"role": "assistant", "content": ""})
-            else:
-                fixed_messages.append({"role": "user", "content": ""})
+        # Handle tool call sequences atomically
+        if role == "assistant" and "tool_calls" in msg and msg["tool_calls"]:
+            # Start of tool sequence - collect all related messages
+            tool_sequence = [msg]
+            expected_ids = {call["id"] for call in msg["tool_calls"]}
+            i += 1
+
+            # Collect tool responses
+            while i < n and expected_ids:
+                next_msg = messages[i]
+                if next_msg.get("role") == "tool" and next_msg.get("tool_call_id") in expected_ids:
+                    tool_sequence.append(next_msg)
+                    expected_ids.discard(next_msg.get("tool_call_id"))
+                    i += 1
+                else:
+                    break
+
+            # Add missing tool responses as empty
+            for tool_id in expected_ids:
+                tool_sequence.append({"role": "tool", "tool_call_id": tool_id, "content": ""})
+
+            # Add the complete tool sequence to result
+            for tool_msg in tool_sequence:
+                result.append(tool_msg)
+
+            # Update prev_role to assistant after processing tool sequence
+            prev_role = "assistant"
+            continue
+
+        # Handle normal message alternation
+        if role in ("user", "assistant"):
+            if role == prev_role:
+                # Insert empty message of opposite role
+                opposite_role = "user" if role == "assistant" else "assistant"
+                result.append({"role": opposite_role, "content": ""})
+                prev_role = opposite_role
+
+            result.append(msg)
+            prev_role = role
+        else:
+            # For non-user/assistant roles, just add them directly
+            result.append(msg)
+
+        i += 1
+
+    # Consolidate consecutive empty messages in a single pass
+    consolidated = []
+    for msg in result:
+        if not consolidated:
+            consolidated.append(msg)
+            continue
+
+        last_msg = consolidated[-1]
+        current_role = msg.get("role")
+        last_role = last_msg.get("role")
+
+        # Skip consecutive empty messages with the same role
+        if (
+            current_role in ("user", "assistant")
+            and last_role in ("user", "assistant")
+            and current_role == last_role
+            and msg.get("content") == ""
+            and last_msg.get("content") == ""
+        ):
+            continue
 
-        fixed_messages.append(msg)
-        prev_role = current_role
+        consolidated.append(msg)
 
-    return fixed_messages
+    return consolidated

aider/tools/__init__.py

@@ -1,26 +1,47 @@
 # flake8: noqa: F401
 # Import tool functions into the aider.tools namespace
 
-from .command import _execute_command
-from .command_interactive import _execute_command_interactive
-from .delete_block import _execute_delete_block
-from .delete_line import _execute_delete_line
-from .delete_lines import _execute_delete_lines
-from .extract_lines import _execute_extract_lines
-from .indent_lines import _execute_indent_lines
-from .insert_block import _execute_insert_block
-from .list_changes import _execute_list_changes
-from .ls import execute_ls
-from .make_editable import _execute_make_editable
-from .make_readonly import _execute_make_readonly
-from .remove import _execute_remove
-from .replace_all import _execute_replace_all
-from .replace_line import _execute_replace_line
-from .replace_lines import _execute_replace_lines
-from .replace_text import _execute_replace_text
-from .show_numbered_context import execute_show_numbered_context
-from .undo_change import _execute_undo_change
-from .view import execute_view
-from .view_files_at_glob import execute_view_files_at_glob
-from .view_files_matching import execute_view_files_matching
-from .view_files_with_symbol import _execute_view_files_with_symbol
+from .command import _execute_command, command_schema
+from .command_interactive import (
+    _execute_command_interactive,
+    command_interactive_schema,
+)
+from .delete_block import _execute_delete_block, delete_block_schema
+from .delete_line import _execute_delete_line, delete_line_schema
+from .delete_lines import _execute_delete_lines, delete_lines_schema
+from .extract_lines import _execute_extract_lines, extract_lines_schema
+from .git import (
+    _execute_git_diff,
+    _execute_git_log,
+    _execute_git_show,
+    _execute_git_status,
+    git_diff_schema,
+    git_log_schema,
+    git_show_schema,
+    git_status_schema,
+)
+from .grep import _execute_grep, grep_schema
+from .indent_lines import _execute_indent_lines, indent_lines_schema
+from .insert_block import _execute_insert_block, insert_block_schema
+from .list_changes import _execute_list_changes, list_changes_schema
+from .ls import execute_ls, ls_schema
+from .make_editable import _execute_make_editable, make_editable_schema
+from .make_readonly import _execute_make_readonly, make_readonly_schema
+from .remove import _execute_remove, remove_schema
+from .replace_all import _execute_replace_all, replace_all_schema
+from .replace_line import _execute_replace_line, replace_line_schema
+from .replace_lines import _execute_replace_lines, replace_lines_schema
+from .replace_text import _execute_replace_text, replace_text_schema
+from .show_numbered_context import (
+    execute_show_numbered_context,
+    show_numbered_context_schema,
+)
+from .undo_change import _execute_undo_change, undo_change_schema
+from .update_todo_list import _execute_update_todo_list, update_todo_list_schema
+from .view import execute_view, view_schema
+from .view_files_at_glob import execute_view_files_at_glob, view_files_at_glob_schema
+from .view_files_matching import execute_view_files_matching, view_files_matching_schema
+from .view_files_with_symbol import (
+    _execute_view_files_with_symbol,
+    view_files_with_symbol_schema,
+)

aider/tools/command.py

@@ -1,6 +1,24 @@
 # Import necessary functions
 from aider.run_cmd import run_cmd_subprocess
 
+command_schema = {
+    "type": "function",
+    "function": {
+        "name": "Command",
+        "description": "Execute a shell command.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command_string": {
+                    "type": "string",
+                    "description": "The shell command to execute.",
+                },
+            },
+            "required": ["command_string"],
+        },
+    },
+}
+
 
 def _execute_command(coder, command_string):
     """

aider/tools/command_interactive.py

@@ -1,6 +1,24 @@
 # Import necessary functions
 from aider.run_cmd import run_cmd
 
+command_interactive_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"],
+        },
+    },
+}
+
 
 def _execute_command_interactive(coder, command_string):
     """

aider/tools/delete_block.py

@@ -10,6 +10,28 @@ from .tool_utils import (
     validate_file_for_edit,
 )
 
+delete_block_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"],
+        },
+    },
+}
+
 
 def _execute_delete_block(
     coder,
@@ -103,6 +125,7 @@ def _execute_delete_block(
             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"

aider/tools/delete_line.py

@@ -8,6 +8,24 @@ from .tool_utils import (
     handle_tool_error,
 )
 
+delete_line_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"],
+        },
+    },
+}
+
 
 def _execute_delete_line(coder, file_path, line_number, change_id=None, dry_run=False):
     """
@@ -96,7 +114,7 @@ def _execute_delete_line(coder, file_path, line_number, change_id=None, dry_run=
             change_id,
         )
 
-        coder.aider_edited_files.add(rel_path)
+        coder.files_edited_by_tools.add(rel_path)
 
         # Format and return result
         success_message = f"Deleted line {line_num_int} in {file_path}"

aider/tools/delete_lines.py

@@ -8,6 +8,25 @@ from .tool_utils import (
     handle_tool_error,
 )
 
+delete_lines_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"],
+        },
+    },
+}
+
 
 def _execute_delete_lines(coder, file_path, start_line, end_line, change_id=None, dry_run=False):
     """
@@ -119,7 +138,7 @@ def _execute_delete_lines(coder, file_path, start_line, end_line, change_id=None
             change_id,
         )
 
-        coder.aider_edited_files.add(rel_path)
+        coder.files_edited_by_tools.add(rel_path)
         num_deleted = end_idx - start_idx + 1
         # Format and return result
         success_message = (

aider/tools/extract_lines.py

@@ -3,6 +3,28 @@ import traceback
 
 from .tool_utils import generate_unified_diff_snippet
 
+extract_lines_schema = {
+    "type": "function",
+    "function": {
+        "name": "ExtractLines",
+        "description": "Extract lines from a source file and append them to a target file.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "source_file_path": {"type": "string"},
+                "target_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},
+                "dry_run": {"type": "boolean", "default": False},
+            },
+            "required": ["source_file_path", "target_file_path", "start_pattern"],
+        },
+    },
+}
+
 
 def _execute_extract_lines(
     coder,
@@ -248,8 +270,9 @@ def _execute_extract_lines(
             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)
+        coder.files_edited_by_tools.add(rel_source_path)
+        coder.files_edited_by_tools.add(rel_target_path)
+
         if not target_exists:
             # Add the newly created file to editable context
             coder.abs_fnames.add(abs_target_path)

aider/tools/git.py

@@ -0,0 +1,142 @@
+from aider.repo import ANY_GIT_ERROR
+
+git_diff_schema = {
+    "type": "function",
+    "function": {
+        "name": "git_diff",
+        "description": (
+            "Show the diff between the current working directory and a git branch or commit."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "branch": {
+                    "type": "string",
+                    "description": "The branch or commit hash to diff against. Defaults to HEAD.",
+                },
+            },
+            "required": [],
+        },
+    },
+}
+
+
+def _execute_git_diff(coder, branch=None):
+    """
+    Show the diff between the current working directory and a git branch or commit.
+    """
+    if not coder.repo:
+        return "Not in a git repository."
+
+    try:
+        if branch:
+            diff = coder.repo.diff_commits(False, branch, "HEAD")
+        else:
+            diff = coder.repo.diff_commits(False, "HEAD", None)
+
+        if not diff:
+            return "No differences found."
+        return diff
+    except ANY_GIT_ERROR as e:
+        coder.io.tool_error(f"Error running git diff: {e}")
+        return f"Error running git diff: {e}"
+
+
+git_log_schema = {
+    "type": "function",
+    "function": {
+        "name": "git_log",
+        "description": "Show the git log.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "The maximum number of commits to show. Defaults to 10.",
+                },
+            },
+            "required": [],
+        },
+    },
+}
+
+
+def _execute_git_log(coder, limit=10):
+    """
+    Show the git log.
+    """
+    if not coder.repo:
+        return "Not in a git repository."
+
+    try:
+        commits = list(coder.repo.repo.iter_commits(max_count=limit))
+        log_output = []
+        for commit in commits:
+            short_hash = commit.hexsha[:8]
+            message = commit.message.strip().split("\n")[0]
+            log_output.append(f"{short_hash} {message}")
+        return "\n".join(log_output)
+    except ANY_GIT_ERROR as e:
+        coder.io.tool_error(f"Error running git log: {e}")
+        return f"Error running git log: {e}"
+
+
+git_show_schema = {
+    "type": "function",
+    "function": {
+        "name": "git_show",
+        "description": "Show various types of objects (blobs, trees, tags, and commits).",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "object": {
+                    "type": "string",
+                    "description": "The object to show. Defaults to HEAD.",
+                },
+            },
+            "required": [],
+        },
+    },
+}
+
+
+def _execute_git_show(coder, object="HEAD"):
+    """
+    Show various types of objects (blobs, trees, tags, and commits).
+    """
+    if not coder.repo:
+        return "Not in a git repository."
+
+    try:
+        return coder.repo.repo.git.show(object)
+    except ANY_GIT_ERROR as e:
+        coder.io.tool_error(f"Error running git show: {e}")
+        return f"Error running git show: {e}"
+
+
+git_status_schema = {
+    "type": "function",
+    "function": {
+        "name": "git_status",
+        "description": "Show the working tree status.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        },
+    },
+}
+
+
+def _execute_git_status(coder):
+    """
+    Show the working tree status.
+    """
+    if not coder.repo:
+        return "Not in a git repository."
+
+    try:
+        return coder.repo.repo.git.status()
+    except ANY_GIT_ERROR as e:
+        coder.io.tool_error(f"Error running git status: {e}")
+        return f"Error running git status: {e}"