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

aider/tools/view_files_at_glob.py

@@ -1,10 +1,28 @@
 import fnmatch
 import os
 
+view_files_at_glob_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewFilesAtGlob",
+        "description": "View files matching a glob pattern.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "The glob pattern to match files.",
+                },
+            },
+            "required": ["pattern"],
+        },
+    },
+}
+
 
 def execute_view_files_at_glob(coder, pattern):
     """
-    Execute a glob pattern and add matching files to context as read-only.
+    Execute a glob pattern and return matching files as text.
 
     This tool helps the LLM find files by pattern matching, similar to
     how a developer would use glob patterns to find files.
@@ -25,38 +43,25 @@ def execute_view_files_at_glob(coder, pattern):
             if fnmatch.fnmatch(file, pattern):
                 matching_files.append(file)
 
-        # Limit the number of files added if there are too many matches
-        if len(matching_files) > coder.max_files_per_glob:
-            coder.io.tool_output(
-                f"⚠️ Found {len(matching_files)} files matching '{pattern}', "
-                f"limiting to {coder.max_files_per_glob} most relevant files."
-            )
-            # Sort by modification time (most recent first)
-            matching_files.sort(
-                key=lambda f: os.path.getmtime(coder.abs_root_path(f)), reverse=True
-            )
-            matching_files = matching_files[: coder.max_files_per_glob]
-
-        # Add files to context
-        for file in matching_files:
-            # Use the coder's internal method to add files
-            coder._add_file_to_context(file)
-
-        # Return a user-friendly result
+        # Return formatted text instead of adding to context
         if matching_files:
             if len(matching_files) > 10:
-                brief = ", ".join(matching_files[:5]) + f", and {len(matching_files) - 5} more"
-                coder.io.tool_output(
-                    f"📂 Added {len(matching_files)} files matching '{pattern}': {brief}"
+                result = (
+                    f"Found {len(matching_files)} files matching '{pattern}':"
+                    f" {', '.join(matching_files[:10])} and {len(matching_files) - 10} more"
                 )
+                coder.io.tool_output(f"📂 Found {len(matching_files)} files matching '{pattern}'")
             else:
+                result = (
+                    f"Found {len(matching_files)} files matching '{pattern}':"
+                    f" {', '.join(matching_files)}"
+                )
                 coder.io.tool_output(
-                    f"📂 Added files matching '{pattern}': {', '.join(matching_files)}"
+                    f"📂 Found files matching '{pattern}':"
+                    f" {', '.join(matching_files[:5])}{' and more' if len(matching_files) > 5 else ''}"
                 )
-            return (
-                f"Added {len(matching_files)} files:"
-                f" {', '.join(matching_files[:5])}{' and more' if len(matching_files) > 5 else ''}"
-            )
+
+            return result
         else:
             coder.io.tool_output(f"⚠️ No files found matching '{pattern}'")
             return f"No files found matching '{pattern}'"

aider/tools/view_files_matching.py

@@ -1,18 +1,46 @@
 import fnmatch
 import re
 
+view_files_matching_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"],
+        },
+    },
+}
 
-def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=False):
+
+def execute_view_files_matching(coder, pattern, file_pattern=None, regex=False):
     """
-    Search for pattern (literal string or regex) in files and add matching files to context as read-only.
+    Search for pattern (literal string or regex) in files and return matching files as text.
 
     Args:
         coder: The Coder instance.
-        search_pattern (str): The pattern to search for.
+        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 search_pattern as a regular expression.
+        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
@@ -29,9 +57,7 @@ def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=
                     files_to_search.append(file)
 
             if not files_to_search:
-                return (
-                    f"No files matching '{file_pattern}' to search for pattern '{search_pattern}'"
-                )
+                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()
@@ -46,16 +72,16 @@ def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=
                     match_count = 0
                     if regex:
                         try:
-                            matches_found = re.findall(search_pattern, content)
+                            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 '{search_pattern}': {e}")
+                            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(search_pattern)
+                        match_count = content.count(pattern)
 
                     if match_count > 0:
                         matches[file] = match_count
@@ -63,40 +89,28 @@ def execute_view_files_matching(coder, search_pattern, file_pattern=None, regex=
                 # Skip files that can't be read (binary, etc.)
                 pass
 
-        # Limit the number of files added if there are too many matches
-        if len(matches) > coder.max_files_per_glob:
-            coder.io.tool_output(
-                f"⚠️ Found '{search_pattern}' in {len(matches)} files, "
-                f"limiting to {coder.max_files_per_glob} files with most matches."
-            )
-            # Sort by number of matches (most matches first)
-            sorted_matches = sorted(matches.items(), key=lambda x: x[1], reverse=True)
-            matches = dict(sorted_matches[: coder.max_files_per_glob])
-
-        # Add matching files to context
-        for file in matches:
-            coder._add_file_to_context(file)
-
-        # Return a user-friendly result
+        # 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[:5]]
+            match_list = [f"{file} ({count} matches)" for file, count in sorted_matches]
 
-            if len(sorted_matches) > 5:
-                coder.io.tool_output(
-                    f"🔍 Found '{search_pattern}' in {len(matches)} files:"
-                    f" {', '.join(match_list)} and {len(matches) - 5} more"
-                )
-                return (
-                    f"Found in {len(matches)} files: {', '.join(match_list)} and"
-                    f" {len(matches) - 5} more"
+            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")
             else:
-                coder.io.tool_output(f"🔍 Found '{search_pattern}' in: {', '.join(match_list)}")
-                return f"Found in {len(matches)} files: {', '.join(match_list)}"
+                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 '{search_pattern}' not found in any files")
+            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)}")

aider/tools/view_files_with_symbol.py

@@ -1,9 +1,25 @@
-import os
+view_files_with_symbol_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewFilesWithSymbol",
+        "description": "View files that contain a specific symbol (e.g., class, function).",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "symbol": {
+                    "type": "string",
+                    "description": "The symbol to search for.",
+                },
+            },
+            "required": ["symbol"],
+        },
+    },
+}
 
 
 def _execute_view_files_with_symbol(coder, symbol):
     """
-    Find files containing a symbol using RepoMap and add them to context.
+    Find files containing a symbol using RepoMap and return them as text.
     Checks files already in context first.
     """
     if not coder.repo_map:
@@ -13,7 +29,6 @@ def _execute_view_files_with_symbol(coder, symbol):
     if not symbol:
         return "Error: Missing 'symbol' parameter for ViewFilesWithSymbol"
 
-    # --- Start Modification ---
     # 1. Check files already in context
     files_in_context = list(coder.abs_fnames) + list(coder.abs_read_only_fnames)
     found_in_context = []
@@ -34,20 +49,11 @@ def _execute_view_files_with_symbol(coder, symbol):
     if found_in_context:
         # Symbol found in already loaded files. Report this and stop.
         file_list = ", ".join(sorted(list(set(found_in_context))))
-        coder.io.tool_output(
-            f"Symbol '{symbol}' found in already loaded file(s): {file_list}. No external search"
-            " performed."
-        )
-        return (
-            f"Symbol '{symbol}' found in already loaded file(s): {file_list}. No external search"
-            " performed."
-        )
-    # --- End Modification ---
+        coder.io.tool_output(f"Symbol '{symbol}' found in already loaded file(s): {file_list}")
+        return f"Symbol '{symbol}' found in already loaded file(s): {file_list}"
 
     # 2. If not found in context, search the repository using RepoMap
-    coder.io.tool_output(
-        f"🔎 Searching for symbol '{symbol}' in repository (excluding current context)..."
-    )
+    coder.io.tool_output(f"🔎 Searching for symbol '{symbol}' in repository...")
     try:
         found_files = set()
         current_context_files = coder.abs_fnames | coder.abs_read_only_fnames
@@ -71,50 +77,31 @@ def _execute_view_files_with_symbol(coder, symbol):
                 # Use absolute path directly if available, otherwise resolve from relative path
                 abs_fname = rel_fname_to_abs.get(tag.rel_fname) or coder.abs_root_path(tag.fname)
                 if abs_fname in files_to_search:  # Ensure we only add files we intended to search
-                    found_files.add(abs_fname)
+                    found_files.add(coder.get_rel_fname(abs_fname))
 
