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

aider/tools/utils/output.py

@@ -0,0 +1,118 @@
+import json
+import re
+
+
+def print_tool_response(coder, mcp_server, tool_response):
+    """
+    Format the output for display.
+    Prints a Header to identify the tool, a body for the relevant information
+    for the user and a footer for verbose information
+
+    Args:
+        coder: An instance of base_coder
+        mcp_server: An mcp server instance
+        tool_response: a tool_response dictionary
+    """
+    tool_header(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+    tool_body(coder=coder, tool_response=tool_response)
+    tool_footer(coder=coder, tool_response=tool_response)
+
+
+def tool_header(coder, mcp_server, tool_response):
+    """
+    Prints the header for the tool call output
+
+    Args:
+        coder: An instance of base_coder
+        mcp_server: An mcp server instance
+        tool_response: a tool_response dictionary
+    """
+    color_start, color_end = color_markers(coder)
+
+    coder.io.tool_output(
+        f"{color_start}Tool Call:{color_end} {mcp_server.name} • {tool_response.function.name}"
+    )
+
+
+def tool_body(coder, tool_response):
+    """
+    Prints the output body of a tool call as the raw json returned from the model
+
+    Args:
+        coder: An instance of base_coder
+        tool_response: a tool_response dictionary
+    """
+    color_start, color_end = color_markers(coder)
+
+    # Parse and format arguments as headers with values
+    if tool_response.function.arguments:
+        # For non-replace tools, show raw arguments
+        raw_args = tool_response.function.arguments
+        coder.io.tool_output(f"{color_start}Arguments:{color_end} {raw_args}")
+
+
+def tool_body_unwrapped(coder, tool_response):
+    """
+    Prints the output body of a tool call with the argument
+    and content sections separated
+
+    Args:
+        coder: An instance of base_coder
+        tool_response: a tool_response dictionary
+    """
+
+    color_start, color_end = color_markers(coder)
+
+    try:
+        args_dict = json.loads(tool_response.function.arguments)
+        first_key = True
+        for key, value in args_dict.items():
+            # Convert explicit \\n sequences to actual newlines using regex
+            # Only match \\n that is not preceded by any other backslashes
+            if isinstance(value, str):
+                value = re.sub(r"(?<!\\)\\n", "\n", value)
+            # Add extra newline before first key/header
+            if first_key:
+                coder.io.tool_output("\n")
+                first_key = False
+            coder.io.tool_output(f"{color_start}{key}:{color_end}")
+            # Split the value by newlines and output each line separately
+            if isinstance(value, str):
+                for line in value.split("\n"):
+                    coder.io.tool_output(f"{line}")
+            else:
+                coder.io.tool_output(f"{str(value)}")
+            coder.io.tool_output("")
+    except json.JSONDecodeError:
+        # If JSON parsing fails, show raw arguments
+        raw_args = tool_response.function.arguments
+        coder.io.tool_output(f"{color_start}Arguments:{color_end} {raw_args}")
+
+
+def tool_footer(coder, tool_response):
+    """
+    Prints the output footer of a tool call, generally a new line
+    But can include id's if ran in verbose mode
+
+    Args:
+        coder: An instance of base_coder
+        tool_response: a tool_response dictionary
+    """
+    if coder.verbose:
+        coder.io.tool_output(f"Tool ID: {tool_response.id}")
+        coder.io.tool_output(f"Tool type: {tool_response.type}")
+
+    coder.io.tool_output("\n")
+
+
+def color_markers(coder):
+    """
+    Rich.console color markers
+
+    Args:
+        coder: An instance of base_coder
+    """
+    color_start = "[blue]" if coder.pretty else ""
+    color_end = "[/blue]" if coder.pretty else ""
+
+    return color_start, color_end

aider/tools/view.py

@@ -1,57 +1,41 @@
-schema = {
-    "type": "function",
-    "function": {
-        "name": "View",
-        "description": (
-            "View a specific file and add it to context."
-            "Only use this when the file is not already in the context "
-            "and when editing the file is necessary to accomplish the goal."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "file_path": {
-                    "type": "string",
-                    "description": "The path to the file to view.",
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "view"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "View",
+            "description": (
+                "View a specific file and add it to context."
+                "Only use this when the file is not already in the context "
+                "and when editing the file is necessary to accomplish the goal."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "The path to the file to view.",
+                    },
                 },
+                "required": ["file_path"],
             },
-            "required": ["file_path"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "view"
-
-
-def execute_view(coder, file_path):
-    """
-    Explicitly add a file to context as read-only.
-
-    This gives the LLM explicit control over what files to view,
-    rather than relying on indirect mentions.
-    """
-    try:
-        # Use the coder's helper, marking it as an explicit view request
-        return coder._add_file_to_context(file_path, explicit=True)
-    except Exception as e:
-        coder.io.tool_error(f"Error viewing file: {str(e)}")
-        return f"Error: {str(e)}"
-
-
-def process_response(coder, params):
-    """
-    Process the View tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    file_path = params.get("file_path")
-    if file_path is not None:
-        return execute_view(coder, file_path)
-    else:
-        return "Error: Missing 'file_path' parameter for View"
+    }
+
+    @classmethod
+    def execute(cls, coder, file_path):
+        """
+        Explicitly add a file to context as read-only.
+
+        This gives the LLM explicit control over what files to view,
+        rather than relying on indirect mentions.
+        """
+        try:
+            # Use the coder's helper, marking it as an explicit view request
+            return coder._add_file_to_context(file_path, explicit=True)
+        except Exception as e:
+            coder.io.tool_error(f"Error viewing file: {str(e)}")
+            return f"Error: {str(e)}"

aider/tools/view_files_matching.py

@@ -1,141 +1,138 @@
 import fnmatch
 import re
 
-schema = {
-    "type": "function",
-    "function": {
-        "name": "ViewFilesMatching",
-        "description": "View files containing a specific pattern.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "pattern": {
-                    "type": "string",
-                    "description": "The pattern to search for in file contents.",
-                },
-                "file_pattern": {
-                    "type": "string",
-                    "description": "An optional glob pattern to filter which files are searched.",
-                },
-                "regex": {
-                    "type": "boolean",
-                    "description": (
-                        "Whether the pattern is a regular expression. Defaults to False."
-                    ),
+from aider.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "viewfilesmatching"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "ViewFilesMatching",
+            "description": "View files containing a specific pattern.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "The pattern to search for in file contents.",
+                    },
+                    "file_pattern": {
+                        "type": "string",
+                        "description": (
+                            "An optional glob pattern to filter which files are searched."
+                        ),
+                    },
+                    "regex": {
+                        "type": "boolean",
+                        "description": (
+                            "Whether the pattern is a regular expression. Defaults to False."
+                        ),
+                    },
                 },
+                "required": ["pattern"],
             },
-            "required": ["pattern"],
         },
-    },
-}
-
-# Normalized tool name for lookup
-NORM_NAME = "viewfilesmatching"
-
-
-def execute_view_files_matching(coder, pattern, file_pattern=None, regex=False):
-    """
-    Search for pattern (literal string or regex) in files and return matching files as text.
-
-    Args:
-        coder: The Coder instance.
-        pattern (str): The pattern to search for.
-            Treated as a literal string by default.
-        file_pattern (str, optional): Glob pattern to filter which files are searched.
-            Defaults to None (search all files).
-        regex (bool, optional): If True, treat pattern as a regular expression.
-            Defaults to False.
-
-    This tool lets the LLM search for content within files, mimicking
-    how a developer would use grep or regex search to find relevant code.
-    """
-    try:
-        # Get list of files to search
-        if file_pattern:
-            # Use glob pattern to filter files
-            all_files = coder.get_all_relative_files()
-            files_to_search = []
-            for file in all_files:
-                if fnmatch.fnmatch(file, file_pattern):
-                    files_to_search.append(file)
-
-            if not files_to_search:
-                return f"No files matching '{file_pattern}' to search for pattern '{pattern}'"
-        else:
-            # Search all files if no pattern provided
-            files_to_search = coder.get_all_relative_files()
-
-        # Search for pattern in files
-        matches = {}
-        for file in files_to_search:
-            abs_path = coder.abs_root_path(file)
-            try:
-                with open(abs_path, "r", encoding="utf-8") as f:
-                    content = f.read()
-                    match_count = 0
-                    if regex:
-                        try:
-                            matches_found = re.findall(pattern, content)
-                            match_count = len(matches_found)
-                        except re.error as e:
-                            # Handle invalid regex patterns gracefully
-                            coder.io.tool_error(f"Invalid regex pattern '{pattern}': {e}")
-                            # Skip this file for this search if regex is invalid
-                            continue
-                    else:
-                        # Exact string matching
-                        match_count = content.count(pattern)
-
-                    if match_count > 0:
-                        matches[file] = match_count
-            except Exception:
-                # Skip files that can't be read (binary, etc.)
-                pass
-
-        # Return formatted text instead of adding to context
-        if matches:
-            # Sort by number of matches (most matches first)
-            sorted_matches = sorted(matches.items(), key=lambda x: x[1], reverse=True)
-            match_list = [f"{file} ({count} matches)" for file, count in sorted_matches]
-
-            if len(matches) > 10:
-                result = (
-                    f"Found '{pattern}' in {len(matches)} files: {', '.join(match_list[:10])} and"
-                    f" {len(matches) - 10} more"
-                )
-                coder.io.tool_output(f"🔍 Found '{pattern}' in {len(matches)} files")
+    }
+
+    @classmethod
+    def execute(cls, coder, pattern, file_pattern=None, regex=False):
+        """
+        Search for pattern (literal string or regex) in files and return matching files as text.
+
+        Args:
+            coder: The Coder instance.
+            pattern (str): The pattern to search for.
+                Treated as a literal string by default.
+            file_pattern (str, optional): Glob pattern to filter which files are searched.
+                Defaults to None (search all files).
+            regex (bool, optional): If True, treat pattern as a regular expression.
+                Defaults to False.
+
+        This tool lets the LLM search for content within files, mimicking
+        how a developer would use grep or regex search to find relevant code.
+        """
+        try:
+            # Get list of files to search
+            if file_pattern:
+                # Use glob pattern to filter files
+                all_files = coder.get_all_relative_files()
+                files_to_search = []
+                for file in all_files:
+                    if fnmatch.fnmatch(file, file_pattern):
+                        files_to_search.append(file)
+
+                if not files_to_search:
+                    return f"No files matching '{file_pattern}' to search for pattern '{pattern}'"
+            else:
+                # Search all files if no pattern provided
+                files_to_search = coder.get_all_relative_files()
+
+            # Search for pattern in files
+            matches = {}
+            num_matches = 0
+            inspecific_search_flag = False
+
+            for file in files_to_search:
+                abs_path = coder.abs_root_path(file)
+
+                if num_matches >= 25:
+                    inspecific_search_flag = True
+
+                try:
+                    if coder.repo.ignored_file(abs_path):
+                        continue
+
+                    with open(abs_path, "r", encoding="utf-8") as f:
+                        content = f.read()
+                        match_count = 0
+                        if regex:
+                            try:
+                                matches_found = re.findall(pattern, content)
+                                match_count = len(matches_found)
+                            except re.error as e:
+                                # Handle invalid regex patterns gracefully
+                                coder.io.tool_error(f"Invalid regex pattern '{pattern}': {e}")
+                                # Skip this file for this search if regex is invalid
+                                continue
+                        else:
+                            # Exact string matching
+                            match_count = content.count(pattern)
+
+                        if match_count > 0:
+                            matches[file] = match_count
+                            num_matches += 1
+                except Exception:
+                    # Skip files that can't be read (binary, etc.)
+                    pass
+
+            # Return formatted text instead of adding to context
+            if matches:
+                # Sort by number of matches (most matches first)
+                sorted_matches = sorted(matches.items(), key=lambda x: x[1], reverse=True)
+                match_list = [f"{file} ({count} matches)" for file, count in sorted_matches]
+
+                if len(matches) > 10:
+                    result = (
+                        f"Found '{pattern}' in {len(matches)} files:"
+                        f" {', '.join(match_list[:10])} and {len(matches) - 10} more"
+                        "\nTry more specific search terms going forward"
+                        if inspecific_search_flag
+                        else ""
+                    )
+                    coder.io.tool_output(f"🔍 Found '{pattern}' in {len(matches)} files")
+                else:
+                    result = f"Found '{pattern}' in {len(matches)} files: {', '.join(match_list)}"
+                    coder.io.tool_output(
+                        f"🔍 Found '{pattern}' in:"
+                        f" {', '.join(match_list[:5])}{' and more' if len(matches) > 5 else ''}"
+                    )
+
+                return result
             else:
-                result = f"Found '{pattern}' in {len(matches)} files: {', '.join(match_list)}"
-                coder.io.tool_output(
-                    f"🔍 Found '{pattern}' in:"
-                    f" {', '.join(match_list[:5])}{' and more' if len(matches) > 5 else ''}"
-                )
-
-            return result
-        else:
-            coder.io.tool_output(f"⚠️ Pattern '{pattern}' not found in any files")
-            return "Pattern not found in any files"
-    except Exception as e:
-        coder.io.tool_error(f"Error in ViewFilesMatching: {str(e)}")
-        return f"Error: {str(e)}"
-
-
-def process_response(coder, params):
-    """
-    Process the ViewFilesMatching tool response.
-
-    Args:
-        coder: The Coder instance
-        params: Dictionary of parameters
-
-    Returns:
-        str: Result message
-    """
-    pattern = params.get("pattern")
-    file_pattern = params.get("file_pattern")
-    regex = params.get("regex", False)
-
-    if pattern is not None:
-        return execute_view_files_matching(coder, pattern, file_pattern, regex)
-    else:
-        return "Error: Missing 'pattern' parameter for ViewFilesMatching"
+                coder.io.tool_output(f"⚠️ Pattern '{pattern}' not found in any files")
+                return "Pattern not found in any files"
+        except Exception as e:
+            coder.io.tool_error(f"Error in ViewFilesMatching: {str(e)}")
+            return f"Error: {str(e)}"