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

aider/io.py

@@ -2,6 +2,7 @@ import asyncio
 import base64
 import functools
 import os
+import re
 import shutil
 import signal
 import subprocess
@@ -32,10 +33,13 @@ from rich.color import ColorParseError
 from rich.columns import Columns
 from rich.console import Console
 from rich.markdown import Markdown
+from rich.markup import escape
 from rich.spinner import SPINNERS
 from rich.style import Style as RichStyle
 from rich.text import Text
 
+from aider.helpers import coroutines
+
 from .dump import dump  # noqa: F401
 from .editor import pipe_editor
 from .utils import is_image_file, run_fzf
@@ -292,6 +296,13 @@ class InputOutput:
     bell_on_next_input = False
     notifications_command = None
     encoding = "utf-8"
+    VALID_STYLES = {"bold", "red", "green", "blue", "orange"}
+    VALID_OPEN_TAG_PATTERN = re.compile(
+        r"\\\[(" + "|".join(re.escape(s) for s in VALID_STYLES) + r")\]"
+    )
+    VALID_CLOSE_TAG_PATTERN = re.compile(
+        r"\\\[/(?:" + "|".join(re.escape(s) for s in VALID_STYLES) + r"|)]"
+    )
 
     def __init__(
         self,
@@ -341,11 +352,14 @@ class InputOutput:
         self.bell_on_next_input = False
         self.notifications = notifications
         self.verbose = verbose
+        self.profile_start_time = None
+        self.profile_last_time = None
 
         # Variables used to interface with base_coder
         self.coder = None
         self.input_task = None
         self.output_task = None
+        self.linear = False
 
         # State tracking for confirmation input
         self.confirmation_in_progress = False
@@ -414,14 +428,17 @@ class InputOutput:
             self.chat_history_file = None
 
         self.encoding = encoding
-        valid_line_endings = {"platform", "lf", "crlf"}
+        valid_line_endings = {"platform", "lf", "crlf", "preserve"}
         if line_endings not in valid_line_endings:
             raise ValueError(
                 f"Invalid line_endings value: {line_endings}. "
                 f"Must be one of: {', '.join(valid_line_endings)}"
             )
+        self.line_endings = line_endings
         self.newline = (
-            None if line_endings == "platform" else "\n" if line_endings == "lf" else "\r\n"
+            None
+            if line_endings in ("platform", "preserve")
+            else "\n" if line_endings == "lf" else "\r\n"
         )
         self.dry_run = dry_run
 
@@ -438,6 +455,7 @@ class InputOutput:
         self.spinner_running = False
         self.spinner_text = ""
         self.last_spinner_text = ""
+        self.spinner_suffix = ""
         self.spinner_frame_index = 0
         self.spinner_last_frame_index = 0
         self.unicode_palette = "░█"
@@ -505,6 +523,7 @@ class InputOutput:
             self.spinner_running = True
             self.spinner_text = text
             self.spinner_frame_index = self.spinner_last_frame_index
+            self.spinner_suffix = ""
 
             if update_last_text:
                 self.last_spinner_text = text
@@ -515,10 +534,18 @@ class InputOutput:
     def update_spinner(self, text):
         self.spinner_text = text
 
+    def update_spinner_suffix(self, text=None):
+        if text:
+            self.spinner_suffix = f" • {text[:16].strip()}"
+        else:
+            self.spinner_suffix = ""
+
     def stop_spinner(self):
         """Stop the spinner."""
         self.spinner_running = False
         self.spinner_text = ""
+        self.spinner_suffix = ""
+
         # Keep last frame index to avoid spinner "jumping" on restart
         self.spinner_last_frame_index = self.spinner_frame_index
         if self.fallback_spinner:
@@ -527,13 +554,13 @@ class InputOutput:
 
     def get_bottom_toolbar(self):
         """Get the current spinner frame and text for the bottom toolbar."""
-        if not self.spinner_running or not self.spinner_frames:
+        if not self.spinner_running or not self.spinner_frames or self.linear:
             return None
 
         frame = self.spinner_frames[self.spinner_frame_index]
         self.spinner_frame_index = (self.spinner_frame_index + 1) % len(self.spinner_frames)
 
-        return f"{frame} {self.spinner_text}"
+        return f"{frame} {self.spinner_text}{self.spinner_suffix}"
 
     def _validate_color_settings(self):
         """Validate configured color strings and reset invalid ones."""
@@ -640,6 +667,18 @@ class InputOutput:
                 self.tool_error("Use --encoding to set the unicode encoding.")
             return
 
+    def _detect_newline(self, filename):
+        try:
+            with open(filename, "rb") as f:
+                chunk = f.read(1024)
+                if b"\r\n" in chunk:
+                    return "\r\n"
+                elif b"\n" in chunk:
+                    return "\n"
+        except (FileNotFoundError, IsADirectoryError):
+            pass  # File doesn't exist or is a directory, will use default
+        return None
+
     def write_text(self, filename, content, max_retries=5, initial_delay=0.1):
         """
         Writes content to a file, retrying with progressive backoff if the file is locked.
@@ -652,10 +691,14 @@ class InputOutput:
         if self.dry_run:
             return
 
+        newline = self.newline
+        if self.line_endings == "preserve":
+            newline = self._detect_newline(filename) or self.newline
+
         delay = initial_delay
         for attempt in range(max_retries):
             try:
-                with open(str(filename), "w", encoding=self.encoding, newline=self.newline) as f:
+                with open(str(filename), "w", encoding=self.encoding, newline=newline) as f:
                     f.write(content)
                 return  # Successfully wrote the file
             except PermissionError as err:
@@ -694,9 +737,13 @@ class InputOutput:
         # This method is now a no-op since we removed the confirmation_future logic
         pass
 
+    def get_coder(self):
+        coder = self.coder() if self.coder else None
+        return coder
+
     async def recreate_input(self, future=None):
-        if not self.input_task or self.input_task.done() or self.input_task.cancelled():
-            coder = self.coder() if self.coder else None
+        if not coroutines.is_active(self.input_task):
+            coder = self.get_coder()
 
             if coder:
                 self.input_task = asyncio.create_task(coder.get_input())
@@ -720,10 +767,10 @@ class InputOutput:
         show = ""
         if rel_fnames:
             rel_read_only_fnames = [
-                get_rel_fname(fname, root) for fname in (abs_read_only_fnames or [])
+                get_rel_fname(fname, root) for fname in abs_read_only_fnames or []
             ]
             rel_read_only_stubs_fnames = [
-                get_rel_fname(fname, root) for fname in (abs_read_only_stubs_fnames or [])
+                get_rel_fname(fname, root) for fname in abs_read_only_stubs_fnames or []
             ]
             show = self.format_files_for_input(
                 rel_fnames, rel_read_only_fnames, rel_read_only_stubs_fnames
@@ -886,9 +933,14 @@ class InputOutput:
                         return cmd
 
             except EOFError:
-                raise
+                coder = self.get_coder()
+
+                if coder:
+                    await coder.commands.cmd_exit(None)
+                else:
+                    raise SystemExit
+
             except KeyboardInterrupt:
-                await self.cancel_output_task()
                 self.console.print()
                 return ""
             except UnicodeEncodeError as err:
@@ -954,26 +1006,46 @@ class InputOutput:
         self.user_input(inp)
         return inp
 
-    async def cancel_input_task(self):
+    async def stop_input_task(self):
         if self.input_task:
             input_task = self.input_task
             self.input_task = None
             try:
                 input_task.cancel()
                 await input_task
-            except (asyncio.CancelledError, EOFError, IndexError):
+            except (
+                asyncio.CancelledError,
+                Exception,
+                EOFError,
+                IndexError,
+                RuntimeError,
+                SystemExit,
+            ):
                 pass
 
-    async def cancel_output_task(self):
+    async def stop_output_task(self):
         if self.output_task:
             output_task = self.output_task
             self.output_task = None
             try:
                 output_task.cancel()
                 await output_task
-            except (asyncio.CancelledError, EOFError, IndexError):
+            except (
+                asyncio.CancelledError,
+                Exception,
+                EOFError,
+                IndexError,
+                RuntimeError,
+                SystemExit,
+            ):
                 pass
 
+    async def stop_task_streams(self):
+        input_task = asyncio.create_task(self.stop_input_task())
+        output_task = asyncio.create_task(self.stop_output_task())
+
+        await asyncio.wait([input_task, output_task], return_when=asyncio.ALL_COMPLETED)
+
     def add_to_input_history(self, inp):
         if not self.input_history_file:
             return
@@ -1042,6 +1114,24 @@ class InputOutput:
         hist = "\n" + content.strip() + "\n\n"
         self.append_chat_history(hist)
 
+    def edit_in_editor(self, content):
+        import subprocess
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(
+            suffix=".md", mode="w", delete=False, encoding=self.encoding
+        ) as tmpfile:
+            tmpfile.write(content)
+            tmpfile.flush()
+            editor = os.environ.get("EDITOR", "vi")
+            subprocess.call([editor, tmpfile.name])
+
+        with open(tmpfile.name, "r", encoding=self.encoding) as f:
+            edited = f.read()
+
+        os.unlink(tmpfile.name)
+        return edited
+
     async def offer_url(
         self, url, prompt="Open URL for more info?", allow_never=True, acknowledge=False
     ):
@@ -1092,6 +1182,7 @@ class InputOutput:
         group=None,
         group_response=None,
         allow_never=False,
+        allow_tweak=False,
         acknowledge=False,
     ):
         self.num_user_asks += 1
@@ -1110,6 +1201,9 @@ class InputOutput:
             valid_responses = ["yes", "no", "skip", "all"]
             options = " (Y)es/(N)o"
 
+            if allow_tweak:
+                valid_responses.append("tweak")
+                options += "/(T)weak"
             if group or group_response:
                 if not explicit_yes_required or group_response:
                     options += "/(A)ll"
@@ -1153,11 +1247,7 @@ class InputOutput:
                         if self.prompt_session:
                             await self.recreate_input()
 
-                            if (
-                                self.input_task
-                                and not self.input_task.done()
-                                and not self.input_task.cancelled()
-                            ):
+                            if coroutines.is_active(self.input_task):
                                 self.prompt_session.message = question
                                 self.prompt_session.app.invalidate()
                             else:
@@ -1200,6 +1290,9 @@ class InputOutput:
                 self.append_chat_history(hist, linebreak=True, blockquote=True)
                 return False
 
+            if res == "t":
+                return "tweak"
+
             if explicit_yes_required and not group_response:
                 is_yes = res == "y"
             else:
@@ -1314,7 +1407,7 @@ class InputOutput:
         if log_only:
             return
 
-        messages = list(map(Text, messages))
+        messages = list(map(lambda message: self.escape(message), messages))
         style = dict()
         if self.pretty:
             if self.tool_output_color:
@@ -1326,6 +1419,49 @@ class InputOutput:
 
         self.stream_print(*messages, style=style)
 
+    def escape(self, text):
+        """Formats valid Rich tags and prints invalid ones as literal text using a single regex pass."""
+
+        # 1. Escape everything initially using Rich's built-in function
+        escaped_text = escape(text)
+
+        if text == escaped_text:
+            return Text(text)
+
+        # 2. Un-escape ONLY the valid opening tags
+        # Replaces '\[style]' with '[style]'
+        unescaped_text = self.__class__.VALID_OPEN_TAG_PATTERN.sub(
+            lambda m: f"[{m.group(1)}]", escaped_text
+        )
+
+        # 3. Un-escape ONLY the valid closing tags (handles both [/style] and [/] formats)
+        # Replaces '\[/style]' or '\[/]' with '[/]'
+        final_text = self.__class__.VALID_CLOSE_TAG_PATTERN.sub(r"[/]", unescaped_text)
+
+        # 4. Print the result
+        return Text(final_text)
+
+    def profile(self, *messages, start=False):
+        if not self.verbose:
+            return
+
+        now = time.time()
+        message_str = " ".join(map(str, messages))
+
+        # Treat uninitialized as an implicit start.
+        if start or self.profile_start_time is None:
+            self.profile_start_time = now
+            self.stream_print(f"PROFILE: {message_str}")
+        else:
+            total_elapsed = now - self.profile_start_time
+            last_elapsed = now - self.profile_last_time
+            output_message = (
+                f"PROFILE: [+{last_elapsed:6.2f}s] {message_str} (total {total_elapsed:.2f}s)"
+            )
+            self.stream_print(output_message)
+
+        self.profile_last_time = now
+
     def assistant_output(self, message, pretty=None):
         if not message:
             self.tool_warning("Empty response received from LLM. Check your provider account?")
@@ -1385,14 +1521,32 @@ class InputOutput:
 
             self._stream_buffer = incomplete_line
 
+        should_print = False
+        should_reset = False
+
         if not final:
             if len(lines) > 1:
+                should_print = True
+        else:
+            # Ensure any remaining buffered content is printed using the full response
+            should_print = True
+            should_reset = True
+
+        if should_print:
+            try:
                 self.console.print(
                     Text.from_ansi(output) if self.has_ansi_codes(output) else output
                 )
-        else:
-            # Ensure any remaining buffered content is printed using the full response
-            self.console.print(Text.from_ansi(output) if self.has_ansi_codes(output) else output)
+            except Exception as e:
+                if self.verbose:
+                    print(e)
+
+                self.console.print(
+                    (Text.from_ansi(output)) if self.has_ansi_codes(output) else output,
+                    markup=False,
+                )
+
+        if should_reset:
             self.reset_streaming_response()
 
     def remove_consecutive_empty_strings(self, string_list):
@@ -1558,7 +1712,7 @@ class InputOutput:
             return "\n".join(lines) + "\n"
 
         output = StringIO()
-        console = Console(file=output, force_terminal=False)
+        console = Console(file=output, force_terminal=False, markup=False)
 
         # Handle read-only files
         if rel_read_only_fnames or rel_read_only_stubs_fnames: