aider-ce 0.88.20__py3-none-any.whl → 0.88.38__py3-none-any.whl

aider/tools/thinking.py

@@ -0,0 +1,52 @@
+import json
+
+from aider.tools.utils.base_tool import BaseTool
+from aider.tools.utils.output import color_markers, tool_footer, tool_header
+
+
+class Tool(BaseTool):
+    NORM_NAME = "thinking"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "Thinking",
+            "description": (
+                "Use this tool to store useful facts for later "
+                "keep a scratch pad of your current efforts "
+                "and clarify your thoughts and intentions for your next steps."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "content": {
+                        "type": "string",
+                        "description": "Textual information to record in the context",
+                    },
+                },
+                "required": ["content"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, content):
+        """
+        A place to allow the model to record freeform text as it
+        iterates over tools to ideally help it guide itself to a proper solution
+        """
+        coder.io.tool_output("🧠 Thoughts recorded in context")
+        return content
+
+    @classmethod
+    def format_output(cls, coder, mcp_server, tool_response):
+        color_start, color_end = color_markers(coder)
+        params = json.loads(tool_response.function.arguments)
+
+        tool_header(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+
+        coder.io.tool_output("")
+        coder.io.tool_output(f"{color_start}Thoughts:{color_end}")
+        coder.io.tool_output(params["content"])
+        coder.io.tool_output("")
+
+        tool_footer(coder=coder, tool_response=tool_response)

aider/tools/undo_change.py

@@ -1,95 +1,82 @@
 import traceback
 
-schema = {
-    "type": "function",
-    "function": {
-        "name": "UndoChange",
-        "description": "Undo a previously applied change.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "change_id": {"type": "string"},
-                "file_path": {"type": "string"},
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "undochange"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "UndoChange",
+            "description": "Undo a previously applied change.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "change_id": {"type": "string"},
+                    "file_path": {"type": "string"},
+                },
             },
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "undochange"
-
-
-def _execute_undo_change(coder, change_id=None, file_path=None):
-    """
-    Undo a specific change by ID, or the last change to a file.
-
-    Parameters:
-    - coder: The Coder instance
-    - change_id: ID of the change to undo
-    - file_path: Path to file where the last change should be undone
-
-    Returns a result message.
-    """
-    # Note: Undo does not have a dry_run parameter as it's inherently about reverting a previous action.
-    try:
-        # Validate parameters
-        if change_id is None and file_path is None:
-            coder.io.tool_error("Must specify either change_id or file_path for UndoChange")
-            return "Error: Must specify either change_id or file_path"
-
-        # If file_path is specified, get the most recent change for that file
-        if file_path:
-            abs_path = coder.abs_root_path(file_path)
-            rel_path = coder.get_rel_fname(abs_path)
-
-            change_id = coder.change_tracker.get_last_change(rel_path)
-            if not change_id:
-                coder.io.tool_error(f"No tracked changes found for file '{file_path}' to undo.")
-                return f"Error: No changes found for file '{file_path}'"
-
-        # Attempt to get undo information from the tracker
-        success, message, change_info = coder.change_tracker.undo_change(change_id)
-
-        if not success:
-            coder.io.tool_error(f"Failed to undo change '{change_id}': {message}")
-            return f"Error: {message}"
-
-        # Apply the undo by restoring the original content
-        if change_info:
-            file_path = change_info["file_path"]
-            abs_path = coder.abs_root_path(file_path)
-            # Write the original content back to the file
-            coder.io.write_text(abs_path, change_info["original"])
-            coder.aider_edited_files.add(file_path)  # Track that the file was modified by the undo
-
-            change_type = change_info["type"]
-            coder.io.tool_output(f"✅ Undid {change_type} change '{change_id}' in {file_path}")
-            return f"Successfully undid {change_type} change '{change_id}'."
-        else:
-            # This case should ideally not be reached if tracker returns success
-            coder.io.tool_error(
-                f"Failed to undo change '{change_id}': Change info missing after successful tracker"
-                " update."
-            )
-            return f"Error: Failed to undo change '{change_id}' (missing change info)"
-
-    except Exception as e:
-        coder.io.tool_error(f"Error in UndoChange: {str(e)}\n{traceback.format_exc()}")
-        return f"Error: {str(e)}"
-
-
-def process_response(coder, params):
-    """
-    Process the UndoChange tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    change_id = params.get("change_id")
-    file_path = params.get("file_path")
-
-    return _execute_undo_change(coder, change_id, file_path)
+    }
+
+    @classmethod
+    def execute(cls, coder, change_id=None, file_path=None):
+        """
+        Undo a specific change by ID, or the last change to a file.
+
+        Parameters:
+        - coder: The Coder instance
+        - change_id: ID of the change to undo
+        - file_path: Path to file where the last change should be undone
+
+        Returns a result message.
+        """
+        # Note: Undo does not have a dry_run parameter as it's inherently about reverting a previous action.
+        try:
+            # Validate parameters
+            if change_id is None and file_path is None:
+                coder.io.tool_error("Must specify either change_id or file_path for UndoChange")
+                return "Error: Must specify either change_id or file_path"
+
+            # If file_path is specified, get the most recent change for that file
+            if file_path:
+                abs_path = coder.abs_root_path(file_path)
+                rel_path = coder.get_rel_fname(abs_path)
+
+                change_id = coder.change_tracker.get_last_change(rel_path)
+                if not change_id:
+                    coder.io.tool_error(f"No tracked changes found for file '{file_path}' to undo.")
+                    return f"Error: No changes found for file '{file_path}'"
+
+            # Attempt to get undo information from the tracker
+            success, message, change_info = coder.change_tracker.undo_change(change_id)
+
+            if not success:
+                coder.io.tool_error(f"Failed to undo change '{change_id}': {message}")
+                return f"Error: {message}"
+
+            # Apply the undo by restoring the original content
+            if change_info:
+                file_path = change_info["file_path"]
+                abs_path = coder.abs_root_path(file_path)
+                # Write the original content back to the file
+                coder.io.write_text(abs_path, change_info["original"])
+                coder.aider_edited_files.add(
+                    file_path
+                )  # Track that the file was modified by the undo
+
+                change_type = change_info["type"]
+                coder.io.tool_output(f"✅ Undid {change_type} change '{change_id}' in {file_path}")
+                return f"Successfully undid {change_type} change '{change_id}'."
+            else:
+                # This case should ideally not be reached if tracker returns success
+                coder.io.tool_error(
+                    f"Failed to undo change '{change_id}': Change info missing after successful"
+                    " tracker update."
+                )
+                return f"Error: Failed to undo change '{change_id}' (missing change info)"
+
+        except Exception as e:
+            coder.io.tool_error(f"Error in UndoChange: {str(e)}\n{traceback.format_exc()}")
+            return f"Error: {str(e)}"

aider/tools/update_todo_list.py

@@ -1,156 +1,148 @@
-from .tool_utils import (
+from aider.tools.utils.base_tool import BaseTool
+from aider.tools.utils.helpers import (
     ToolError,
     format_tool_result,
     generate_unified_diff_snippet,
     handle_tool_error,
 )
-
-schema = {
-    "type": "function",
-    "function": {
-        "name": "UpdateTodoList",
-        "description": "Update the todo list with new items or modify existing ones.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "content": {
-                    "type": "string",
-                    "description": "The new content for the todo list.",
-                },
-                "append": {
-                    "type": "boolean",
-                    "description": (
-                        "Whether to append to existing content instead of replacing it. Defaults to"
-                        " False."
-                    ),
-                },
-                "change_id": {
-                    "type": "string",
-                    "description": "Optional change ID for tracking.",
-                },
-                "dry_run": {
-                    "type": "boolean",
-                    "description": (
-                        "Whether to perform a dry run without actually updating the file. Defaults"
-                        " to False."
-                    ),
+from aider.tools.utils.output import tool_body_unwrapped, tool_footer, tool_header
+
+
+class Tool(BaseTool):
+    NORM_NAME = "updatetodolist"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "UpdateTodoList",
+            "description": "Update the todo list with new items or modify existing ones.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "content": {
+                        "type": "string",
+                        "description": "The new content for the todo list.",
+                    },
+                    "append": {
+                        "type": "boolean",
+                        "description": (
+                            "Whether to append to existing content instead of replacing it."
+                            " Defaults to False."
+                        ),
+                    },
+                    "change_id": {
+                        "type": "string",
+                        "description": "Optional change ID for tracking.",
+                    },
+                    "dry_run": {
+                        "type": "boolean",
+                        "description": (
+                            "Whether to perform a dry run without actually updating the file."
+                            " Defaults to False."
+                        ),
+                    },
                 },
+                "required": ["content"],
             },
-            "required": ["content"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "updatetodolist"
-
-
-def _execute_update_todo_list(coder, content, append=False, change_id=None, dry_run=False):
-    """
-    Update the todo list file (.aider.todo.txt) with new content.
-    Can either replace the entire content or append to it.
-    """
-    tool_name = "UpdateTodoList"
-    try:
-        # Define the todo file path
-        todo_file_path = ".aider.todo.txt"
-        abs_path = coder.abs_root_path(todo_file_path)
-
-        # Get existing content if appending
-        existing_content = ""
-        import os
-
-        if os.path.isfile(abs_path):
-            existing_content = coder.io.read_text(abs_path) or ""
-
-        # Prepare new content
-        if append:
-            if existing_content and not existing_content.endswith("\n"):
-                existing_content += "\n"
-            new_content = existing_content + content
-        else:
-            new_content = content
-
-        # Check if content exceeds 4096 characters and warn
-        if len(new_content) > 4096:
-            coder.io.tool_warning(
-                "⚠️ Todo list content exceeds 4096 characters. Consider summarizing the plan before"
-                " proceeding."
+    }
+
+    @classmethod
+    def execute(cls, coder, content, append=False, change_id=None, dry_run=False):
+        """
+        Update the todo list file (.aider.todo.txt) with new content.
+        Can either replace the entire content or append to it.
+        """
+        tool_name = "UpdateTodoList"
+        try:
+            # Define the todo file path
+            todo_file_path = ".aider.todo.txt"
+            abs_path = coder.abs_root_path(todo_file_path)
+
+            # Get existing content if appending
+            existing_content = ""
+            import os
+
+            if os.path.isfile(abs_path):
+                existing_content = coder.io.read_text(abs_path) or ""
+
+            # Prepare new content
+            if append:
+                if existing_content and not existing_content.endswith("\n"):
+                    existing_content += "\n"
+                new_content = existing_content + content
+            else:
+                new_content = content
+
+            # Check if content exceeds 4096 characters and warn
+            if len(new_content) > 4096:
+                coder.io.tool_warning(
+                    "⚠️ Todo list content exceeds 4096 characters. Consider summarizing the plan"
+                    " before proceeding."
+                )
+
+            # Check if content actually changed
+            if existing_content == new_content:
+                coder.io.tool_warning("No changes made: new content is identical to existing")
+                return "Warning: No changes made (content identical to existing)"
+
+            # Generate diff for feedback
+            diff_snippet = generate_unified_diff_snippet(
+                existing_content, new_content, todo_file_path
             )
 
-        # Check if content actually changed
-        if existing_content == new_content:
-            coder.io.tool_warning("No changes made: new content is identical to existing")
-            return "Warning: No changes made (content identical to existing)"
+            # Handle dry run
+            if dry_run:
+                action = "append to" if append else "replace"
+                dry_run_message = f"Dry run: Would {action} todo list in {todo_file_path}."
+                return format_tool_result(
+                    coder,
+                    tool_name,
+                    "",
+                    dry_run=True,
+                    dry_run_message=dry_run_message,
+                    diff_snippet=diff_snippet,
+                )
+
+            # Apply change
+            metadata = {
+                "append": append,
+                "existing_length": len(existing_content),
+                "new_length": len(new_content),
+            }
+
+            # Write the file directly since it's a special file
+            coder.io.write_text(abs_path, new_content)
+
+            # Track the change
+            final_change_id = coder.change_tracker.track_change(
+                file_path=todo_file_path,
+                change_type="updatetodolist",
+                original_content=existing_content,
+                new_content=new_content,
+                metadata=metadata,
+                change_id=change_id,
+            )
 
-        # Generate diff for feedback
-        diff_snippet = generate_unified_diff_snippet(existing_content, new_content, todo_file_path)
+            coder.aider_edited_files.add(todo_file_path)
 
-        # Handle dry run
-        if dry_run:
-            action = "append to" if append else "replace"
-            dry_run_message = f"Dry run: Would {action} todo list in {todo_file_path}."
+            # Format and return result
+            action = "appended to" if append else "updated"
+            success_message = f"Successfully {action} todo list in {todo_file_path}"
             return format_tool_result(
                 coder,
                 tool_name,
-                "",
-                dry_run=True,
-                dry_run_message=dry_run_message,
+                success_message,
+                change_id=final_change_id,
                 diff_snippet=diff_snippet,
             )
 
-        # Apply change
-        metadata = {
-            "append": append,
-            "existing_length": len(existing_content),
-            "new_length": len(new_content),
-        }
-
-        # Write the file directly since it's a special file
-        coder.io.write_text(abs_path, new_content)
-
-        # Track the change
-        final_change_id = coder.change_tracker.track_change(
-            file_path=todo_file_path,
-            change_type="updatetodolist",
-            original_content=existing_content,
-            new_content=new_content,
-            metadata=metadata,
-            change_id=change_id,
-        )
-
-        coder.aider_edited_files.add(todo_file_path)
-
-        # Format and return result
-        action = "appended to" if append else "updated"
-        success_message = f"Successfully {action} todo list in {todo_file_path}"
-        return format_tool_result(
-            coder, tool_name, success_message, change_id=final_change_id, diff_snippet=diff_snippet
-        )
-
-    except ToolError as e:
-        return handle_tool_error(coder, tool_name, e, add_traceback=False)
-    except Exception as e:
-        return handle_tool_error(coder, tool_name, e)
-
-
-def process_response(coder, params):
-    """
-    Process the UpdateTodoList tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    content = params.get("content")
-    append = params.get("append", False)
-    change_id = params.get("change_id")
-    dry_run = params.get("dry_run", False)
-
-    if content is not None:
-        return _execute_update_todo_list(coder, content, append, change_id, dry_run)
-    else:
-        return "Error: Missing required 'content' parameter for UpdateTodoList"
+        except ToolError as e:
+            return handle_tool_error(coder, tool_name, e, add_traceback=False)
+        except Exception as e:
+            return handle_tool_error(coder, tool_name, e)
+
+    @classmethod
+    def format_output(cls, coder, mcp_server, tool_response):
+        tool_header(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+        tool_body_unwrapped(coder=coder, tool_response=tool_response)
+        tool_footer(coder=coder, tool_response=tool_response)

aider/tools/utils/base_tool.py

@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+
+from aider.tools.utils.helpers import handle_tool_error
+from aider.tools.utils.output import print_tool_response
+
+
+class BaseTool(ABC):
+    """Abstract base class for all tools."""
+
+    # Class properties that must be defined by subclasses
+    # Note: NORM_NAME should be the lowercase version of the function name in the SCHEMA
+    NORM_NAME = None
+    SCHEMA = None
+
+    @classmethod
+    @abstractmethod
+    def execute(cls, coder, **params):
+        """
+        Execute the tool with the given parameters.
+
+        Args:
+            coder: The Coder instance
+            **params: Tool-specific parameters
+
+        Returns:
+            str: Result message
+        """
+        pass
+
+    @classmethod
+    def process_response(cls, coder, params):
+        """
+        Process the tool response by creating an instance and calling execute.
+
+        Args:
+            coder: The Coder instance
+            params: Dictionary of parameters
+
+        Returns:
+            str: Result message
+        """
+
+        # Validate required parameters from SCHEMA
+        if cls.SCHEMA and "function" in cls.SCHEMA:
+            function_schema = cls.SCHEMA["function"]
+
+            if "parameters" in function_schema and "required" in function_schema["parameters"]:
+                required_params = function_schema["parameters"]["required"]
+                missing_params = [param for param in required_params if param not in params]
+                if missing_params:
+                    tool_name = function_schema.get("name", "Unknown Tool")
+                    error_msg = (
+                        f"Missing required parameters for {tool_name}: {', '.join(missing_params)}"
+                    )
+                    return handle_tool_error(coder, tool_name, ValueError(error_msg))
+
+        try:
+            return cls.execute(coder, **params)
+        except Exception as e:
+            return handle_tool_error(coder, cls.SCHEMA.get("function").get("name"), e)
+
+    @classmethod
+    def format_output(cls, coder, mcp_server, tool_response):
+        print_tool_response(coder=coder, mcp_server=mcp_server, tool_response=tool_response)