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

aider/commands.py

@@ -1,3 +1,4 @@
+import asyncio
 import glob
 import os
 import re
@@ -216,7 +217,7 @@ class Commands:
         else:
             self.io.tool_output("Please provide a partial model name to search for.")
 
-    def cmd_web(self, args, return_content=False):
+    async def cmd_web(self, args, return_content=False):
         "Scrape a webpage, convert to markdown and send in a message"
 
         url = args.strip()
@@ -230,7 +231,7 @@ class Commands:
             if disable_playwright:
                 res = False
             else:
-                res = install_playwright(self.io)
+                res = await install_playwright(self.io)
                 if not res:
                     self.io.tool_warning("Unable to initialize playwright.")
 
@@ -284,7 +285,7 @@ class Commands:
 
         return commands
 
-    def do_run(self, cmd_name, args):
+    async def do_run(self, cmd_name, args):
         cmd_name = cmd_name.replace("-", "_")
         cmd_method_name = f"cmd_{cmd_name}"
         cmd_method = getattr(self, cmd_method_name, None)
@@ -293,7 +294,10 @@ class Commands:
             return
 
         try:
-            return cmd_method(args)
+            if asyncio.iscoroutinefunction(cmd_method):
+                return await cmd_method(args)
+            else:
+                return cmd_method(args)
         except ANY_GIT_ERROR as err:
             self.io.tool_error(f"Unable to complete {cmd_name}: {err}")
 
@@ -309,10 +313,10 @@ class Commands:
         matching_commands = [cmd for cmd in all_commands if cmd.startswith(first_word)]
         return matching_commands, first_word, rest_inp
 
-    def run(self, inp):
+    async def run(self, inp):
         if inp.startswith("!"):
             self.coder.event("command_run")
-            return self.do_run("run", inp[1:])
+            return await self.do_run("run", inp[1:])
 
         res = self.matching_commands(inp)
         if res is None:
@@ -321,11 +325,11 @@ class Commands:
         if len(matching_commands) == 1:
             command = matching_commands[0][1:]
             self.coder.event(f"command_{command}")
-            return self.do_run(command, rest_inp)
+            return await self.do_run(command, rest_inp)
         elif first_word in matching_commands:
             command = first_word[1:]
             self.coder.event(f"command_{command}")
-            return self.do_run(command, rest_inp)
+            return await self.do_run(command, rest_inp)
         elif len(matching_commands) > 1:
             self.io.tool_error(f"Ambiguous command: {', '.join(matching_commands)}")
         else:
@@ -334,14 +338,14 @@ class Commands:
     # any method called cmd_xxx becomes a command automatically.
     # each one must take an args param.
 
-    def cmd_commit(self, args=None):
+    async def cmd_commit(self, args=None):
         "Commit edits to the repo made outside the chat (commit message optional)"
         try:
-            self.raw_cmd_commit(args)
+            await self.raw_cmd_commit(args)
         except ANY_GIT_ERROR as err:
             self.io.tool_error(f"Unable to complete commit: {err}")
 
-    def raw_cmd_commit(self, args=None):
+    async def raw_cmd_commit(self, args=None):
         if not self.coder.repo:
             self.io.tool_error("No git repository found.")
             return
@@ -351,9 +355,9 @@ class Commands:
             return
 
         commit_message = args.strip() if args else None
-        self.coder.repo.commit(message=commit_message, coder=self.coder)
+        await self.coder.repo.commit(message=commit_message, coder=self.coder)
 
-    def cmd_lint(self, args="", fnames=None):
+    async def cmd_lint(self, args="", fnames=None):
         "Lint and fix in-chat files or all dirty files if none in chat"
 
         if not self.coder.repo:
@@ -386,15 +390,15 @@ class Commands:
                 continue
 
             self.io.tool_output(errors)
-            if not self.io.confirm_ask(f"Fix lint errors in {fname}?", default="y"):
+            if not await self.io.confirm_ask(f"Fix lint errors in {fname}?", default="y"):
                 continue
 
             # Commit everything before we start fixing lint errors
             if self.coder.repo.is_dirty() and self.coder.dirty_commits:
-                self.cmd_commit("")
+                await self.cmd_commit("")
 
             if not lint_coder:
