aider-ce 0.88.3__py3-none-any.whl → 0.88.5__py3-none-any.whl

aider/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.88.3.dev"
+__version__ = "0.88.5.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.3'
-__version_tuple__ = version_tuple = (0, 88, 3)
+__version__ = version = '0.88.5'
+__version_tuple__ = version_tuple = (0, 88, 5)
 
 __commit_id__ = commit_id = None

aider/args.py

@@ -315,7 +315,12 @@ def get_parser(default_config_files, git_root):
             " (default: current directory)"
         ),
     )
-
+    group.add_argument(
+        "--map-memory-cache",
+        action="store_true",
+        help="Store repo map in memory (default: False)",
+        default=False,
+    )
     ##########
     group = parser.add_argument_group("History Files")
     default_input_history_file = (
@@ -745,7 +750,14 @@ def get_parser(default_config_files, git_root):
         help="Print the system prompts and exit (debug)",
         default=False,
     )
-
+    group.add_argument(
+        "--linear-output",
+        action="store_true",
+        help=(
+            "Run input and output sequentially instead of us simultaneous streams (default: False)"
+        ),
+        default=False,
+    )
     ##########
     group = parser.add_argument_group("Voice settings")
     group.add_argument(

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
@@ -381,6 +381,7 @@ class Coder:
         map_cache_dir=".",
         repomap_in_memory=False,
         preserve_todo_list=False,
+        linear_output=False,
     ):
         # initialize from args.map_cache_dir
         self.map_cache_dir = map_cache_dir
@@ -469,6 +470,7 @@ class Coder:
 
         self.dry_run = dry_run
         self.pretty = self.io.pretty
+        self.linear_output = linear_output
 
         self.main_model = main_model
 
@@ -585,8 +587,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,18 +1057,71 @@ 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.linear_output:
+            return await self._run_linear(with_message, preproc)
+
         if self.io.prompt_session:
             with patch_stdout(raw=True):
                 return await self._run_patched(with_message, preproc)
         else:
             return await self._run_patched(with_message, preproc)
 
+    async def _run_linear(self, with_message=None, preproc=True):
+        try:
+            if with_message:
+                self.io.user_input(with_message)
+                await self.run_one(with_message, preproc)
+                return self.partial_response_content
+
+            user_message = None
+            await self.io.cancel_input_task()
+            await self.io.cancel_processing_task()
+
+            while True:
+                try:
+                    if self.commands.cmd_running:
+                        await asyncio.sleep(0.1)
+                        continue
+
+                    if not self.suppress_announcements_for_next_prompt:
+                        self.show_announcements()
+                    self.suppress_announcements_for_next_prompt = True
+
+                    self.io.input_task = asyncio.create_task(self.get_input())
+                    await asyncio.sleep(0)
+                    await self.io.input_task
+                    user_message = self.io.input_task.result()
+
+                    self.io.processing_task = asyncio.create_task(
+                        self._processing_logic(user_message, preproc)
+                    )
+
+                    await self.io.processing_task
+
+                    self.io.ring_bell()
+                    user_message = None
+                except KeyboardInterrupt:
+                    if self.io.input_task:
+                        self.io.set_placeholder("")
+                        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 (asyncio.CancelledError, IndexError):
+                    pass
+        except EOFError:
+            return
+        finally:
+            await self.io.cancel_input_task()
+            await self.io.cancel_processing_task()
+
     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 +1129,142 @@ 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 self.commands.cmd_running:
+                        await asyncio.sleep(0.1)
+                        continue
+
                     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()
+
+                                if self.commands.is_run_command(user_message):
+                                    self.commands.cmd_running = True
+
                             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):
                                 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 +1292,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,
@@ -1203,6 +1308,12 @@ class Coder:
             return
 
         if self.commands.is_command(inp):
+            if inp[0] in "!":
+                inp = f"/run {inp[1:]}"
+
+            if self.commands.is_run_command(inp):
+                self.commands.cmd_running = True
+
             return await self.commands.run(inp)
 
         await self.check_for_file_mentions(inp)
@@ -2704,7 +2815,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/commands.py

@@ -84,6 +84,7 @@ class Commands:
 
         # Store the original read-only filenames provided via args.read
         self.original_read_only_fnames = set(original_read_only_fnames or [])
+        self.cmd_running = False
 
     def cmd_model(self, args):
         "Switch the Main Model to a new LLM"
@@ -256,6 +257,9 @@ class Commands:
     def is_command(self, inp):
         return inp[0] in "/!"
 
+    def is_run_command(self, inp):
+        return inp and (inp[0] in "!" or inp[:5] == "/test" or inp[:4] == "/run")
+
     def get_raw_completions(self, cmd):
         assert cmd.startswith("/")
         cmd = cmd[1:]
