aider-ce 0.88.2__py3-none-any.whl → 0.88.4__py3-none-any.whl

aider/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.88.2.dev"
+__version__ = "0.88.4.dev"
 safe_version = __version__
 
 try:

aider/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.88.2'
-__version_tuple__ = version_tuple = (0, 88, 2)
+__version__ = version = '0.88.4'
+__version_tuple__ = version_tuple = (0, 88, 4)
 
 __commit_id__ = commit_id = None

aider/coders/base_coder.py

@@ -42,7 +42,7 @@ from rich.console import Console
 
 from aider import __version__, models, prompts, urls, utils
 from aider.analytics import Analytics
-from aider.commands import Commands
+from aider.commands import Commands, SwitchCoder
 from aider.exceptions import LiteLLMExceptions
 from aider.history import ChatSummary
 from aider.io import ConfirmGroup, InputOutput
@@ -585,8 +585,6 @@ class Coder:
         self.summarizer_thread = None
         self.summarized_done_messages = []
         self.summarizing_messages = None
-        self.input_task = None
-        self.confirmation_in_progress = False
 
         self.files_edited_by_tools = set()
 
@@ -1057,7 +1055,7 @@ class Coder:
             self.commit_before_message.append(self.repo.get_head_commit_sha())
 
     async def run(self, with_message=None, preproc=True):
-        while self.confirmation_in_progress:
+        while self.io.confirmation_in_progress:
             await asyncio.sleep(0.1)  # Yield control and wait briefly
 
         if self.io.prompt_session:
@@ -1067,8 +1065,6 @@ class Coder:
             return await self._run_patched(with_message, preproc)
 
     async def _run_patched(self, with_message=None, preproc=True):
-        input_task = None
-        processing_task = None
         try:
             if with_message:
                 self.io.user_input(with_message)
@@ -1076,91 +1072,134 @@ class Coder:
                 return self.partial_response_content
 
             user_message = None
+            await self.io.cancel_input_task()
+            await self.io.cancel_processing_task()
 
             while True:
                 try:
                     if (
-                        not self.confirmation_in_progress
-                        and not input_task
+                        not self.io.confirmation_in_progress
                         and not user_message
-                        and (not processing_task or not self.io.placeholder)
+                        and (
+                            not self.io.input_task
+                            or self.io.input_task.done()
+                            or self.io.input_task.cancelled()
+                        )
+                        and (not self.io.processing_task or not self.io.placeholder)
                     ):
                         if not self.suppress_announcements_for_next_prompt:
                             self.show_announcements()
-                        self.suppress_announcements_for_next_prompt = False
+                        self.suppress_announcements_for_next_prompt = True
 
                         # Stop spinner before showing announcements or getting input
                         self.io.stop_spinner()
-
                         self.copy_context()
-                        self.input_task = asyncio.create_task(self.get_input())
-                        input_task = self.input_task
+                        self.io.input_task = asyncio.create_task(self.get_input())
+
+                        # Yield Control so input can actually get properly set up
+                        await asyncio.sleep(0)
 
                     tasks = set()
-                    if processing_task:
-                        tasks.add(processing_task)
-                    if input_task:
-                        tasks.add(input_task)
+
+                    if self.io.processing_task:
+                        if self.io.processing_task.done():
+                            exception = self.io.processing_task.exception()
+                            if exception:
+                                if isinstance(exception, SwitchCoder):
+                                    await self.io.processing_task
+                        elif (
+                            not self.io.processing_task.done()
+                            and not self.io.processing_task.cancelled()
+                        ):
+                            tasks.add(self.io.processing_task)
+
+                    if (
+                        self.io.input_task
+                        and not self.io.input_task.done()
+                        and not self.io.input_task.cancelled()
+                    ):
+                        tasks.add(self.io.input_task)
 
                     if tasks:
                         done, pending = await asyncio.wait(
                             tasks, return_when=asyncio.FIRST_COMPLETED
                         )
 
-                        if input_task and input_task in done:
-                            if processing_task:
-                                if not self.confirmation_in_progress:
-                                    processing_task.cancel()
-                                    try:
-                                        await processing_task
-                                    except asyncio.CancelledError:
-                                        pass
+                        if self.io.input_task and self.io.input_task in done:
+                            if self.io.processing_task:
+                                if not self.io.confirmation_in_progress:
+                                    await self.io.cancel_processing_task()
                                     self.io.stop_spinner()
-                                    processing_task = None
 
                             try:
-                                user_message = input_task.result()
+                                user_message = self.io.input_task.result()
+                                await self.io.cancel_input_task()
                             except (asyncio.CancelledError, KeyboardInterrupt):
                                 user_message = None
-                            input_task = None
-                            self.input_task = None
-                            if user_message is None:
+
+                            if not user_message:
+                                await self.io.cancel_input_task()
                                 continue
 
-                        if processing_task and processing_task in done:
+                        if self.io.processing_task and self.io.processing_task in pending:
                             try:
-                                await processing_task
+                                tasks = set()
+                                tasks.add(self.io.processing_task)
+
+                                # We just did a confirmation so add a new input task
+                                if (
+                                    not self.io.input_task
+                                    and self.io.get_confirmation_acknowledgement()
+                                ):
+                                    self.io.input_task = asyncio.create_task(self.get_input())
+                                    tasks.add(self.io.input_task)
+
+                                done, pending = await asyncio.wait(
+                                    tasks, return_when=asyncio.FIRST_COMPLETED
+                                )
+
+                                if self.io.input_task and self.io.input_task in done:
+                                    await self.io.cancel_processing_task()
+                                    self.io.stop_spinner()
+                                    self.io.acknowledge_confirmation()
+
+                                    try:
+                                        user_message = self.io.input_task.result()
+                                        await self.io.cancel_input_task()
+                                    except (asyncio.CancelledError, KeyboardInterrupt):
+                                        user_message = None
+
                             except (asyncio.CancelledError, KeyboardInterrupt):
+                                print("error of some sort")
                                 pass
-                            processing_task = None
+
                             # Stop spinner when processing task completes
                             self.io.stop_spinner()
 
-                    if user_message and self.run_one_completed and self.compact_context_completed:
-                        processing_task = asyncio.create_task(
+                    if user_message and not self.io.acknowledge_confirmation():
+                        self.io.processing_task = asyncio.create_task(
                             self._processing_logic(user_message, preproc)
                         )
                         # Start spinner for processing task
                         self.io.start_spinner("Processing...")
-                        user_message = None  # Clear message after starting task
+
+                    self.io.ring_bell()
+                    user_message = None
                 except KeyboardInterrupt:
-                    if processing_task:
-                        processing_task.cancel()
-                        processing_task = None
-                        # Stop spinner when processing task is cancelled
-                        self.io.stop_spinner()
-                    if input_task:
+                    if self.io.input_task:
                         self.io.set_placeholder("")
-                        input_task.cancel()
-                        input_task = None
+                        await self.io.cancel_input_task()
+
+                    if self.io.processing_task:
+                        await self.io.cancel_processing_task()
+                        self.io.stop_spinner()
+
                     self.keyboard_interrupt()
         except EOFError:
             return
         finally:
-            if input_task:
-                input_task.cancel()
-            if processing_task:
-                processing_task.cancel()
+            await self.io.cancel_input_task()
+            await self.io.cancel_processing_task()
 
     async def _processing_logic(self, user_message, preproc):
         try:
@@ -1188,6 +1227,7 @@ class Coder:
         all_read_only_files = [self.get_rel_fname(fname) for fname in all_read_only_fnames]
         all_files = sorted(set(inchat_files + all_read_only_files))
         edit_format = "" if self.edit_format == self.main_model.edit_format else self.edit_format
+
         return await self.io.get_input(
             self.root,
             all_files,
@@ -1214,6 +1254,8 @@ class Coder:
         self.init_before_message()
 
         if preproc:
+            if user_message[0] in "!":
+                user_message = f"/run {user_message[1:]}"
             message = await self.preproc_user_input(user_message)
         else:
             message = user_message
@@ -2704,7 +2746,7 @@ class Coder:
 
         async for chunk in completion:
             # Check if confirmation is in progress and wait if needed
-            while self.confirmation_in_progress:
+            while self.io.confirmation_in_progress:
                 await asyncio.sleep(0.1)  # Yield control and wait briefly
 
             if isinstance(chunk, str):

aider/io.py

@@ -320,6 +320,7 @@ class InputOutput:
         root=".",
         notifications=False,
         notifications_command=None,
+        verbose=False,
     ):
         self.console = Console()
         self.pretty = pretty
@@ -337,6 +338,8 @@ class InputOutput:
         self.multiline_mode = multiline_mode
         self.bell_on_next_input = False
         self.notifications = notifications
+        self.verbose = verbose
+
         if notifications and notifications_command is None:
             self.notifications_command = self.get_default_notification_command()
         else:
@@ -363,7 +366,7 @@ class InputOutput:
         )
 
         self.fzf_available = shutil.which("fzf")
-        if not self.fzf_available:
+        if not self.fzf_available and self.verbose:
             self.tool_warning(
                 "fzf not found, fuzzy finder features will be disabled. Install it for enhanced"
                 " file/history search."
@@ -418,13 +421,14 @@ class InputOutput:
             self.pretty = False
             fancy_input = False
 
+        # Spinner state
+        self.spinner_running = False
+        self.spinner_text = ""
+        self.spinner_frame_index = 0
+        self.spinner_last_frame_index = 0
+        self.unicode_palette = "░█"
+
         if fancy_input:
-            # Spinner state
-            self.spinner_running = False
-            self.spinner_text = ""
-            self.spinner_frame_index = 0
-            self.spinner_last_frame_index = 0
-            self.unicode_palette = "░█"
             # If unicode is supported, use the rich 'dots2' spinner, otherwise an ascii fallback
             if self._spinner_supports_unicode():
                 self.spinner_frames = SPINNERS["dots2"]["frames"]
@@ -459,7 +463,18 @@ class InputOutput:
         self.file_watcher = file_watcher
         self.root = root
         self.outstanding_confirmations = []
+
+        # Variables used to interface with base_coder
         self.coder = None
+        self.input_task = None
+        self.processing_task = None
+        self.confirmation_in_progress = False
+        self.confirmation_acknowledgement = False
+
+        # State tracking for confirmation input
+        self.confirmation_input_active = False
+        self.saved_input_text = ""
+        self.confirmation_future = None
 
         # Validate color settings after console is initialized
         self._validate_color_settings()
@@ -656,16 +671,8 @@ class InputOutput:
             print()
 
     def interrupt_input(self):
-        coder = self.coder() if self.coder else None
-        # interrupted_for_confirmation = False
-
-        if (
-            coder
-            and hasattr(coder, "input_task")
-            and coder.input_task
-            and not coder.input_task.done()
-        ):
-            coder.input_task.cancel()
+        if self.input_task and not self.input_task.done():
+            self.input_task.cancel()
 
         if self.prompt_session and self.prompt_session.app:
             # Store any partial input before interrupting
@@ -697,9 +704,6 @@ class InputOutput:
         self.reject_outstanding_confirmations()
         self.rule()
 
-        # Ring the bell if needed
-        self.ring_bell()
-
         rel_fnames = list(rel_fnames)
         show = ""
         if rel_fnames:
@@ -878,6 +882,11 @@ class InputOutput:
                 self.tool_error(str(err))
                 return ""
             except Exception as err:
+                try:
+                    self.prompt_session.app.exit()
+                except Exception:
+                    pass
+
                 import traceback
 
                 self.tool_error(str(err))
@@ -930,6 +939,26 @@ class InputOutput:
         self.user_input(inp)
         return inp
 
+    async def cancel_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:
+                pass
+
+    async def cancel_processing_task(self):
+        if self.processing_task:
+            processing_task = self.processing_task
+            self.processing_task = None
+            try:
+                processing_task.cancel()
+                await processing_task
+            except asyncio.CancelledError:
+                pass
+
     def add_to_input_history(self, inp):
         if not self.input_history_file:
             return
@@ -1000,32 +1029,33 @@ class InputOutput:
             return True
         return False
 
+    def set_confirmation_acknowledgement(self):
+        self.confirmation_acknowledgement = True
+
+    def get_confirmation_acknowledgement(self):
+        return self.confirmation_acknowledgement
+
+    def acknowledge_confirmation(self):
+        outstanding_confirmation = self.confirmation_acknowledgement
+        self.confirmation_acknowledgement = False
+        return outstanding_confirmation
+
     @restore_multiline_async
     async def confirm_ask(
         self,
         *args,
         **kwargs,
     ):
-        coder = self.coder() if self.coder else None
-        interrupted_for_confirmation = False
-        if (
-            coder
-            and hasattr(coder, "input_task")
-            and coder.input_task
-            and not coder.input_task.done()
-        ):
-            coder.confirmation_in_progress = True
-            interrupted_for_confirmation = True
-            # self.interrupt_input()
+        self.confirmation_in_progress = True
 
         try:
+            self.set_confirmation_acknowledgement()
             return await asyncio.create_task(self._confirm_ask(*args, **kwargs))
         except KeyboardInterrupt:
             # Re-raise KeyboardInterrupt to allow it to propagate
             raise
         finally:
-            if interrupted_for_confirmation:
-                coder.confirmation_in_progress = False
+            self.confirmation_in_progress = False
 
     async def _confirm_ask(
         self,
@@ -1038,9 +1068,6 @@ class InputOutput:
     ):
         self.num_user_asks += 1
 
-        # Ring the bell if needed
-        self.ring_bell()
-
         question_id = (question, subject)
 
         confirmation_future = asyncio.get_running_loop().create_future()
@@ -1085,47 +1112,45 @@ class InputOutput:
                 else:
                     self.tool_output(subject, bold=True)
 
-            style = self._get_style()
-
             if self.yes is True:
                 res = "n" if explicit_yes_required else "y"
+                self.acknowledge_confirmation()
             elif self.yes is False:
                 res = "n"
+                self.acknowledge_confirmation()
             elif group and group.preference:
                 res = group.preference
                 self.user_input(f"{question}{res}", log_only=False)
+                self.acknowledge_confirmation()
             else:
+                # Ring the bell if needed
+                self.ring_bell()
+
                 while True:
                     try:
                         if self.prompt_session:
-                            coder = self.coder() if self.coder else None
                             if (
-                                coder
-                                and hasattr(coder, "input_task")
-                                and coder.input_task
-                                and not coder.input_task.done()
+                                not self.input_task
+                                or self.input_task.done()
+                                or self.input_task.cancelled()
+                            ):
+                                coder = self.coder() if self.coder else None
+
+                                if coder:
+                                    self.input_task = asyncio.create_task(coder.get_input())
+                                    await asyncio.sleep(0)
+
+                            if (
+                                self.input_task
+                                and not self.input_task.done()
+                                and not self.input_task.cancelled()
                             ):
                                 self.prompt_session.message = question
                                 self.prompt_session.app.invalidate()
-                                res = await coder.input_task
                             else:
-                                prompt_task = asyncio.create_task(
-                                    self.prompt_session.prompt_async(
-                                        question,
-                                        style=style,
-                                        complete_while_typing=False,
-                                    )
-                                )
-                                done, pending = await asyncio.wait(
-                                    {prompt_task, confirmation_future},
-                                    return_when=asyncio.FIRST_COMPLETED,
-                                )
-
-                                if confirmation_future in done:
-                                    prompt_task.cancel()
-                                    return await confirmation_future
-
-                                res = await prompt_task
+                                continue
+
+                            res = await self.input_task
                         else:
                             res = await asyncio.get_event_loop().run_in_executor(
                                 None, input, question
@@ -1240,17 +1265,22 @@ class InputOutput:
 
         if not isinstance(message, Text):
             message = Text(message)
-        color = ensure_hash_prefix(color) if color else None
-        style = dict(style=color) if self.pretty and color else dict()
+
+        style = dict()
+
+        if self.pretty:
+            color = ensure_hash_prefix(color) if color else None
+            if color:
+                style["color"] = color
 
         try:
-            self.stream_print(message, **style)
+            self.stream_print(message, style=RichStyle(**style))
         except UnicodeEncodeError:
             # Fallback to ASCII-safe output
             if isinstance(message, Text):
                 message = message.plain
             message = str(message).encode("ascii", errors="replace").decode("ascii")
-            self.stream_print(message, **style)
+            self.stream_print(message, style=RichStyle(**style))
 
         if self.prompt_session and self.prompt_session.app:
             self.prompt_session.app.invalidate()

aider/main.py

@@ -601,6 +601,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
             multiline_mode=args.multiline,
             notifications=args.notifications,
             notifications_command=args.notifications_command,
+            verbose=args.verbose,
         )
 
     io = get_io(args.pretty)

aider/urls.py

@@ -8,7 +8,7 @@ model_warnings = "https://aider.chat/docs/llms/warnings.html"
 token_limits = "https://aider.chat/docs/troubleshooting/token-limits.html"
 llms = "https://aider.chat/docs/llms.html"
 large_repos = "https://aider.chat/docs/faq.html#can-i-use-aider-in-a-large-mono-repo"
-github_issues = "https://github.com/Aider-AI/aider/issues/new"
+github_issues = "https://github.com/dwash96/aider-ce/issues/new"
 git_index_version = "https://github.com/Aider-AI/aider/issues/211"
 install_properly = "https://aider.chat/docs/troubleshooting/imports.html"
 analytics = "https://aider.chat/docs/more/analytics.html"

aider/versioncheck.py

@@ -21,7 +21,7 @@ def install_from_main_branch(io):
         io,
         None,
         "Install the development version of aider from the main branch?",
-        ["git+https://github.com/Aider-AI/aider.git"],
+        ["git+https://github.com/dwash96/aider-ce.git"],
         self_update=True,
     )
 

{aider_ce-0.88.2.dist-info → aider_ce-0.88.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-ce
-Version: 0.88.2
+Version: 0.88.4
 Summary: Aider is AI pair programming in your terminal
 Project-URL: Homepage, https://github.com/dwash96/aider-ce
 Classifier: Development Status :: 4 - Beta

{aider_ce-0.88.2.dist-info → aider_ce-0.88.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-aider/__init__.py,sha256=lR9OBHkDJxBD9W4uVZzRD0QzU75uFDkVWRF4kJyJh4k,496
+aider/__init__.py,sha256=Gt5Oveq-MHT_HEMx5-sLQoQaHGVMIX7buzoDjI8ifqA,496
 aider/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
-aider/_version.py,sha256=2xGyxCb49iWFz4jJKwCSryLonWCKFULLHVc5ZqHj6h8,706
+aider/_version.py,sha256=IQ-Q4S4Mold8rZdN7zBkEdwsR_c0ns8JopeeDGBPsmA,706
 aider/analytics.py,sha256=c5ujaCcMc3yG-9rz_0oSsqBwmVQRxJnui6iE_yDyY_M,7507
 aider/args.py,sha256=lC64t3gp-SJ1Sv51LDHpTAsiU2ZwiFWerYf3iu9mtWY,32742
 aider/args_formatter.py,sha256=CBRnzHyZk-fFCK0ekAzb6C4PPJOU-VTpWIIsJe3qUhk,6369
@@ -17,10 +17,10 @@ aider/gui.py,sha256=JnHvli1JTCGHAgsOZ8HkAWOKAFxmngbyviZIJeYvjsw,17573
 aider/help.py,sha256=wExA1E9vuJccKBH1VvKmH-zJqFi-vhNc0n3CD3Y-8fI,4432
 aider/help_pats.py,sha256=syn7pSVJdcf8uMKTxnZUZBQu-r8JMAi-rrC-k2er1Fk,376
 aider/history.py,sha256=083Gm7KxNo1PXMFHYiChigxCbRzmLkfNlesODdCC-eY,6067
-aider/io.py,sha256=_CS6DxB-HmpaqVUedyAq-CZzp-KdHHs2zwpF53pcaCY,56859
+aider/io.py,sha256=jEhZdRs7pbOszyiJpCAUYbUjSH9Bp21H-YkgdraUrjw,57586
 aider/linter.py,sha256=t5jwWZ1dvIzRtig1kTSjzl6u1LRfw0e19qwNIen2jAg,7998
 aider/llm.py,sha256=dtT0mavXP1SyR0Zu_ysZXKdbs3y53q2PevvDKBUrs6s,1505
-aider/main.py,sha256=2Pk5nJhUf-aoa2cbs6VPQA0lfneRYgw-dCbkFO8r8WY,46331
+aider/main.py,sha256=I_zPPpX19TWMwngQowlIeiv8O9UwFqdCiQOiFhZ2tBo,46365
 aider/mdstream.py,sha256=fS9iQUQmIJPEMo7o1psPGE2yYj31MI3m3msdN-jEzUw,7594
 aider/models.py,sha256=yflYZ64oza4QH04vIPI2n7rcsdSw2Np4BRwRKlb3STQ,45455
 aider/onboarding.py,sha256=pMWl--NOH_hb4w1wVxLmv8W0akcrilo1Pxf9XUSqBXs,16135
@@ -34,9 +34,9 @@ aider/run_cmd.py,sha256=9-NpSL4hlqIndf_EN1jnmWfjX7vIPbDgKgGPGRAr2Rw,4223
 aider/scrape.py,sha256=1d5RTtHLJ8JersGoQWm0mDVk_rQfsY4Xm-0jTK8xEPw,8346
 aider/sendchat.py,sha256=fY9scUSGdcLUDrD3PWUEyp6njRZZ138l79oXz_bks8o,7700
 aider/special.py,sha256=OhsBWWM-DWwjWbi6kE7EqR4CiUfyJ6qJuCgcmywZSAc,4415
-aider/urls.py,sha256=W0OL4pahSIZAaSUHPvn9KPN1aIkXE5nAKcizMKy4EKg,1122
+aider/urls.py,sha256=LoSe3P1wGC5hEohJ5lRuIXT2R0YzLNbJrC67c8KoQZ4,1124
 aider/utils.py,sha256=wkT43yJx59Q0OfIlzNX2n9rPyEEo7WLKXdXoxNJzdz4,12231
-aider/versioncheck.py,sha256=R9R1gUJYgOtmUycpJ4YqxCkCOylQBSiZ_p_BAnHJ8H4,2977
+aider/versioncheck.py,sha256=e2rD1Kdz_mcuzcgyrRsveYd-BxfgS4pzkFbIE2gz6xs,2979
 aider/voice.py,sha256=hNQCMCWhljcROJhzsvnkwgzzgQQbFORkpROhKeqICig,6797
 aider/waiting.py,sha256=QbDnh1U6oJPqkUrRM3DC8iA5-djbKRW5iJh6Q3VOnrI,944
 aider/watch.py,sha256=znCZhHCBlcMm-4SRJP-B0mWfsl5q26DAd-zlk2zykQ8,10641
@@ -46,7 +46,7 @@ aider/coders/architect_coder.py,sha256=O5KIf__Ka0bgtCUhYWUmAb08aCS6Nq-CdVWWa-VNK
 aider/coders/architect_prompts.py,sha256=R0_KxZjo-km_yNaeDAquDP9qfp3IdWgrdMirCWe0RIE,1658
 aider/coders/ask_coder.py,sha256=Omk4Ih8-prefkMZ_jnRS3faoW5CQUakHOvZ-s7piM3U,210
 aider/coders/ask_prompts.py,sha256=W6HwDUfzfOLt9q8sl6rw7fN7b5ND90FkxCZrtrWl5vY,1171
-aider/coders/base_coder.py,sha256=I2IwjL2mzcBJhnaMHhAZn0tQZ6DPi8sw-EsjRofJk9c,128223
+aider/coders/base_coder.py,sha256=gFEeUmxwv5r9wrl9kwRyIxJIxefx4hCs3SedZVnyEms,130301
 aider/coders/base_prompts.py,sha256=O3bBjhf0hgvtKbQ9QyOMnRy8LrmfLyT9dVAcXxHS_3k,3659
 aider/coders/chat_chunks.py,sha256=8HPet6cmQdgWvaA_tGpinO4ASMst53uTcSEtNVTYDXE,1981
 aider/coders/context_coder.py,sha256=_RSzu6ptHo2lkTN7-e9TpcZKzqbQF2eNX5MkyswGm3s,1577
@@ -261,9 +261,9 @@ aider/website/docs/usage/tutorials.md,sha256=ZKBztbUtucHOiv9h8gvWiWTP6MTSsFyz4mA
 aider/website/docs/usage/voice.md,sha256=BtX7pHRgHRWUmrNbS4JssC-SO8RrJ_OetBCtIYpO0pU,3452
 aider/website/docs/usage/watch.md,sha256=OVF14lGtv1vhSXRE8PpxQ3YW-uXSifarUbmLBjmLRyA,7940
 aider/website/share/index.md,sha256=P51aDw9AT8AVbsU7v6g1tWuMjly7y_plM_ZI1ScaT8Y,3172
-aider_ce-0.88.2.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-aider_ce-0.88.2.dist-info/METADATA,sha256=24StMPdhLaWO45fN1UXg5gC-nJjB7mEuPzaaVlBxULE,20820
-aider_ce-0.88.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aider_ce-0.88.2.dist-info/entry_points.txt,sha256=qUBEUd84DYNEHFSgZbgsjgsrAABxqwOj-Dwut9pHZx0,45
-aider_ce-0.88.2.dist-info/top_level.txt,sha256=uwOA6ycgSiRLrBsaRBcIeN_eBKAX78U01_KDEHR8mBk,6
-aider_ce-0.88.2.dist-info/RECORD,,
+aider_ce-0.88.4.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+aider_ce-0.88.4.dist-info/METADATA,sha256=9NpL2hUk3EJMmZYIsg6JtqX80IqogsWzDTQTX-zo7zE,20820
+aider_ce-0.88.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aider_ce-0.88.4.dist-info/entry_points.txt,sha256=qUBEUd84DYNEHFSgZbgsjgsrAABxqwOj-Dwut9pHZx0,45
+aider_ce-0.88.4.dist-info/top_level.txt,sha256=uwOA6ycgSiRLrBsaRBcIeN_eBKAX78U01_KDEHR8mBk,6
+aider_ce-0.88.4.dist-info/RECORD,,