-        # Limit the number of files added
-        if len(found_files) > coder.max_files_per_glob:
-            coder.io.tool_output(
-                f"⚠️ Found symbol '{symbol}' in {len(found_files)} files, "
-                f"limiting to {coder.max_files_per_glob} most relevant files."
-            )
-            # Sort by modification time (most recent first) - approximate relevance
-            sorted_found_files = sorted(
-                list(found_files), key=lambda f: os.path.getmtime(f), reverse=True
-            )
-            found_files = set(sorted_found_files[: coder.max_files_per_glob])
-
-        # Add files to context (as read-only)
-        added_count = 0
-        added_files_rel = []
-        for abs_file_path in found_files:
-            rel_path = coder.get_rel_fname(abs_file_path)
-            # Double check it's not already added somehow
-            if (
-                abs_file_path not in coder.abs_fnames
-                and abs_file_path not in coder.abs_read_only_fnames
-            ):
-                # Use explicit=True for clear output, even though it's an external search result
-                add_result = coder._add_file_to_context(rel_path, explicit=True)
-                if "Added" in add_result or "Viewed" in add_result:  # Count successful adds/views
-                    added_count += 1
-                    added_files_rel.append(rel_path)
-
-        if added_count > 0:
-            if added_count > 5:
-                brief = ", ".join(added_files_rel[:5]) + f", and {added_count - 5} more"
-                coder.io.tool_output(f"🔎 Found '{symbol}' and added {added_count} files: {brief}")
+        # Return formatted text instead of adding to context
+        if found_files:
+            found_files_list = sorted(list(found_files))
+            if len(found_files) > 10:
+                result = (
+                    f"Found symbol '{symbol}' in {len(found_files)} files:"
+                    f" {', '.join(found_files_list[:10])} and {len(found_files) - 10} more"
+                )
+                coder.io.tool_output(f"🔎 Found '{symbol}' in {len(found_files)} files")
             else:
+                result = (
+                    f"Found symbol '{symbol}' in {len(found_files)} files:"
+                    f" {', '.join(found_files_list)}"
+                )
                 coder.io.tool_output(
-                    f"🔎 Found '{symbol}' and added files: {', '.join(added_files_rel)}"
+                    f"🔎 Found '{symbol}' in files:"
+                    f" {', '.join(found_files_list[:5])}{' and more' if len(found_files) > 5 else ''}"
                 )
-            return f"Found symbol '{symbol}' and added {added_count} files as read-only."
+
+            return result
         else:
-            coder.io.tool_output(
-                f"⚠️ Symbol '{symbol}' not found in searchable files (outside current context)."
-            )
-            return f"Symbol '{symbol}' not found in searchable files (outside current context)."
+            coder.io.tool_output(f"⚠️ Symbol '{symbol}' not found in searchable files")
+            return f"Symbol '{symbol}' not found in searchable files"
 
     except Exception as e:
         coder.io.tool_error(f"Error in ViewFilesWithSymbol: {str(e)}")

aider/tools/view_todo_list.py

@@ -0,0 +1,57 @@
+from .tool_utils import ToolError, format_tool_result, handle_tool_error
+
+view_todo_list_schema = {
+    "type": "function",
+    "function": {
+        "name": "ViewTodoList",
+        "description": "View the current todo list for tracking conversation steps and progress.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        },
+    },
+}
+
+
+def _execute_view_todo_list(coder):
+    """
+    View the current todo list from .aider.todo.txt file.
+    Returns the todo list content or creates an empty one if it doesn't exist.
+    """
+    tool_name = "ViewTodoList"
+    try:
+        # Define the todo file path
+        todo_file_path = ".aider.todo.txt"
+        abs_path = coder.abs_root_path(todo_file_path)
+
+        # Check if file exists
+        import os
+
+        if os.path.isfile(abs_path):
+            # Read existing todo list
+            content = coder.io.read_text(abs_path)
+            if content is None:
+                raise ToolError(f"Could not read todo list file: {todo_file_path}")
+
+            # Check if content exceeds 4096 characters and warn
+            if len(content) > 4096:
+                coder.io.tool_warning(
+                    "⚠️ Todo list content exceeds 4096 characters. Consider summarizing the plan"
+                    " before proceeding."
+                )
+
+            if content.strip():
+                result_message = f"Current todo list:\n```\n{content}\n```"
+            else:
+                result_message = "Todo list is empty. Use UpdateTodoList to add items."
+        else:
+            # Create empty todo list
+            result_message = "Todo list is empty. Use UpdateTodoList to add items."
+
+        return format_tool_result(coder, tool_name, result_message)
+
+    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)

aider/waiting.py

@@ -1,221 +1,38 @@
 #!/usr/bin/env python
 
 """
-Thread-based, killable spinner utility.
-
-Use it like:
-
-    from aider.waiting import WaitingSpinner
-
-    spinner = WaitingSpinner("Waiting for LLM")
-    spinner.start()
-    ...  # long task
-    spinner.stop()
+A simple wrapper for rich.status to provide a spinner.
 """
 
-import sys
-import threading
-import time
-
 from rich.console import Console
 
 
 class Spinner:
-    """
-    Minimal spinner that scans a single marker back and forth across a line.
-
-    The animation is pre-rendered into a list of frames.  If the terminal
-    cannot display unicode the frames are converted to plain ASCII.
-    """
+    """A wrapper around rich.status.Status for displaying a spinner."""
 
-    last_frame_idx = 0  # Class variable to store the last frame index
-
-    def __init__(self, text: str, width: int = 7):
+    def __init__(self, text: str = "Waiting..."):
         self.text = text
-        self.start_time = time.time()
-        self.last_update = 0.0
-        self.visible = False
-        self.is_tty = sys.stdout.isatty()
         self.console = Console()
-
-        # Pre-render the animation frames using pure ASCII so they will
-        # always display, even on very limited terminals.
-        ascii_frames = [
-            "#=        ",  # C1 C2 space(8)
-            "=#        ",  # C2 C1 space(8)
-            " =#       ",  # space(1) C2 C1 space(7)
-            "  =#      ",  # space(2) C2 C1 space(6)
-            "   =#     ",  # space(3) C2 C1 space(5)
-            "    =#    ",  # space(4) C2 C1 space(4)
-            "     =#   ",  # space(5) C2 C1 space(3)
-            "      =#  ",  # space(6) C2 C1 space(2)
-            "       =# ",  # space(7) C2 C1 space(1)
-            "        =#",  # space(8) C2 C1
-            "        #=",  # space(8) C1 C2
-            "       #= ",  # space(7) C1 C2 space(1)
-            "      #=  ",  # space(6) C1 C2 space(2)
-            "     #=   ",  # space(5) C1 C2 space(3)
-            "    #=    ",  # space(4) C1 C2 space(4)
-            "   #=     ",  # space(3) C1 C2 space(5)
-            "  #=      ",  # space(2) C1 C2 space(6)
-            " #=       ",  # space(1) C1 C2 space(7)
-        ]
-
-        self.unicode_palette = "░█"
-        xlate_from, xlate_to = ("=#", self.unicode_palette)
-
-        # If unicode is supported, swap the ASCII chars for nicer glyphs.
-        if self._supports_unicode():
-            translation_table = str.maketrans(xlate_from, xlate_to)
-            frames = [f.translate(translation_table) for f in ascii_frames]
-            self.scan_char = xlate_to[xlate_from.find("#")]
-        else:
-            frames = ascii_frames
-            self.scan_char = "#"
-
-        # Bounce the scanner back and forth.
-        self.frames = frames
-        self.frame_idx = Spinner.last_frame_idx  # Initialize from class variable
-        self.width = len(frames[0]) - 2  # number of chars between the brackets
-        self.animation_len = len(frames[0])
-        self.last_display_len = 0  # Length of the last spinner line (frame + text)
-
-    def _supports_unicode(self) -> bool:
-        if not self.is_tty:
-            return False
-        try:
-            out = self.unicode_palette
-            out += "\b" * len(self.unicode_palette)
-            out += " " * len(self.unicode_palette)
-            out += "\b" * len(self.unicode_palette)
-            sys.stdout.write(out)
-            sys.stdout.flush()
-            return True
-        except UnicodeEncodeError:
-            return False
-        except Exception:
-            return False
-
-    def _next_frame(self) -> str:
-        frame = self.frames[self.frame_idx]
-        self.frame_idx = (self.frame_idx + 1) % len(self.frames)
-        Spinner.last_frame_idx = self.frame_idx  # Update class variable
-        return frame
-
-    def step(self, text: str = None) -> None:
-        if text is not None:
-            self.text = text
-
-        if not self.is_tty:
-            return
-
-        now = time.time()
-        if not self.visible and now - self.start_time >= 0.5:
-            self.visible = True
-            self.last_update = 0.0
-            if self.is_tty:
-                self.console.show_cursor(False)
-
-        if not self.visible or now - self.last_update < 0.1:
-            return
-
-        self.last_update = now
-        frame_str = self._next_frame()
-
-        # Determine the maximum width for the spinner line
-        # Subtract 2 as requested, to leave a margin or prevent cursor wrapping issues
-        max_spinner_width = self.console.width - 2
-        if max_spinner_width < 0:  # Handle extremely narrow terminals
-            max_spinner_width = 0
-
-        current_text_payload = f" {self.text}"
-        line_to_display = f"{frame_str}{current_text_payload}"
-
-        # Truncate the line if it's too long for the console width
-        if len(line_to_display) > max_spinner_width:
-            line_to_display = line_to_display[:max_spinner_width]
-
-        len_line_to_display = len(line_to_display)
-
-        # Calculate padding to clear any remnants from a longer previous line
-        padding_to_clear = " " * max(0, self.last_display_len - len_line_to_display)
-
-        # Write the spinner frame, text, and any necessary clearing spaces
-        sys.stdout.write(f"\r{line_to_display}{padding_to_clear}")
-        self.last_display_len = len_line_to_display
-
-        # Calculate number of backspaces to position cursor at the scanner character
-        scan_char_abs_pos = frame_str.find(self.scan_char)
-
-        # Total characters written to the line (frame + text + padding)
-        total_chars_written_on_line = len_line_to_display + len(padding_to_clear)
-
-        # num_backspaces will be non-positive if scan_char_abs_pos is beyond
-        # total_chars_written_on_line (e.g., if the scan char itself was truncated).
-        # (e.g., if the scan char itself was truncated).
-        # In such cases, (effectively) 0 backspaces are written,
-        # and the cursor stays at the end of the line.
-        num_backspaces = total_chars_written_on_line - scan_char_abs_pos
-        sys.stdout.write("\b" * num_backspaces)
-        sys.stdout.flush()
-
-    def end(self) -> None:
-        if self.visible and self.is_tty:
-            clear_len = self.last_display_len  # Use the length of the last displayed content
-            sys.stdout.write("\r" + " " * clear_len + "\r")
-            sys.stdout.flush()
-            self.console.show_cursor(True)
-        self.visible = False
-
-
-class WaitingSpinner:
-    """Background spinner that can be started/stopped safely."""
-
-    def __init__(self, text: str = "Waiting for LLM", delay: float = 0.15):
-        self.spinner = Spinner(text)
-        self.delay = delay
-        self._stop_event = threading.Event()
-        self._thread = threading.Thread(target=self._spin, daemon=True)
-
-    def _spin(self):
-        while not self._stop_event.is_set():
-            self.spinner.step()
-            time.sleep(self.delay)
-        self.spinner.end()
-
-    def start(self):
-        """Start the spinner in a background thread."""
-        if not self._thread.is_alive():
-            self._thread.start()
-
-    def stop(self):
-        """Request the spinner to stop and wait briefly for the thread to exit."""
-        self._stop_event.set()
-        if self._thread.is_alive():
-            self._thread.join(timeout=self.delay)
-        self.spinner.end()
+        self.status = None
+
+    def step(self, message=None):
+        """Start the spinner or update its text."""
+        if self.status is None:
+            self.status = self.console.status(self.text, spinner="dots2")
+            self.status.start()
+        elif message:
+            self.status.update(message)
+
+    def end(self):
+        """Stop the spinner."""
+        if self.status:
+            self.status.stop()
+            self.status = None
 
     # Allow use as a context-manager
     def __enter__(self):
-        self.start()
+        self.step()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.stop()
-
-
-def main():
-    spinner = Spinner("Running spinner...")
-    try:
-        for _ in range(100):
-            time.sleep(0.15)
-            spinner.step()
-        print("Success!")
-    except KeyboardInterrupt:
-        print("\nInterrupted by user.")
-    finally:
-        spinner.end()
-
-
-if __name__ == "__main__":
-    main()
+        self.end()