aider-ce 0.88.20__py3-none-any.whl

aider/website/docs/recordings/auto-accept-architect.md

@@ -0,0 +1,31 @@
+---
+parent: Screen recordings
+nav_order: 1
+layout: minimal
+highlight_image: /assets/recordings.jpg
+description: See how a new command-line option is added to automatically accept edits proposed by the architect model, with implementation. Aider also updates the project's HISTORY file.
+---
+
+# Add --auto-accept-architect feature
+
+<script>
+const recording_id = "auto-accept-architect";
+const recording_url = "https://gist.githubusercontent.com/paul-gauthier/e7383fbc29c9bb343ee6fb7ee5d77e15/raw/c2194334085304bb1c6bb80814d791704d9719b6/707774.cast";
+</script>
+
+{% include recording.md %}
+
+## Commentary
+
+- 0:01 We're going to add a new feature to automatically accept edits proposed by the architect model.
+- 0:11 First, let's add the new switch.
+- 0:40 Aider figured out that it should be passed to the Coder class.
+- 0:48 Now we need to implement the functionality.
+- 1:00 Let's do some manual testing.
+- 1:28 That worked. Let's make sure we can turn it off too.
+- 1:42 That worked too. Let's have aider update the HISTORY file to document the new feature.
+- 2:00 Let's quickly tidy up the changes to HISTORY.
+- 2:05 All done!
+
+
+

aider/website/docs/recordings/dont-drop-original-read-files.md

@@ -0,0 +1,35 @@
+---
+parent: Screen recordings
+nav_order: 1
+layout: minimal
+highlight_image: /assets/recordings.jpg
+description: Follow along as aider is modified to preserve read-only files specified at launch when using the /drop command. Aider does this implementation and adds test coverage.
+---
+
+# Don't /drop read-only files added at launch
+
+<script>
+const recording_id = "dont-drop-original-read-files";
+const recording_url = "https://gist.githubusercontent.com/paul-gauthier/c2e7b2751925fb7bb47036cdd37ec40d/raw/08e62ab539e2b5d4b52c15c31d9a0d241377c17c/707583.cast";
+</script>
+
+{% include recording.md %}
+
+## Commentary
+
+- 0:01 We're going to update the /drop command to keep any read only files that were originally specified at launch.
+- 0:10 We've added files that handle the main CLI and in-chat slash commands like /drop.
+- 0:20 Let's explain the needed change to aider.
+- 1:20 Ok, let's look at the code.
+- 1:30 I'd prefer not to use "hasattr()", let's ask for improvements.
+- 1:45 Let's try some manual testing.
+- 2:10 Looks good. Let's check the existing test suite to ensure we didn't break anything.
+- 2:19 Let's ask aider to add tests for this.
+- 2:50 Tests look reasonable, we're done!
+
+
+
+
+
+
+

aider/website/docs/recordings/index.md

@@ -0,0 +1,21 @@
+---
+title: Screen recordings
+has_children: true
+nav_order: 75
+has_toc: false
+description: Screen recordings of aider building aider.
+highlight_image: /assets/recordings.jpg
+---
+
+# Screen recordings
+
+Below are a series of screen recordings of the aider developer using aider
+to enhance aider.
+They contain commentary that describes how aider is being used,
+and might provide some inspiration for your own use of aider.
+
+{% assign sorted_pages = site.pages | where: "parent", "Screen recordings" | sort: "nav_order" %}
+{% for page in sorted_pages %}
+- [{{ page.title }}]({{ page.url | relative_url }}) - {{ page.description }}
+{% endfor %}
+

aider/website/docs/recordings/model-accepts-settings.md

@@ -0,0 +1,69 @@
+---
+parent: Screen recordings
+nav_order: 1
+layout: minimal
+highlight_image: /assets/recordings.jpg
+description: Watch the implementation of a warning system that alerts users when they try to apply reasoning settings to models that don't support them. Includes adding model metadata, confirmation dialogs, refactoring, and comprehensive test coverage.
+---
+
+# Warn when users apply unsupported reasoning settings
+
+<script>
+const recording_id = "model-accepts-settings";
+const recording_url = "https://gist.githubusercontent.com/paul-gauthier/66b1b5aa7136147702c98afc4987c0d4/raw/4b5c7ddf7e80db1ff4dfa78fe158bc000fc42e0e/accepts-settings.cast";
+</script>
+
+{% include recording.md %}
+
+## Commentary
+
+- 0:01 Users sometimes run aider with "reasoning" settings that aren't supported by the model they're using. This can cause LLM API calls to completely fail, with non-specific error messages from the API provider. We're going to warn users up front to prevent this.
+- 0:25 Ok, let's ask aider to add a new model setting where we can note which reasoning settings it supports. And then print a warning if the user tries to apply an unsupported setting.
+- 1:30 Looks like it's including some extra changes we don't want.
+- 1:45 Let's have a look at the models code and clean up some stray lines.
+- 2:00 It also made the warning logic too conservative. We want to warn unless the setting is explicitly known to be supported.
+- 3:00 Ok, good. Now lets add a setting to silence these warnings for power users who are doing something intentional.
+- 3:45 Now we need to update the database of model settings to annotate which models support which reasoning settings. We'll start with the code that handles "fallback" settings for known models on unknown providers.
+- 4:45 Oh, we forgot to give aider the actual file with that code! Aider asks to see it.
+- 5:00 Ok, we've confused aider by asking it to change code it couldn't see.
+- 5:10 Let's clear the chat and refine the prompt and try again.
+- 6:00 Ok, looks good. Let's move on and update the full model settings database YAML file. Each main model like "o1" appears here from many providers, like OpenAI, OpenRouter, etc. We want to update them all.
+- 7:43 Let's interrupt and refine the prompt to be more clear about which models to update.
+- 9:20 Looks good. Let's review the YAML file and eyeball all the relevant models.
+- 10:20 Now let's do some manual testing.
+- 10:41 Ok, it should not be warning us about using "thinking tokens" with Sonnet 3.7.
+- 10:55 Let's see if aider can spot the problem?
+- 11:28 That doesn't sound like a promising solution. Let's add more of the relevant code, clear history and try again.
+- 12:00 Ok, let's try aider's proposed solution.
+- 12:32 And see if it worked... Nope! Still getting the unneeded warning. Undo that change!
+- 12:48 Time for some manual print debugging.
+- 13:00 It seems like the "accept_settings" value is not being set?
+- 14:30 Aha! I have a local model settings file for Sonnet which overrides aider's built in settings. And we did not update it. Let's add "accepts_settings" there.
+- 14:45 That was the problem, it wasn't a bug.
+- 14:59 Ok, let's add test coverage for all this stuff.
+- 15:09 And while aider writes tests, let's use "git diff" to review all the changes we've made.
+- 15:34 Aider is done writing tests, let's try them.
+- 15:44 One passed, one failed. Let's eyeball the passing test first.
+- 16:04 And let's see if aider can fix the failing test.
+- 16:14 Aider needs to see another file, which makes sense.
+- 16:29 It's found the problem, but is trying to "fix" the code. We want it to fix the test.
+- 16:47 Ok, tests are passing.
+- 16:55 We should stop and ask the user "are you sure?", not just flash a warning if they're about to break their API calls.
+- 17:59 Ok, that confirmation dialog looks good.
+- 18:35 This code is a little bit repetitive. Let's do a bit of refactoring.
+- 19:44 Sonnet is messing up the code editing instructions, so aider is retrying.
+- 19:54 Let's clear the chat history and try again.
+- 20:25 Are tests still passing after the refactor?
+- 20:55 Tests passed, good. Let's tweak the warning text.
+- 21:10 And now let's have aider update the docs to explain these changes.
+- 22:32 Let's proofread and edit the updated docs.
+- 24:25 And a "git diff" of all the docs changes to do a final check.
+- 24:56 Let's have aider update the project's HISTORY file.
+- 25:35 We can refine the HISTORY entries a bit.
+- 26:20 All done!
+
+
+
+
+
+

aider/website/docs/recordings/tree-sitter-language-pack.md

@@ -0,0 +1,80 @@
+---
+parent: Screen recordings
+nav_order: 0
+layout: minimal
+highlight_image: /assets/recordings.jpg
+description: Watch how aider adds support for tons of new programming languages by integrating with tree-sitter-language-pack. Demonstrates using aider to script downloading a collection of files, and using ad-hoc bash scripts to have aider modify a collection of files.
+---
+
+# Add language support via tree-sitter-language-pack
+
+<script>
+const recording_id = "tree-sitter-language-pack";
+const recording_url = "https://gist.githubusercontent.com/paul-gauthier/a990333449b09e2793088a45eb1587f4/raw/364124781cca282907ccdc7567cdfc588a9b438b/tmp.redacted.cast";
+</script>
+
+{% include recording.md %}
+
+
+## Commentary
+
+- 0:01 We're going to add a ton of new languages to aider via tree-sitter-language-pack.
+- 0:10 First, lets try and find which languages it supports.
+- 1:00 Ok, there's a language definitions json file
+- 1:10 Does it have the github repos for each language?
+- 1:29 Ok, this is what we need.
+- 1:45 We need to get all the tags files from each repository for aider's repo-map. Let's have aider write a script to fetch them all.
+- 2:05 We'll show aider the language definitions json file.
+- 3:37 Looks like it can't find most of the tags.scm files.
+- 4:19 Maybe we should have it try other branches besides master?
+- 5:02 Ok, it seems to be downloading them now.
+- 5:55 Let's make it so we can re-run the script and only download files we haven't fetched yet.
+- 6:12 I see lots of tags files, so it's working.
+- 6:30 Ok, restart to run with latest code. This will take awhile to fetch them all.
+- 9:02 The Grep-AST module needs to know about all the new languages.
+- 9:45 Let's have aider add them all, and register each using their commonly used file extensions.
+- 10:15 Some of the languages need to be recognized by their base name, not by their extension.
+- 11:15 Let's sanity check if Grep-AST can handle PowerShell, one of the new languages.
+- 12:00 Looks like it's parsing PowerShell fine.
+- 13:00 Ok, let's download all the tags files into the right spot in the aider repo.
+- 14:00 This will take a minute...
+- 16:07 Delete some no-op or empty tags files.
+- 16:16 Let's commit all the unmodified tags files.
+- 16:33 We need to update each tag file, so that aider can identify names of functions, classes, etc in all these languages.
+- 17:01 Let's use a bash loop to script aider to modify each tags file.
+- 17:12 I'm giving aider a read-only example of an already modified tags file, as an example to follow.
+- 19:04 Looks like it correctly updated the first couple of tags files.
+- 19:28 Let's grep to watch aider's progress working through the list of files.
+- 20:20 It's working on the Dart language now...
+- 20:50 E-lisp is up next...
+- 21:30 This is going to take a little while...
+- 24:39 Let's add a README file with attribution for these tags files.
+- 26:55 Ok, all the files are updated with tags for definitions and references to named code objects.
+- 27:10 Let's add test coverage to be sure these languages work with the repo-map.
+- 27:19 Each language needs a "fixture" with some sample code to parse during the test. Let's show aider the layout of the fixtures directory.
+- 27:50 We can use a bash loop to ask aider to add test coverage for each new tags file.
+- 28:12 We'll pass the fixtures directory listing to aider.
+- 28:52 Just need to fix the bash to correctly iterate through the list of tags files.
+- 29:27 I forgot to ask aider to actually generate a sample code fixture for each language.
+- 30:25 Lets run the repo-map tests to see if the first new test works.
+- 30:37 Tests for the Arduino language failed, with an empty repo-map? That's not good.
+- 31:52 Can aider figure out what's wrong?
+- 32:27 Well, aider made the test pass by basically skipping Arduino.
+- 32:36 Let me see if I can use Grep-AST on the new Arduino fixture code.
+- 32:42 Oh! I'm not using the updated Grep-AST that knows about all the new languages.
+- 32:54 Ok, now we're parsing Arduino code properly. Undo aider's bogus test fix.
+- 33:05 Ok, arduino passes now but there seems to be a regression with tsx?
+- 33:20 Can aider figure out why?
+- 34:10 Let's check the parsers map.
+- 35:00 Well, that's all for this recording. The tsx problem was due to a bad mapping from ".tsx" to "typescript" in the map that aider generated earlier.
+
+
+
+
+
+
+
+
+
+
+

aider/website/docs/repomap.md

@@ -0,0 +1,112 @@
+---
+parent: More info
+highlight_image: /assets/robot-ast.png
+nav_order: 300
+description: Aider uses a map of your git repository to provide code context to LLMs.
+---
+
+# Repository map
+
+![robot flowchat](/assets/robot-ast.png)
+
+Aider
+uses a **concise map of your whole git repository**
+that includes
+the most important classes and functions along with their types and call signatures.
+This helps aider understand the code it's editing
+and how it relates to the other parts of the codebase.
+The repo map also helps aider write new code
+that respects and utilizes existing libraries, modules and abstractions
+found elsewhere in the codebase.
+
+## Using a repo map to provide context
+
+Aider sends a **repo map** to the LLM along with
+each change request from the user.
+The repo map contains a list of the files in the
+repo, along with the key symbols which are defined in each file.
+It shows how each of these symbols are defined, by including the critical lines of code for each definition.
+
+Here's a part of
+the repo map of aider's repo, for
+[base_coder.py](https://github.com/Aider-AI/aider/blob/main/aider/coders/base_coder.py)
+and
+[commands.py](https://github.com/Aider-AI/aider/blob/main/aider/commands.py)
+:
+
+```
+aider/coders/base_coder.py:
+⋮...
+│class Coder:
+│    abs_fnames = None
+⋮...
+│    @classmethod
+│    def create(
+│        self,
+│        main_model,
+│        edit_format,
+│        io,
+│        skip_model_availabily_check=False,
+│        **kwargs,
+⋮...
+│    def abs_root_path(self, path):
+⋮...
+│    def run(self, with_message=None):
+⋮...
+
+aider/commands.py:
+⋮...
+│class Commands:
+│    voice = None
+│
+⋮...
+│    def get_commands(self):
+⋮...
+│    def get_command_completions(self, cmd_name, partial):
+⋮...
+│    def run(self, inp):
+⋮...
+```
+
+Mapping out the repo like this provides some key benefits:
+
+  - The LLM can see classes, methods and function signatures from everywhere in the repo. This alone may give it enough context to solve many tasks. For example, it can probably figure out how to use the API exported from a module just based on the details shown in the map.
+  - If it needs to see more code, the LLM can use the map to figure out which files it needs to look at. The LLM can ask to see these specific files, and aider will offer to add them to the chat context.
+
+## Optimizing the map
+
+Of course, for large repositories even just the repo map might be too large
+for the LLM's context window.
+Aider solves this problem by sending just the **most relevant**
+portions of the repo map.
+It does this by analyzing the full repo map using
+a graph ranking algorithm, computed on a graph
+where each source file is a node and edges connect
+files which have dependencies.
+Aider optimizes the repo map by
+selecting the most important parts of the codebase
+which will
+fit into the active token budget.
+The optimization identifies and maps the portions of the code base
+which are most relevant to the current state of the chat.
+
+The token budget is
+influenced by the `--map-tokens` switch, which defaults to 1k tokens.
+Aider adjusts the size of the repo map dynamically based on the state of the chat. It will usually stay within that setting's value. But it does expand the repo map
+significantly at times, especially when no files have been added to the chat and aider needs to understand the entire repo as best as possible.
+
+
+The sample map shown above doesn't contain *every* class, method and function from those
+files.
+It only includes the most important identifiers,
+the ones which are most often referenced by other portions of the code.
+These are the key pieces of context that the LLM needs to know to understand
+the overall codebase.
+
+
+## More info
+
+Please check the
+[repo map article on aider's blog](https://aider.chat/2023/10/22/repomap.html)
+for more information on aider's repository map
+and how it is constructed.

aider/website/docs/scripting.md

@@ -0,0 +1,100 @@
+---
+parent: More info
+nav_order: 400
+description: You can script aider via the command line or python.
+---
+
+# Scripting aider
+
+You can script aider via the command line or python.
+
+## Command line
+
+Aider takes a `--message` argument, where you can give it a natural language instruction.
+It will do that one thing, apply the edits to the files and then exit.
+So you could do:
+
+```bash
+aider --message "make a script that prints hello" hello.js
+```
+
+Or you can write simple shell scripts to apply the same instruction to many files:
+
+```bash
+for FILE in *.py ; do
+    aider --message "add descriptive docstrings to all the functions" $FILE
+done
+```
+
+Use `aider --help` to see all the 
+[command line options](/docs/config/options.html),
+but these are useful for scripting:
+
+```
+--stream, --no-stream
+                      Enable/disable streaming responses (default: True) [env var:
+                      AIDER_STREAM]
+--message COMMAND, --msg COMMAND, -m COMMAND
+                      Specify a single message to send GPT, process reply then exit
+                      (disables chat mode) [env var: AIDER_MESSAGE]
+--message-file MESSAGE_FILE, -f MESSAGE_FILE
+                      Specify a file containing the message to send GPT, process reply,
+                      then exit (disables chat mode) [env var: AIDER_MESSAGE_FILE]
+--yes                 Always say yes to every confirmation [env var: AIDER_YES]
+--auto-commits, --no-auto-commits
+                      Enable/disable auto commit of GPT changes (default: True) [env var:
+                      AIDER_AUTO_COMMITS]
+--dirty-commits, --no-dirty-commits
+                      Enable/disable commits when repo is found dirty (default: True) [env
+                      var: AIDER_DIRTY_COMMITS]
+--dry-run, --no-dry-run
+                      Perform a dry run without modifying files (default: False) [env var:
+                      AIDER_DRY_RUN]
+--commit              Commit all pending changes with a suitable commit message, then exit
+                      [env var: AIDER_COMMIT]
+```
+
+
+## Python
+
+You can also script aider from python:
+
+```python
+from aider.coders import Coder
+from aider.models import Model
+
+# This is a list of files to add to the chat
+fnames = ["greeting.py"]
+
+model = Model("gpt-4-turbo")
+
+# Create a coder object
+coder = Coder.create(main_model=model, fnames=fnames)
+
+# This will execute one instruction on those files and then return
+coder.run("make a script that prints hello world")
+
+# Send another instruction
+coder.run("make it say goodbye")
+
+# You can run in-chat "/" commands too
+coder.run("/tokens")
+
+```
+
+See the
+[Coder.create() and Coder.__init__() methods](https://github.com/Aider-AI/aider/blob/main/aider/coders/base_coder.py)
+for all the supported arguments.
+
+It can also be helpful to set the equivalent of `--yes` by doing this:
+
+```python
+from aider.io import InputOutput
+io = InputOutput(yes=True)
+# ...
+coder = Coder.create(model=model, fnames=fnames, io=io)
+```
+
+{: .note }
+The python scripting API is not officially supported or documented,
+and could change in future releases without providing backwards compatibility.

aider/website/docs/sessions.md

@@ -0,0 +1,203 @@
+# 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/`.
+
+### Auto-Save and Auto-Load
+Aider can automatically save and load sessions using command line options:
+
+**Auto-save:**
+```bash
+aider --auto-save
+```
+
+**Auto-load:**
+```bash
+aider --auto-load
+```
+
+**In configuration files:**
+```yaml
+auto-save: true
+auto-load: true
+```
+
+When `--auto-save` is enabled, aider will automatically save your session as 'auto-save' when you exit. When `--auto-load` is enabled, aider will automatically load the 'auto-save' session on startup if it exists.
+
+**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-5
+/save-session gpt4-session
+
+# Try different model
+/model claude-sonnet-4.5
+/save-session claude-session
+```

aider/website/docs/troubleshooting/aider-not-found.md

@@ -0,0 +1,24 @@
+---
+parent: Troubleshooting
+nav_order: 28
+---
+
+# Aider not found
+
+In some environments the `aider` command may not be available
+on your shell path.
+This can occur because of permissions/security settings in your OS,
+and often happens to Windows users.
+
+You may see an error message like this:
+
+> aider: The term 'aider' is not recognized as a name of a cmdlet, function, script file, or executable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again.
+
+Below is the most fail safe way to run aider in these situations:
+
+```
+python -m aider
+```
+
+You should also consider 
+[installing aider using aider-install, uv or pipx](/docs/install.html).