aider-ce 0.88.4__tar.gz → 0.88.6__tar.gz

{aider_ce-0.88.4/aider_ce.egg-info → aider_ce-0.88.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-ce
-Version: 0.88.4
+Version: 0.88.6
 Summary: Aider is AI pair programming in your terminal
 Project-URL: Homepage, https://github.com/dwash96/aider-ce
 Classifier: Development Status :: 4 - Beta
@@ -146,6 +146,8 @@ This project aims to be compatible with upstream Aider, but with priority commit
 
 ### Other Notes
 * [MCP Configuration](https://github.com/dwash96/aider-ce/blob/main/aider/website/docs/config/mcp.md)
+* [Session Management](https://github.com/dwash96/aider-ce/blob/main/aider/website/docs/sessions.md)
+
 
 ### Installation Instructions
 This project can be installed using several methods:

{aider_ce-0.88.4 → aider_ce-0.88.6}/README.md

@@ -65,6 +65,8 @@ This project aims to be compatible with upstream Aider, but with priority commit
 
 ### Other Notes
 * [MCP Configuration](https://github.com/dwash96/aider-ce/blob/main/aider/website/docs/config/mcp.md)
+* [Session Management](https://github.com/dwash96/aider-ce/blob/main/aider/website/docs/sessions.md)
+
 
 ### Installation Instructions
 This project can be installed using several methods:

{aider_ce-0.88.4 → aider_ce-0.88.6}/aider/__init__.py

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

{aider_ce-0.88.4 → aider_ce-0.88.6}/aider/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.88.4'
-__version_tuple__ = version_tuple = (0, 88, 4)
+__version__ = version = '0.88.6'
+__version_tuple__ = version_tuple = (0, 88, 6)
 
-__commit_id__ = commit_id = 'g6752d1123'
+__commit_id__ = commit_id = 'g732c383a4'

{aider_ce-0.88.4 → aider_ce-0.88.6}/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_ce-0.88.4 → aider_ce-0.88.6}/aider/coders/base_coder.py

@@ -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
 
@@ -1058,12 +1060,67 @@ class Coder:
         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):
         try:
             if with_message:
@@ -1077,6 +1134,10 @@ class Coder:
 
             while True:
                 try:
+                    if self.commands.cmd_running:
+                        await asyncio.sleep(0.1)
+                        continue
+
                     if (
                         not self.io.confirmation_in_progress
                         and not user_message
@@ -1134,6 +1195,10 @@ class Coder:
                             try:
                                 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
 
@@ -1170,7 +1235,6 @@ class Coder:
                                         user_message = None
 
                             except (asyncio.CancelledError, KeyboardInterrupt):
-                                print("error of some sort")
                                 pass
 
                             # Stop spinner when processing task completes
@@ -1180,6 +1244,7 @@ class Coder:
                         self.io.processing_task = asyncio.create_task(
                             self._processing_logic(user_message, preproc)
                         )
+
                         # Start spinner for processing task
                         self.io.start_spinner("Processing...")
 
@@ -1243,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)
@@ -1254,8 +1325,6 @@ 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
@@ -1859,6 +1928,7 @@ class Coder:
         self.usage_report = None
         exhausted = False
         interrupted = False
+
         try:
             while True:
                 try:
@@ -2392,7 +2462,7 @@ class Coder:
                 return (server.name, server_tools)
             except Exception as e:
                 if server.name != "unnamed-server":
-                    self.io.tool_warning(f"Error initializing MCP server {server.name}:\n{e}")
+                    self.io.tool_warning(f"Error initializing MCP server {server.name}: {e}")
                 return None
 
         async def get_all_server_tools():

{aider_ce-0.88.4 → aider_ce-0.88.6}/aider/commands.py

@@ -1,11 +1,14 @@
 import asyncio
 import glob
+import json
 import os
 import re
 import subprocess
 import sys
 import tempfile
+import time
 from collections import OrderedDict
+from datetime import datetime
 from os.path import expanduser
 from pathlib import Path
 
@@ -84,6 +87,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 +260,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 +1158,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,
+                )
 
-            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"
+                self.coder.cur_messages += [
+                    dict(role="user", content=msg),
+                    dict(role="assistant", content="Ok."),
+                ]
 
-        # Return None if output wasn't added or command succeeded
-        return None
+                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
+        finally:
+            self.cmd_running = False
 
     def cmd_exit(self, args):
         "Exit the application"
@@ -1476,19 +1493,12 @@ class Commands:
             edit_format=edit_format,
             summarize_from_coder=False,
             num_cache_warming_pings=0,
+            aider_commit_hashes=self.coder.aider_commit_hashes,
         )
 
         user_msg = args
-        await coder.run(user_msg)
-
-        # Use the provided placeholder if any
-        raise SwitchCoder(
-            edit_format=self.coder.edit_format,
-            summarize_from_coder=False,
-            from_coder=coder,
-            show_announcements=False,
-            placeholder=placeholder,
-        )
+        await coder.run(user_msg, False)
+        self.coder.aider_commit_hashes = coder.aider_commit_hashes
 
     def get_help_md(self):
         "Show help about all commands in markdown"
@@ -2021,6 +2031,197 @@ class Commands:
         announcements = "\n".join(self.coder.get_announcements())
         self.io.tool_output(announcements)
 
+    def _get_session_directory(self):
+        """Get the session storage directory, creating it if needed"""
+        session_dir = Path(self.coder.root) / ".aider" / "sessions"
+        session_dir.mkdir(parents=True, exist_ok=True)
+        return session_dir
+
+    def _get_session_file_path(self, session_name):
+        """Get the full path for a session file"""
+        session_dir = self._get_session_directory()
+        # Sanitize the session name to be filesystem-safe
+        safe_name = re.sub(r"[^a-zA-Z0-9_.-]", "_", session_name)
+        return session_dir / f"{safe_name}.json"
+
+    def _find_session_file(self, session_name):
+        """Find a session file by name, checking both name-based and full path"""
+        # First check if it's a full path
+        if Path(session_name).exists():
+            return Path(session_name)
+
+        # Then check in the sessions directory
+        session_file = self._get_session_file_path(session_name)
+        if session_file.exists():
+            return session_file
+
+        return None
+
+    def cmd_save_session(self, args):
+        """Save the current chat session to a named file in .aider/sessions/"""
+        if not args.strip():
+            self.io.tool_error("Please provide a session name.")
+            return
+
+        session_name = args.strip()
+        session_file = self._get_session_file_path(session_name)
+
+        # Collect session data
+        session_data = {
+            "version": "1.0",
+            "timestamp": time.time(),
+            "session_name": session_name,
+            "model": self.coder.main_model.name,
+            "edit_format": self.coder.edit_format,
+            "chat_history": {
+                "done_messages": self.coder.done_messages,
+                "cur_messages": self.coder.cur_messages,
+            },
+            "files": {
+                "editable": [self.coder.get_rel_fname(f) for f in self.coder.abs_fnames],
+                "read_only": [self.coder.get_rel_fname(f) for f in self.coder.abs_read_only_fnames],
+                "read_only_stubs": [
+                    self.coder.get_rel_fname(f) for f in self.coder.abs_read_only_stubs_fnames
+                ],
+            },
+            "settings": {
+                "root": self.coder.root,
+                "auto_commits": self.coder.auto_commits,
+                "auto_lint": self.coder.auto_lint,
+                "auto_test": self.coder.auto_test,
+            },
+        }
+
+        try:
+            with open(session_file, "w", encoding="utf-8") as f:
+                json.dump(session_data, f, indent=2, ensure_ascii=False)
+            self.io.tool_output(f"Session saved to: {session_file}")
+        except Exception as e:
+            self.io.tool_error(f"Error saving session: {e}")
+
+    def cmd_list_sessions(self, args):
+        """List all saved sessions in .aider/sessions/"""
+        session_dir = self._get_session_directory()
+        session_files = list(session_dir.glob("*.json"))
+
+        if not session_files:
+            self.io.tool_output("No saved sessions found.")
+            return
+
+        self.io.tool_output("Saved sessions:")
+        for session_file in sorted(session_files):
+            try:
+                with open(session_file, "r", encoding="utf-8") as f:
+                    session_data = json.load(f)
+                session_name = session_data.get("session_name", session_file.stem)
+                timestamp = session_data.get("timestamp", 0)
+                model = session_data.get("model", "unknown")
+                edit_format = session_data.get("edit_format", "unknown")
+
+                # Format timestamp
+                if timestamp:
+                    date_str = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M")
+                else:
+                    date_str = "unknown date"
+
+                self.io.tool_output(
+                    f"  {session_name} (model: {model}, format: {edit_format}, {date_str})"
+                )
+            except Exception as e:
+                self.io.tool_output(f"  {session_file.stem} [error reading: {e}]")
+
+    def cmd_load_session(self, args):
+        """Load a saved session by name or file path"""
+        if not args.strip():
+            self.io.tool_error("Please provide a session name or file path.")
+            return
+
+        session_name = args.strip()
+        session_file = self._find_session_file(session_name)
+
+        if not session_file:
+            self.io.tool_error(f"Session not found: {session_name}")
+            self.io.tool_output("Use /list-sessions to see available sessions.")
+            return
+
+        try:
+            with open(session_file, "r", encoding="utf-8") as f:
+                session_data = json.load(f)
+        except Exception as e:
+            self.io.tool_error(f"Error loading session: {e}")
+            return
+
+        # Verify session format
+        if not isinstance(session_data, dict) or "version" not in session_data:
+            self.io.tool_error("Invalid session format.")
+            return
+
+        # Load session data
+        try:
+            # Clear current state
+            self.coder.abs_fnames = set()
+            self.coder.abs_read_only_fnames = set()
+            self.coder.abs_read_only_stubs_fnames = set()
+            self.coder.done_messages = []
+            self.coder.cur_messages = []
+
+            # Load chat history
+            chat_history = session_data.get("chat_history", {})
+            self.coder.done_messages = chat_history.get("done_messages", [])
+            self.coder.cur_messages = chat_history.get("cur_messages", [])
+
+            # Load files
+            files = session_data.get("files", {})
+            for rel_fname in files.get("editable", []):
+                abs_fname = self.coder.abs_root_path(rel_fname)
+                if os.path.exists(abs_fname):
+                    self.coder.abs_fnames.add(abs_fname)
+                else:
+                    self.io.tool_warning(f"File not found, skipping: {rel_fname}")
+
+            for rel_fname in files.get("read_only", []):
+                abs_fname = self.coder.abs_root_path(rel_fname)
+                if os.path.exists(abs_fname):
+                    self.coder.abs_read_only_fnames.add(abs_fname)
+                else:
+                    self.io.tool_warning(f"File not found, skipping: {rel_fname}")
+
+            for rel_fname in files.get("read_only_stubs", []):
+                abs_fname = self.coder.abs_root_path(rel_fname)
+                if os.path.exists(abs_fname):
+                    self.coder.abs_read_only_stubs_fnames.add(abs_fname)
+                else:
+                    self.io.tool_warning(f"File not found, skipping: {rel_fname}")
+
+            # Load settings
+            settings = session_data.get("settings", {})
+            if "auto_commits" in settings:
+                self.coder.auto_commits = settings["auto_commits"]
+            if "auto_lint" in settings:
+                self.coder.auto_lint = settings["auto_lint"]
+            if "auto_test" in settings:
+                self.coder.auto_test = settings["auto_test"]
+
+            self.io.tool_output(
+                f"Session loaded: {session_data.get('session_name', session_file.stem)}"
+            )
+            self.io.tool_output(
+                f"Model: {session_data.get('model', 'unknown')}, Edit format:"
+                f" {session_data.get('edit_format', 'unknown')}"
+            )
+
+            # Show summary
+            num_messages = len(self.coder.done_messages) + len(self.coder.cur_messages)
+            num_files = (
+                len(self.coder.abs_fnames)
+                + len(self.coder.abs_read_only_fnames)
+                + len(self.coder.abs_read_only_stubs_fnames)
+            )
+            self.io.tool_output(f"Loaded {num_messages} messages and {num_files} files")
+
+        except Exception as e:
+            self.io.tool_error(f"Error applying session data: {e}")
+
     def cmd_copy_context(self, args=None):
         """Copy the current chat context as markdown, suitable to paste into a web UI"""
 

{aider_ce-0.88.4 → aider_ce-0.88.6}/aider/exceptions.py

@@ -71,6 +71,9 @@ class LiteLLMExceptions:
             ex = getattr(litellm, var, "default")
 
             if ex != "default":
+                if not issubclass(ex, BaseException):
+                    continue
+
                 self.exceptions[ex] = self.exception_info[var]
 
     def exceptions_tuple(self):