@@ -1151,51 +1155,61 @@ class Commands:
 
     async def cmd_run(self, args, add_on_nonzero_exit=False):
         "Run a shell command and optionally add the output to the chat (alias: !)"
-        exit_status, combined_output = await asyncio.to_thread(
-            run_cmd,
-            args,
-            verbose=self.verbose,
-            error_print=self.io.tool_error,
-            cwd=self.coder.root,
-        )
+        try:
+            self.cmd_running = True
+            exit_status, combined_output = await asyncio.to_thread(
+                run_cmd,
+                args,
+                verbose=self.verbose,
+                error_print=self.io.tool_error,
+                cwd=self.coder.root,
+            )
+            self.cmd_running = False
 
-        if combined_output is None:
-            return
+            # This print statement, for whatever reason,
+            # allows the thread to properly yield control of the terminal
+            # to the main program
+            print("")
 
-        # Calculate token count of output
-        token_count = self.coder.main_model.token_count(combined_output)
-        k_tokens = token_count / 1000
+            if combined_output is None:
+                return
 
-        if add_on_nonzero_exit:
-            add = exit_status != 0
-        else:
-            add = await self.io.confirm_ask(
-                f"Add {k_tokens:.1f}k tokens of command output to the chat?"
-            )
+            # Calculate token count of output
+            token_count = self.coder.main_model.token_count(combined_output)
+            k_tokens = token_count / 1000
 
-        if add:
-            num_lines = len(combined_output.strip().splitlines())
-            line_plural = "line" if num_lines == 1 else "lines"
-            self.io.tool_output(f"Added {num_lines} {line_plural} of output to the chat.")
+            if add_on_nonzero_exit:
+                add = exit_status != 0
+            else:
+                add = await self.io.confirm_ask(
+                    f"Add {k_tokens:.1f}k tokens of command output to the chat?"
+                )
 
-            msg = prompts.run_output.format(
-                command=args,
-                output=combined_output,
-            )
+            if add:
+                num_lines = len(combined_output.strip().splitlines())
+                line_plural = "line" if num_lines == 1 else "lines"
+                self.io.tool_output(f"Added {num_lines} {line_plural} of output to the chat.")
 
-            self.coder.cur_messages += [
-                dict(role="user", content=msg),
-                dict(role="assistant", content="Ok."),
-            ]
+                msg = prompts.run_output.format(
+                    command=args,
+                    output=combined_output,
+                )
+
+                self.coder.cur_messages += [
+                    dict(role="user", content=msg),
+                    dict(role="assistant", content="Ok."),
+                ]
 
-            if add_on_nonzero_exit and exit_status != 0:
-                # Return the formatted output message for test failures
-                return msg
-            elif add and exit_status != 0:
-                self.io.placeholder = "What's wrong? Fix"
+                if add_on_nonzero_exit and exit_status != 0:
+                    # Return the formatted output message for test failures
+                    return msg
+                elif add and exit_status != 0:
+                    self.io.placeholder = "What's wrong? Fix"
 
-        # Return None if output wasn't added or command succeeded
-        return None
+            # Return None if output wasn't added or command succeeded
+            return None
+        finally:
+            self.cmd_running = False
 
     def cmd_exit(self, args):
         "Exit the application"

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."
@@ -459,8 +462,17 @@ 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 = ""
 
         # Validate color settings after console is initialized
         self._validate_color_settings()
@@ -657,16 +669,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
@@ -680,10 +684,8 @@ class InputOutput:
 
     def reject_outstanding_confirmations(self):
         """Reject all outstanding confirmation dialogs."""
-        for future in self.outstanding_confirmations:
-            if not future.done():
-                future.set_result(False)
-        self.outstanding_confirmations = []
+        # This method is now a no-op since we removed the confirmation_future logic
+        pass
 
     async def get_input(
         self,
@@ -695,12 +697,8 @@ class InputOutput:
         abs_read_only_stubs_fnames=None,
         edit_format=None,
     ):
-        self.reject_outstanding_confirmations()
         self.rule()
 
-        # Ring the bell if needed
-        self.ring_bell()
-
         rel_fnames = list(rel_fnames)
         show = ""
         if rel_fnames:
@@ -879,6 +877,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))
@@ -931,6 +934,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, IndexError):
+                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, IndexError):
+                pass
+
     def add_to_input_history(self, inp):
         if not self.input_history_file:
             return
@@ -1001,32 +1024,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,
@@ -1039,19 +1063,11 @@ 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()
-        self.outstanding_confirmations.append(confirmation_future)
-
         try:
             if question_id in self.never_prompts:
-                if not confirmation_future.done():
-                    confirmation_future.set_result(False)
-                return await confirmation_future
+                return False
 
             if group and not group.show_group:
                 group = None
@@ -1086,47 +1102,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
@@ -1136,9 +1150,7 @@ class InputOutput:
                         res = default
                         break
                     except asyncio.CancelledError:
-                        if not confirmation_future.done():
-                            confirmation_future.set_result(False)
-                        raise
+                        return False
 
                     if not res:
                         res = default
@@ -1157,9 +1169,7 @@ class InputOutput:
                 self.never_prompts.add(question_id)
                 hist = f"{question.strip()} {res}"
                 self.append_chat_history(hist, linebreak=True, blockquote=True)
-                if not confirmation_future.done():
-                    confirmation_future.set_result(False)
-                return await confirmation_future
+                return False
 
             if explicit_yes_required:
                 is_yes = res == "y"
@@ -1177,19 +1187,11 @@ class InputOutput:
 
             hist = f"{question.strip()} {res}"
             self.append_chat_history(hist, linebreak=True, blockquote=True)
-
-            if not confirmation_future.done():
-                confirmation_future.set_result(is_yes)
-
         except asyncio.CancelledError:
-            if not confirmation_future.done():
-                confirmation_future.set_result(False)
-            raise
+            return False
         finally:
-            if confirmation_future in self.outstanding_confirmations:
-                self.outstanding_confirmations.remove(confirmation_future)
-
-        return await confirmation_future
+            pass
+        return is_yes
 
     @restore_multiline
     def prompt_ask(self, question, default="", subject=None):
@@ -1241,17 +1243,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)
@@ -1056,6 +1057,9 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
             context_compaction_max_tokens=args.context_compaction_max_tokens,
             context_compaction_summary_tokens=args.context_compaction_summary_tokens,
             map_cache_dir=args.map_cache_dir,
+            repomap_in_memory=args.map_memory_cache,
+            preserve_todo_list=args.preserve_todo_list,
+            linear_output=args.linear_output,
         )
     except UnknownEditFormat as err:
         io.tool_error(str(err))

aider/queries/tree-sitter-languages/haskell-tags.scm

@@ -0,0 +1,3 @@
+(function  (variable) @name.definition.function)
+(bind      (variable) @name.definition.function)
+(signature (variable) @name.definition.type)

aider/queries/tree-sitter-languages/zig-tags.scm

@@ -0,0 +1,3 @@
+(FnProto) @name.definition.function
+(VarDecl "const" @name.definition.constant)
+(VarDecl "var"   @name.definition.variable)

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.3.dist-info → aider_ce-0.88.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-ce
-Version: 0.88.3
+Version: 0.88.5
 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.3.dist-info → aider_ce-0.88.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
-aider/__init__.py,sha256=wrKtj8dqyfjwH3Rlw7e1W9GVgUnjsG9nsUMYHBwb3Vo,496
+aider/__init__.py,sha256=1DZ03r447CFeqM5FT2f7BbovXi_RlzOLcnP79PsACpU,496
 aider/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
-aider/_version.py,sha256=enEulHZ1Bg_kUgfLWzNgkcmguOKMpRSnje8Z-0F49F4,706
+aider/_version.py,sha256=zZmH68H1r9949DHpJ12DEFhFY-78SXQLc-K3CKqklcc,706
 aider/analytics.py,sha256=c5ujaCcMc3yG-9rz_0oSsqBwmVQRxJnui6iE_yDyY_M,7507
-aider/args.py,sha256=lC64t3gp-SJ1Sv51LDHpTAsiU2ZwiFWerYf3iu9mtWY,32742
+aider/args.py,sha256=r9xdhB44K4LF2ru-cbOdaoHYzvG6CyViwcw9QRewEKw,33145
 aider/args_formatter.py,sha256=CBRnzHyZk-fFCK0ekAzb6C4PPJOU-VTpWIIsJe3qUhk,6369
 aider/change_tracker.py,sha256=djUlUuewhwRAlC0x6jIUZNpn6_PK1YyiNTMYvlvDeTE,4884
-aider/commands.py,sha256=TFQPjSy7y_BgU2WUB5cTQM2eCHFbd2UO86KGyNhLUVI,80529
+aider/commands.py,sha256=dbS-pqao-TSg35P9BDPiY5fRhLGwY5ZJyyIE-dAqlQw,81156
 aider/copypaste.py,sha256=J99QrXILUED_GPdEqxt7WjGZ5if8sfy0VQTzsV2jBrE,2095
 aider/deprecated.py,sha256=SNeAWR7ih87F5AyFpC4pxRoJAaw8measBW583w0EUT8,4277
 aider/diffs.py,sha256=y6_rxIKe3FPCIsVy_RRkHdofguYOhYBr2Oytr5AqjHI,3028
@@ -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=flltMLvPUnG7sDpfQC_XWICjXxhIy2EJGtdygSr0cvA,56836
+aider/io.py,sha256=6CKaWP5zWngaMjzS2lpy_pT84a_mGWgDcyFsazHKlTU,56543
 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=3IE18moiAP2nXs-NY_PJKk8PXS_pdzMvbefoNfT9CnQ,46520
 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=5R6AGbofXg1PeW-TF3pD0o5vWl1-Tn9lND2GhQlRRvI,132707
 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
@@ -125,6 +125,7 @@ aider/queries/tree-sitter-languages/elixir-tags.scm,sha256=eO20nPIwI7_vq4Fob6U5R
 aider/queries/tree-sitter-languages/elm-tags.scm,sha256=4qTEWJCAd7_BOfwyky0q_NYzAMtGdiq7qwo1GIhXmag,951
 aider/queries/tree-sitter-languages/fortran-tags.scm,sha256=BD6M5CVhMpINlLR7U9bL6STRwGLYBrMmvmldOHe1-9U,419
 aider/queries/tree-sitter-languages/go-tags.scm,sha256=mHtS5NEuxWJGfVz1rq4YlJRMYVDAl5tf7iYnm6RikVE,848
+aider/queries/tree-sitter-languages/haskell-tags.scm,sha256=mopkZ2Py3_Vl3xvpmaryzUVwYWAzl6GaYgmMb9qKD3Q,143
 aider/queries/tree-sitter-languages/hcl-tags.scm,sha256=yOVCBeF4C3ZrFG-gg0adWg2QkxylPcI2dbVeEgD7EPE,2137
 aider/queries/tree-sitter-languages/java-tags.scm,sha256=7WKb-djGv0Ief6XEWQPYpfLpgJHtMPPukIUi55PegvE,627
 aider/queries/tree-sitter-languages/javascript-tags.scm,sha256=svVct6pxbcYP_-xEBwzGy6t1SlN7ajkEUCivUkBZn_Q,2251
@@ -140,6 +141,7 @@ aider/queries/tree-sitter-languages/ruby-tags.scm,sha256=vIidsCeE2A0vdFN18yXKqUW
 aider/queries/tree-sitter-languages/rust-tags.scm,sha256=9ljM1nzhfPs_ZTRw7cr2P9ToOyhGcKkCoN4_HPXSWi4,1451
 aider/queries/tree-sitter-languages/scala-tags.scm,sha256=UxQjz80JIrrJ7Pm56uUnQyThfmQNvwk7aQzPNypB-Ao,1761
 aider/queries/tree-sitter-languages/typescript-tags.scm,sha256=OMdCeedPiA24ky82DpgTMKXK_l2ySTuF2zrQ2fJAi9E,1253
+aider/queries/tree-sitter-languages/zig-tags.scm,sha256=BPgov_nD_LqpL37sbdwsMYbFmHwjBOuRm76geKo29ds,124
 aider/resources/__init__.py,sha256=09npmZFptj6XR6ZeEuekpcK2stecKEjI59zR0Vz2JU8,142
 aider/resources/model-metadata.json,sha256=fFBW3iBFAZlhEPXyM-5_8qYEEOCx6tFqMu2Yh-5oBLI,28667
 aider/resources/model-settings.yml,sha256=bqpgKJRNZUcSlXyuZgTKFybf61kW5NRuoIVyOMZztwc,58325
@@ -261,9 +263,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.3.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-aider_ce-0.88.3.dist-info/METADATA,sha256=3XMMyoRjhPiiC-TNNFw4oVg3yUtLttJRCfvX03w5zBE,20820
-aider_ce-0.88.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aider_ce-0.88.3.dist-info/entry_points.txt,sha256=qUBEUd84DYNEHFSgZbgsjgsrAABxqwOj-Dwut9pHZx0,45
-aider_ce-0.88.3.dist-info/top_level.txt,sha256=uwOA6ycgSiRLrBsaRBcIeN_eBKAX78U01_KDEHR8mBk,6
-aider_ce-0.88.3.dist-info/RECORD,,
+aider_ce-0.88.5.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+aider_ce-0.88.5.dist-info/METADATA,sha256=uCUDJn4PseoYw1J-KczE4HLbg3JfANIPcjiKYkH48Zg,20820
+aider_ce-0.88.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aider_ce-0.88.5.dist-info/entry_points.txt,sha256=qUBEUd84DYNEHFSgZbgsjgsrAABxqwOj-Dwut9pHZx0,45
+aider_ce-0.88.5.dist-info/top_level.txt,sha256=uwOA6ycgSiRLrBsaRBcIeN_eBKAX78U01_KDEHR8mBk,6
+aider_ce-0.88.5.dist-info/RECORD,,