-                lint_coder = self.coder.clone(
+                lint_coder = await self.coder.clone(
                     # Clear the chat history, fnames
                     cur_messages=[],
                     done_messages=[],
@@ -402,11 +406,11 @@ class Commands:
                 )
 
             lint_coder.add_rel_fname(fname)
-            lint_coder.run(errors)
+            await lint_coder.run(errors)
             lint_coder.abs_fnames = set()
 
         if lint_coder and self.coder.repo.is_dirty() and self.coder.auto_commits:
-            self.cmd_commit("")
+            await self.cmd_commit("")
 
     def cmd_clear(self, args):
         "Clear the chat history"
@@ -857,7 +861,7 @@ class Commands:
         res = list(map(str, matched_files))
         return res
 
-    def cmd_add(self, args):
+    async def cmd_add(self, args):
         "Add files to the chat so aider can edit them or review them in detail"
 
         if not args.strip():
@@ -908,7 +912,9 @@ class Commands:
                 self.io.tool_output(f"You can add to git with: /git add {fname}")
                 continue
 
-            if self.io.confirm_ask(f"No files matched '{word}'. Do you want to create {fname}?"):
+            if await self.io.confirm_ask(
+                f"No files matched '{word}'. Do you want to create {fname}?"
+            ):
                 try:
                     fname.parent.mkdir(parents=True, exist_ok=True)
                     fname.touch()
@@ -1123,7 +1129,7 @@ class Commands:
 
         self.io.tool_output(combined_output)
 
-    def cmd_test(self, args):
+    async def cmd_test(self, args):
         "Run a shell command and add the output to the chat on non-zero exit code"
         if not args and self.coder.test_cmd:
             args = self.coder.test_cmd
@@ -1134,7 +1140,7 @@ class Commands:
         if not callable(args):
             if type(args) is not str:
                 raise ValueError(repr(args))
-            return self.cmd_run(args, True)
+            return await self.cmd_run(args, True)
 
         errors = args()
         if not errors:
@@ -1143,10 +1149,14 @@ class Commands:
         self.io.tool_output(errors)
         return errors
 
-    def cmd_run(self, args, add_on_nonzero_exit=False):
+    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 = run_cmd(
-            args, verbose=self.verbose, error_print=self.io.tool_error, cwd=self.coder.root
+        exit_status, combined_output = await asyncio.to_thread(
+            run_cmd,
+            args,
+            verbose=self.verbose,
+            error_print=self.io.tool_error,
+            cwd=self.coder.root,
         )
 
         if combined_output is None:
@@ -1159,7 +1169,9 @@ class Commands:
         if add_on_nonzero_exit:
             add = exit_status != 0
         else:
-            add = self.io.confirm_ask(f"Add {k_tokens:.1f}k tokens of command output to the chat?")
+            add = await self.io.confirm_ask(
+                f"Add {k_tokens:.1f}k tokens of command output to the chat?"
+            )
 
         if add:
             num_lines = len(combined_output.strip().splitlines())
@@ -1360,7 +1372,7 @@ class Commands:
         self.io.tool_output()
         self.io.tool_output("Use `/help <question>` to ask questions about how to use aider.")
 
-    def cmd_help(self, args):
+    async def cmd_help(self, args):
         "Ask questions about aider"
 
         if not args.strip():
@@ -1378,7 +1390,7 @@ class Commands:
 
             self.help = Help()
 
-        coder = Coder.create(
+        coder = await Coder.create(
             io=self.io,
             from_coder=self.coder,
             edit_format="help",
@@ -1393,7 +1405,7 @@ class Commands:
 """
         user_msg += "\n".join(self.coder.get_announcements()) + "\n"
 
-        coder.run(user_msg, preproc=False)
+        await coder.run(user_msg, preproc=False)
 
         if self.coder.repo_map:
             map_tokens = self.coder.repo_map.max_map_tokens
@@ -1426,39 +1438,39 @@ class Commands:
     def completions_navigator(self):
         raise CommandCompletionException()
 
-    def cmd_ask(self, args):
+    async def cmd_ask(self, args):
         """Ask questions about the code base without editing any files. If no prompt provided, switches to ask mode."""  # noqa
-        return self._generic_chat_command(args, "ask")
+        return await self._generic_chat_command(args, "ask")
 
-    def cmd_code(self, args):
+    async def cmd_code(self, args):
         """Ask for changes to your code. If no prompt provided, switches to code mode."""  # noqa
-        return self._generic_chat_command(args, self.coder.main_model.edit_format)
+        return await self._generic_chat_command(args, self.coder.main_model.edit_format)
 
-    def cmd_architect(self, args):
+    async def cmd_architect(self, args):
         """Enter architect/editor mode using 2 different models. If no prompt provided, switches to architect/editor mode."""  # noqa
-        return self._generic_chat_command(args, "architect")
+        return await self._generic_chat_command(args, "architect")
 
-    def cmd_context(self, args):
+    async def cmd_context(self, args):
         """Enter context mode to see surrounding code context. If no prompt provided, switches to context mode."""  # noqa
-        return self._generic_chat_command(args, "context", placeholder=args.strip() or None)
+        return await self._generic_chat_command(args, "context", placeholder=args.strip() or None)
 
-    def cmd_navigator(self, args):
+    async def cmd_navigator(self, args):
         """Enter navigator mode to autonomously discover and manage relevant files. If no prompt provided, switches to navigator mode."""  # noqa
         # Enable context management when entering navigator mode
         if hasattr(self.coder, "context_management_enabled"):
             self.coder.context_management_enabled = True
             self.io.tool_output("Context management enabled for large files")
 
-        return self._generic_chat_command(args, "navigator", placeholder=args.strip() or None)
+        return await self._generic_chat_command(args, "navigator", placeholder=args.strip() or None)
 
-    def _generic_chat_command(self, args, edit_format, placeholder=None):
+    async def _generic_chat_command(self, args, edit_format, placeholder=None):
         if not args.strip():
             # Switch to the corresponding chat mode if no args provided
             return self.cmd_chat_mode(edit_format)
 
         from aider.coders.base_coder import Coder
 
-        coder = Coder.create(
+        coder = await Coder.create(
             io=self.io,
             from_coder=self.coder,
             edit_format=edit_format,
@@ -1467,7 +1479,7 @@ class Commands:
         )
 
         user_msg = args
-        coder.run(user_msg)
+        await coder.run(user_msg)
 
         # Use the provided placeholder if any
         raise SwitchCoder(
@@ -1821,7 +1833,7 @@ class Commands:
     def completions_raw_load(self, document, complete_event):
         return self.completions_raw_read_only(document, complete_event)
 
-    def cmd_load(self, args):
+    async def cmd_load(self, args):
         "Load and execute commands from a file"
         if not args.strip():
             self.io.tool_error("Please provide a filename containing commands to load.")
@@ -1844,7 +1856,7 @@ class Commands:
 
             self.io.tool_output(f"\nExecuting: {cmd}")
             try:
-                self.run(cmd)
+                await self.run(cmd)
             except SwitchCoder:
                 self.io.tool_error(
                     f"Command '{cmd}' is only supported in interactive mode, skipping."

aider/history.py

@@ -30,13 +30,13 @@ class ChatSummary:
             sized.append((tokens, msg))
         return sized
 
-    def summarize(self, messages, depth=0):
-        messages = self.summarize_real(messages)
+    async def summarize(self, messages, depth=0):
+        messages = await self.summarize_real(messages)
         if messages and messages[-1]["role"] != "assistant":
             messages.append(dict(role="assistant", content="Ok."))
         return messages
 
-    def summarize_real(self, messages, depth=0):
+    async def summarize_real(self, messages, depth=0):
         if not self.models:
             raise ValueError("No models available for summarization")
 
@@ -48,11 +48,11 @@ class ChatSummary:
                 # All fit, no summarization needed
                 return messages
             # This is a chunk that's small enough to summarize in one go
-            return self.summarize_all(messages)
+            return await self.summarize_all(messages)
 
         min_split = 4
         if len(messages) <= min_split or depth > 4:
-            return self.summarize_all(messages)
+            return await self.summarize_all(messages)
 
         tail_tokens = 0
         split_index = len(messages)
@@ -78,13 +78,13 @@ class ChatSummary:
             split_index -= 1
 
         if split_index <= min_split:
-            return self.summarize_all(messages)
+            return await self.summarize_all(messages)
 
         # Split head and tail
         head = messages[:split_index]
         tail = messages[split_index:]
 
-        summary = self.summarize_real(head, depth + 1)
+        summary = await self.summarize_real(head, depth + 1)
 
         # If the combined summary and tail still fits, return directly
         new_messages = summary + tail
@@ -96,9 +96,9 @@ class ChatSummary:
             return new_messages
 
         # Otherwise recurse with increased depth
-        return self.summarize_real(new_messages, depth + 1)
+        return await self.summarize_real(new_messages, depth + 1)
 
-    def summarize_all(self, messages):
+    async def summarize_all(self, messages):
         content = ""
         for msg in messages:
             role = msg["role"].upper()
@@ -118,7 +118,7 @@ class ChatSummary:
 
         for model in self.models:
             try:
-                summary = model.simple_send_with_retries(summarize_messages)
+                summary = await model.simple_send_with_retries(summarize_messages)
                 if summary is not None:
                     summary = prompts.summary_prefix + summary
                     return [dict(role="user", content=summary)]
@@ -129,7 +129,7 @@ class ChatSummary:
         print(err)
         raise ValueError(err)
 
-    def summarize_all_as_text(self, messages, prompt, max_tokens=None):
+    async def summarize_all_as_text(self, messages, prompt, max_tokens=None):
         content = ""
         for msg in messages:
             role = msg["role"].upper()
@@ -149,7 +149,9 @@ class ChatSummary:
 
         for model in self.models:
             try:
-                summary = model.simple_send_with_retries(summarize_messages, max_tokens=max_tokens)
+                summary = await model.simple_send_with_retries(
+                    summarize_messages, max_tokens=max_tokens
+                )
                 if summary is not None:
                     return summary
             except Exception as e: