aider-ce 0.88.3__py3-none-any.whl → 0.88.6.dev7__py3-none-any.whl

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
@@ -968,7 +991,7 @@ class InputOutput:
         else:
             style = dict()
 
-        self.console.print(Text(inp), **style)
+        self.stream_print(Text(inp), **style)
 
     def user_input(self, inp, log_only=True):
         if not log_only:
@@ -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,20 +1243,25 @@ 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:
+            if color:
+                style["color"] = ensure_hash_prefix(color)
+
+        style = RichStyle(**style)
 
         try:
-            self.stream_print(message, **style)
+            self.stream_print(message, style=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=style)
 
-        if self.prompt_session and self.prompt_session.app:
-            self.prompt_session.app.invalidate()
+    def tool_success(self, message="", strip=True):
+        self._tool_message(message, strip, self.user_input_color)
 
     def tool_error(self, message="", strip=True):
         self.num_error_outputs += 1
@@ -1302,7 +1309,7 @@ class InputOutput:
         else:
             show_resp = Text(message or "(empty response)")
 
-        self.console.print(show_resp)
+        self.stream_print(show_resp)
 
     def render_markdown(self, text):
         output = StringIO()
@@ -1345,12 +1352,18 @@ class InputOutput:
 
         if not final:
             if len(lines) > 1:
-                self.console.print(output)
+                self.console.print(
+                    Text.from_ansi(output) if self.has_ansi_codes(output) else output
+                )
         else:
             # Ensure any remaining buffered content is printed using the full response
-            self.console.print(output)
+            self.console.print(Text.from_ansi(output) if self.has_ansi_codes(output) else output)
             self.reset_streaming_response()
 
+    def has_ansi_codes(self, s: str) -> bool:
+        """Check if a string contains the ANSI escape character."""
+        return "\x1b" in s
+
     def reset_streaming_response(self):
         self._stream_buffer = ""
         self._stream_line_count = 0

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/repo.py

@@ -310,7 +310,7 @@ class GitRepo:
                 # Perform the commit
                 self.repo.git.commit(cmd)
                 commit_hash = self.get_head_commit_sha(short=True)
-                self.io.tool_output(f"Commit {commit_hash} {commit_message}", bold=True)
+                self.io.tool_success(f"Commit {commit_hash} {commit_message}")
                 return commit_hash, commit_message
 
         except ANY_GIT_ERROR as err:

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/website/docs/sessions.md

@@ -0,0 +1,182 @@
+# Session Management
+
+Aider provides session management commands that allow you to save, load, and manage your chat sessions. This is particularly useful for:
+
+- Continuing work on complex projects across multiple sessions
+- Recreating specific development environments
+- Archiving important conversations and file configurations
+
+## Session Commands
+
+### `/save-session <name>`
+Save the current chat session to a named file in `.aider/sessions/`.
+
+**Usage:**
+```
+/save-session my-project-session
+```
+
+**What gets saved:**
+- Chat history (both done and current messages)
+- All files in the chat (editable, read-only, and read-only stubs)
+- Current model and edit format settings
+- Auto-commit, auto-lint, and auto-test settings
+- Session metadata (timestamp, version)
+
+### `/load-session <name>`
+Load a previously saved session by name or file path.
+
+**Usage:**
+```
+/load-session my-project-session
+```
+
+**What gets loaded:**
+- Restores chat history and file configurations
+- Recreates the exact session state
+- Preserves all settings and model configurations
+
+### `/list-sessions`
+List all available saved sessions in `.aider/sessions/`.
+
+**Usage:**
+```
+/list-sessions
+```
+
+**Shows:**
+- Session names
+- Model used
+- Edit format
+- Creation timestamp
+
+## How Sessions Work
+
+### Session Storage
+Sessions are stored as JSON files in the `.aider/sessions/` directory within your project. Each session file contains:
+
+```json
+{
+  "version": "1.0",
+  "timestamp": 1700000000,
+  "session_name": "my-session",
+  "model": "gpt-4",
+  "edit_format": "diff",
+  "chat_history": {
+    "done_messages": [...],
+    "cur_messages": [...]
+  },
+  "files": {
+    "editable": ["file1.py", "file2.js"],
+    "read_only": ["docs/README.md"],
+    "read_only_stubs": []
+  },
+  "settings": {
+    "root": "/path/to/project",
+    "auto_commits": true,
+    "auto_lint": false,
+    "auto_test": false
+  }
+}
+```
+
+### Session File Location
+- **Relative paths**: Files within your project are stored with relative paths
+- **Absolute paths**: External files are stored with absolute paths
+
+## Use Cases
+
+### Project Continuation
+```
+# Start working on a project
+/add src/main.py src/utils.py
+# ... have a conversation ...
+/save-session my-project
+
+# Later, continue where you left off
+/load-session my-project
+```
+
+### Multiple Contexts
+```
+# Work on frontend
+/add src/components/*.jsx src/styles/*.css
+/save-session frontend-work
+
+# Switch to backend
+/reset
+/add server/*.py database/*.sql
+/save-session backend-work
+
+# Easily switch between contexts
+/load-session frontend-work
+```
+
+## Best Practices
+
+### Naming Conventions
+- Use descriptive names: `feature-auth-session`, `bugfix-issue-123`
+- Include dates if needed: `2024-01-project-setup`
+
+### File Management
+- Session files include all file paths, so they work best when project structure is stable
+- External files (outside the project root) are stored with absolute paths
+- Missing files are skipped with warnings during loading
+
+### Version Control
+- Consider adding `.aider/sessions/` to your `.gitignore` if sessions contain sensitive information
+
+## Troubleshooting
+
+### Session Not Found
+If `/load-session` reports "Session not found":
+- Check that the session file exists in `.aider/sessions/`
+- Verify the session name matches exactly
+- Use `/list-sessions` to see available sessions
+
+### Missing Files
+If files are reported as missing during loading:
+- The files may have been moved or deleted
+- Session files store relative paths, so directory structure changes can affect this
+- External files must exist at their original locations
+
+### Corrupted Sessions
+If a session fails to load:
+- Check the session file is valid JSON
+- Verify the session version is compatible
+- Try creating a new session and compare file structures
+
+## Related Commands
+- `/reset` - Clear chat history and drop files (useful before loading a session)
+
+## Examples
+
+### Complete Workflow
+```
+# Start a new project session
+/add package.json src/main.js src/components/
+# ... work on the project ...
+/save-session react-project
+
+# Later, continue working
+/load-session react-project
+# All files and chat history are restored
+```
+
+### Session with External Files
+```
+# Include documentation from outside the project
+/read-only ~/docs/api-reference.md
+/save-session project-with-docs
+```
+
+### Multiple Model Sessions
+```
+# Save session with specific model
+/model gpt-4
+/save-session gpt4-session
+
+# Try different model
+/model claude-3
+/save-session claude-session
+```

{aider_ce-0.88.3.dist-info → aider_ce-0.88.6.dev7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-ce
-Version: 0.88.3
+Version: 0.88.6.dev7
 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: