set version to 0.74.4.dev

The test for `EDITOR` preference failed to clean up any existing value
of `VISUAL` which may be present in the environment pytest is run in.

.github/workflows/docker-build-test.yml

@@ -4,42 +4,46 @@ on:
   push:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
+      - 'README.md'
-      - HISTORY.md
+      - 'HISTORY.md'
+      - '.github/workflows/*'
+      - '!.github/workflows/docker-build-test.yml'
     branches:
       - main
   pull_request:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
+      - 'README.md'
+      - 'HISTORY.md'
+      - '.github/workflows/*'
+      - '!.github/workflows/docker-build-test.yml'
     branches:
       - main
 
-# copy most of these steps from release.yml, but push: false and no tags:
-
 jobs:
-  build:
+  docker_build_and_push:
     runs-on: ubuntu-latest
-
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
 
     - name: Set up QEMU
       uses: docker/setup-qemu-action@v3
+
     - name: Set up Docker Buildx
       uses: docker/setup-buildx-action@v3
+
     - name: Login to DockerHub
+      if: ${{ github.event_name != 'pull_request' }}
       uses: docker/login-action@v3
       with:
         username: ${{ secrets.DOCKERHUB_USERNAME }}
         password: ${{ secrets.DOCKERHUB_PASSWORD }}
-      env:
-        dockerhub_username: ${{ secrets.DOCKERHUB_USERNAME }}
-        dockerhub_password: ${{ secrets.DOCKERHUB_PASSWORD }}
-      if: ${{ env.dockerhub_username }} && ${{ env.dockerhub_password }}
 
-    - name: Build Docker standard image
+    - name: Build Docker images (PR)
+      if: ${{ github.event_name == 'pull_request' }}
       uses: docker/build-push-action@v5
       with:
         context: .
@@ -48,7 +52,19 @@ jobs:
         push: false
         target: aider
 
-    - name: Build Docker full image
+    - name: Build Docker images (Push)
+      if: ${{ github.event_name != 'pull_request' }}
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: linux/amd64,linux/arm64
+        push: true
+        tags: ${{ secrets.DOCKERHUB_USERNAME }}/aider:dev
+        target: aider
+
+    - name: Build Docker full image (PR)
+      if: ${{ github.event_name == 'pull_request' }}
       uses: docker/build-push-action@v5
       with:
         context: .
@@ -56,3 +72,14 @@ jobs:
         platforms: linux/amd64,linux/arm64
         push: false
         target: aider-full
+
+    - name: Build Docker full image (Push)
+      if: ${{ github.event_name != 'pull_request' }}
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: linux/amd64,linux/arm64
+        push: true
+        tags: ${{ secrets.DOCKERHUB_USERNAME }}/aider-full:dev
+        target: aider-full

.github/workflows/docker-release.yml

@@ -12,6 +12,8 @@ jobs:
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
 
     - name: Set up QEMU
       uses: docker/setup-qemu-action@v3

.github/workflows/issues.yml

@@ -0,0 +1,29 @@
+name: Process GitHub Issues
+on:
+  schedule:
+    - cron: '0 */12 * * *'  # Run every 12 hours
+  workflow_dispatch:  # Allow manual triggers
+
+jobs:
+  process-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write  # Required to modify issues
+    
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+          
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install requests python-dotenv tqdm
+          
+      - name: Run issues script
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: python scripts/issues.py --yes

.github/workflows/pages.yml

@@ -12,6 +12,7 @@ on:
       - "main"
     paths:
       - "aider/website/**"
+      - ".github/workflows/pages.yml"
 
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
@@ -36,7 +37,9 @@ jobs:
         working-directory: aider/website
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -53,10 +56,9 @@ jobs:
         env:
           JEKYLL_ENV: production
       - name: Upload artifact
-        # Automatically uploads an artifact from the './_site' directory by default
+        uses: actions/upload-pages-artifact@v3
-        uses: actions/upload-pages-artifact@v1
         with:
-          path: "aider/website/_site/"
+          path: "aider/website/_site"
 
   # Deployment job
   deploy:
@@ -68,18 +70,18 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4
         
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python 3.12
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: '3.12'
 
       - name: Install linkchecker
         run: |
           python -m pip install --upgrade pip
-          pip install linkchecker
+          python -m pip install linkchecker
 
       - name: Run linkchecker
         run: |
-          linkchecker https://aider.chat
+          linkchecker --ignore-url='.+\.(mp4|mov|avi)' https://aider.chat

.github/workflows/release.yml

@@ -12,6 +12,8 @@ jobs:
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
 
     - name: Set up Python
       uses: actions/setup-python@v5

.github/workflows/ubuntu-tests.yml

@@ -4,14 +4,19 @@ on:
   push:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
+      - 'README.md'
-      - HISTORY.md
+      - 'HISTORY.md'
+      - '.github/workflows/*'
+      - '!.github/workflows/ubuntu-tests.yml'
     branches:
       - main
   pull_request:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
+      - 'README.md'
+      - 'HISTORY.md'
+      - '.github/workflows/*'
+      - '!.github/workflows/ubuntu-tests.yml'
     branches:
       - main
 
@@ -25,12 +30,19 @@ jobs:
     steps:
     - name: Check out repository
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
 
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
 
+    - name: Install system dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libportaudio2
+
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
@@ -38,5 +50,7 @@ jobs:
         pip install .
 
     - name: Run tests
+      env:
+        AIDER_ANALYTICS: false
       run: |
         pytest

.github/workflows/windows-tests.yml

@@ -4,14 +4,19 @@ on:
   push:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
+      - 'README.md'
-      - HISTORY.md
+      - 'HISTORY.md'
+      - '.github/workflows/*'
+      - '!.github/workflows/windows-tests.yml'
     branches:
       - main
   pull_request:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
+      - 'README.md'
+      - 'HISTORY.md'
+      - '.github/workflows/*'
+      - '!.github/workflows/windows-tests.yml'
     branches:
       - main
 
@@ -25,6 +30,8 @@ jobs:
     steps:
     - name: Check out repository
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
 
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
@@ -38,6 +45,8 @@ jobs:
         pip install .
 
     - name: Run tests
+      env:
+        AIDER_ANALYTICS: false
       run: |
         pytest
         

.gitignore

@@ -11,3 +11,8 @@ _site
 .jekyll-cache/
 .jekyll-metadata
 aider/__version__.py
+aider/_version.py
+.venv/
+.#*
+.gitattributes
+tmp.benchmarks/

CONTRIBUTING.md

@@ -17,10 +17,10 @@ Contributions of
 [LLM benchmark results](https://aider.chat/docs/leaderboards/)
 are welcome!
 See the
-[benchmark README](https://github.com/paul-gauthier/aider/blob/main/benchmark/README.md)
+[benchmark README](https://github.com/Aider-AI/aider/blob/main/benchmark/README.md)
 for information on running aider's code editing benchmarks.
 Submit results by opening a PR with edits to the
-[benchmark results data files](https://github.com/paul-gauthier/aider/blob/main/aider/website/_data/).
+[benchmark results data files](https://github.com/Aider-AI/aider/blob/main/aider/website/_data/).
 
 
 ## Pull Requests
@@ -33,19 +33,16 @@ ensure that your contributions can be integrated smoothly.
 
 ## Licensing
 
-By contributing to this project, you agree that your contributions
+Before contributing a PR, please review our
-will be licensed under the Apache License 2.0. Additionally, you
+[Individual Contributor License Agreement](https://aider.chat/docs/legal/contributor-agreement.html).
-understand and agree that contributions may be subject to a different
+All contributors will be asked to complete the agreement as part of the PR process.
-license, should the project maintainers decide to change the licensing
-terms.
-
 
 ## Setting up a Development Environment
 
 ### Clone the Repository
 
 ```
-git clone https://github.com/paul-gauthier/aider.git
+git clone https://github.com/Aider-AI/aider.git
 cd aider
 ```
 
@@ -59,13 +56,6 @@ It is recommended to create a virtual environment outside of the repository to k
 python -m venv /path/to/venv
 ```
 
-#### Using `virtualenv` (for older Python versions)
-
-```
-pip install virtualenv
-virtualenv /path/to/venv
-```
-
 ### Activate the Virtual Environment
 
 #### On Windows
@@ -154,6 +144,10 @@ The project's documentation is built using Jekyll and hosted on GitHub Pages. To
    ```
    bundle exec jekyll build
    ```
+5. Preview the website while editing (optional):
+   ```
+   bundle exec jekyll serve
+   ```
 
 The built documentation will be available in the `aider/website/_site` directory.
 
@@ -186,8 +180,8 @@ pytest
 You can also run specific test files or test cases by providing the file path or test name:
 
 ```
-pytest aider/tests/test_coder.py
+pytest tests/basic/test_coder.py
-pytest aider/tests/test_coder.py::TestCoder::test_specific_case
+pytest tests/basic/test_coder.py::TestCoder::test_specific_case
 ```
 
 #### Continuous Integration

HISTORY.md

@@ -1,6 +1,360 @@
-
 # Release history
 
+### Aider v0.74.3
+
+- Downgrade streamlit dependency to avoid threading bug.
+- Added support for tree-sitter language pack.
+- Added openrouter/o3-mini-high model configuration.
+- Added build.gradle.kts to special files for Kotlin project support, by Lucas Shadler.
+
+### Aider v0.74.2
+
+- Prevent more than one cache warming thread from becoming active.
+- Fixed continuation prompt ". " for multiline input.
+- Added HCL (Terraform) syntax support, by Warren Krewenki.
+
+### Aider v0.74.1
+
+- Have o1 & o3-mini generate markdown by sending the magic "Formatting re-enabled." string.
+- Bugfix for multi-line inputs, which should not include the ". " continuation prompt.
+
+### Aider v0.74.0
+
+- Dynamically changes the Ollama context window to hold the current chat.
+- Better support for o3-mini, DeepSeek V3 & R1, o1-mini, o1 especially via third-party API providers.
+- Remove `<think>` tags from R1 responses for commit messages (and other weak model uses).
+- Can now specify `use_temperature: <float>` in model settings, not just true/false.
+- The full docker container now includes `boto3` for Bedrock.
+- Docker containers now set `HOME=/app` which is the normal project mount-point, to persist `~/.aider`.
+- Bugfix to prevent creating incorrect filenames like `python`, `php`, etc.
+- Bugfix for `--timeout`
+- Bugfix so that `/model` now correctly reports that the weak model is not changed.
+- Bugfix so that multi-line mode persists through ^C at confirmation prompts.
+- Watch files now fully ignores top-level directories named in ignore files, to reduce the chance of hitting OS watch limits. Helpful to ignore giant subtrees like `node_modules`.
+- Fast startup with more providers and when model metadata provided in local files.
+- Improved .gitignore handling:
+  - Honor ignores already in effect regardless of how they've been configured.
+  - Check for .env only when the file exists.
+- Yes/No prompts now accept All/Skip as alias for Y/N even when not processing a group of confirmations.
+- Aider wrote 77% of the code in this release.
+
+### Aider v0.73.0
+
+- Full support for o3-mini: `aider --model o3-mini`
+- New `--reasoning-effort` argument: low, medium, high.
+- Improved handling of context window size limits, with better messaging and Ollama-specific guidance.
+- Added support for removing model-specific reasoning tags from responses with `remove_reasoning: tagname` model setting.
+- Auto-create parent directories when creating new files, by xqyz.
+- Support for R1 free on OpenRouter: `--model openrouter/deepseek/deepseek-r1:free`
+- Aider wrote 69% of the code in this release.
+
+### Aider v0.72.3
+
+- Enforce user/assistant turn order to avoid R1 errors, by miradnanali.
+- Case-insensitive model name matching while preserving original case.
+
+### Aider v0.72.2
+- Harden against user/assistant turn order problems which cause R1 errors.
+
+### Aider v0.72.1
+- Fix model metadata for `openrouter/deepseek/deepseek-r1`
+
+### Aider v0.72.0
+- Support for DeepSeek R1.
+  - Use shortcut: `--model r1`
+  - Also via OpenRouter: `--model openrouter/deepseek/deepseek-r1`
+- Added Kotlin syntax support to repo map, by Paul Walker.
+- Added `--line-endings` for file writing, by Titusz Pan.
+- Added examples_as_sys_msg=True for GPT-4o models, improves benchmark scores.
+- Bumped all dependencies, to pick up litellm support for o1 system messages.
+- Bugfix for turn taking when reflecting lint/test errors.
+- Aider wrote 52% of the code in this release.
+
+### Aider v0.71.1
+
+- Fix permissions issue in Docker images.
+- Added read-only file announcements.
+- Bugfix: ASCII fallback for unicode errors.
+- Bugfix: integer indices for list slicing in repomap calculations.
+
+### Aider v0.71.0
+
+- Prompts to help DeepSeek work better when alternating between `/ask` and `/code`.
+- Streaming pretty LLM responses is smoother and faster for long replies.
+- Streaming automatically turns of for model that don't support it
+  - Can now switch to/from `/model o1` and a streaming model
+- Pretty output remains enabled even when editing files with triple-backtick fences
+- Bare `/ask`, `/code` and `/architect` commands now switch the chat mode.
+- Increased default size of the repomap.
+- Increased max chat history tokens limit from 4k to 8k.
+- Turn off fancy input and watch files if terminal is dumb.
+- Added support for custom voice format and input device settings.
+- Disabled Streamlit email prompt, by apaz-cli.
+- Docker container runs as non-root user.
+- Fixed lint command handling of nested spaced strings, by Aaron Weisberg.
+- Added token count feedback when adding command output to chat.
+- Improved error handling for large audio files with automatic format conversion.
+- Improved handling of git repo index errors, by Krazer.
+- Improved unicode handling in console output with ASCII fallback.
+- Added AssertionError, AttributeError to git error handling.
+- Aider wrote 60% of the code in this release.
+
+### Aider v0.70.0
+
+- Full support for o1 models.
+- Watch files now honors `--subtree-only`, and only watches that subtree.
+- Improved prompting for watch files, to work more reliably with more models.
+- New install methods via uv, including one-liners.
+- Support for openrouter/deepseek/deepseek-chat model.
+- Better error handling when interactive commands are attempted via `/load` or `--load`.
+- Display read-only files with abs path if its shorter than rel path.
+- Ask 10% of users to opt-in to analytics.
+- Bugfix for auto-suggest.
+- Gracefully handle unicode errors in git path names.
+- Aider wrote 74% of the code in this release.
+
+### Aider v0.69.1
+
+- Fix for gemini model names in model metadata.
+- Show hints about AI! and AI? when user makes AI comments.
+- Support for running without git installed.
+- Improved environment variable setup messages on Windows.
+
+### Aider v0.69.0
+
+- [Watch files](https://aider.chat/docs/usage/watch.html) improvements:
+  - Use `# ... AI?` comments to trigger aider and ask questions about your code.
+  - Now watches *all* files, not just certain source files.
+  - Use `# AI comments`, `// AI comments`, or `-- AI comments` to give aider instructions in any text file.
+- Full support for Gemini Flash 2.0 Exp:
+  - `aider --model flash` or `aider --model gemini/gemini-2.0-flash-exp`
+- [New `--multiline` flag and `/multiline-mode` command](https://aider.chat/docs/usage/commands.html#entering-multi-line-chat-messages) makes ENTER a soft newline and META-ENTER send the message, by @miradnanali.
+- `/copy-context <instructions>` now takes optional "instructions" when [copying code context to the clipboard](https://aider.chat/docs/usage/copypaste.html#copy-aiders-code-context-to-your-clipboard-paste-into-the-web-ui).
+- Improved clipboard error handling with helpful requirements install info.
+- Ask 5% of users if they want to opt-in to analytics.
+- `/voice` now lets you edit the transcribed text before sending.
+- Disabled auto-complete in Y/N prompts.
+- Aider wrote 68% of the code in this release.
+
+### Aider v0.68.0
+
+- [Aider works with LLM web chat UIs](https://aider.chat/docs/usage/copypaste.html).
+  - New `--copy-paste` mode.
+  - New `/copy-context` command.
+- [Set API keys and other environment variables for all providers from command line or yaml conf file](https://aider.chat/docs/config/aider_conf.html#storing-llm-keys).
+  - New `--api-key provider=key` setting.
+  - New `--set-env VAR=value` setting.
+- Added bash and zsh support to `--watch-files`.
+- Better error messages when missing dependencies for Gemini and Bedrock models.
+- Control-D now properly exits the program.
+- Don't count token costs when API provider returns a hard error.
+- Bugfix so watch files works with files that don't have tree-sitter support.
+- Bugfix so o1 models can be used as weak model.
+- Updated shell command prompt.
+- Added docstrings for all Coders.
+- Reorganized command line arguments with improved help messages and grouping.
+- Use the exact `sys.python` for self-upgrades.
+- Added experimental Gemini models.
+- Aider wrote 71% of the code in this release.
+
+### Aider v0.67.0
+
+- [Use aider in your IDE or editor](https://aider.chat/docs/usage/watch.html).
+  - Run `aider --watch-files` and it will watch for instructions you add to your source files.
+  - One-liner `# ...` or `// ...` comments that start or end with "AI" are instructions to aider.
+  - When aider sees "AI!" it reads and follows all the instructions in AI comments.
+- Support for new Amazon Bedrock Nova models.
+- When `/run` or `/test` have non-zero exit codes, pre-fill "Fix that" into the next message prompt.
+- `/diff` now invokes `git diff` to use your preferred diff tool.
+- Added Ctrl-Z support for process suspension.
+- Spinner now falls back to ASCII art if fancy symbols throw unicode errors.
+- `--read` now expands `~` home dirs.
+- Enabled exception capture in analytics.
+- [Aider wrote 61% of the code in this release.](https://aider.chat/HISTORY.html)
+
+### Aider v0.66.0
+
+- PDF support for Sonnet and Gemini models.
+- Added `--voice-input-device` to select audio input device for voice recording, by @preynal.
+- Added `--timeout` option to configure API call timeouts.
+- Set cwd to repo root when running shell commands.
+- Added Ctrl-Up/Down keyboard shortcuts for per-message history navigation.
+- Improved error handling for failed .gitignore file operations.
+- Improved error handling for input history file permissions.
+- Improved error handling for analytics file access.
+- Removed spurious warning about disabling pretty in VSCode.
+- Removed broken support for Dart.
+- Bugfix when scraping URLs found in chat messages.
+- Better handling of __version__ import errors.
+- Improved `/drop` command to support substring matching for non-glob patterns.
+- Aider wrote 82% of the code in this release.
+
+### Aider v0.65.1
+
+- Bugfix to `--alias`.
+
+### Aider v0.65.0
+
+- Added `--alias` config to define [custom model aliases](https://aider.chat/docs/config/model-aliases.html).
+- Added `--[no-]detect-urls` flag to disable detecting and offering to scrape URLs found in the chat.
+- Ollama models now default to an 8k context window.
+- Added [RepoMap support for Dart language](https://aider.chat/docs/languages.html) by @malkoG.
+- Ask 2.5% of users if they want to opt-in to [analytics](https://aider.chat/docs/more/analytics.html).
+- Skip suggesting files that share names with files already in chat.
+- `/editor` returns and prefill the file content into the prompt, so you can use `/editor` to compose messages that start with `/commands`, etc.
+- Enhanced error handling for analytics.
+- Improved handling of UnknownEditFormat exceptions with helpful documentation links.
+- Bumped dependencies to pick up grep-ast 0.4.0 for Dart language support.
+- Aider wrote 81% of the code in this release.
+
+### Aider v0.64.1
+
+- Disable streaming for o1 on OpenRouter.
+
+### Aider v0.64.0
+
+- Added [`/editor` command](https://aider.chat/docs/usage/commands.html) to open system editor for writing prompts, by @thehunmonkgroup.
+- Full support for `gpt-4o-2024-11-20`.
+- Stream o1 models by default.
+- `/run` and suggested shell commands are less mysterious and now confirm that they "Added XX lines of output to the chat."
+- Ask 1% of users if they want to opt-in to [analytics](https://aider.chat/docs/more/analytics.html).
+- Added support for [optional multiline input tags](https://aider.chat/docs/usage/commands.html#entering-multi-line-chat-messages) with matching closing tags.
+- Improved [model settings configuration](https://aider.chat/docs/config/adv-model-settings.html#global-extra-params) with support for global `extra_params` for `litellm.completion()`.
+- Architect mode now asks to add files suggested by the LLM.
+- Fixed bug in fuzzy model name matching.
+- Added Timeout exception to handle API provider timeouts.
+- Added `--show-release-notes` to control release notes display on first run of new version.
+- Save empty dict to cache file on model metadata download failure, to delay retry.
+- Improved error handling and code formatting.
+- Aider wrote 74% of the code in this release.
+
+###  Aider v0.63.2
+
+- Fixed bug in fuzzy model name matching when litellm provider info is missing.
+- Modified model metadata file loading to allow override of resource file.
+- Allow recursive loading of dirs using `--read`.
+- Updated dependency versions to pick up litellm fix for ollama models.
+- Added exponential backoff retry when writing files to handle editor file locks.
+- Updated Qwen 2.5 Coder 32B model configuration.
+
+### Aider v0.63.1
+
+- Fixed bug in git ignored file handling.
+- Improved error handling for git operations.
+
+### Aider v0.63.0
+
+- Support for Qwen 2.5 Coder 32B.
+- `/web` command just adds the page to the chat, without triggering an LLM response.
+- Improved prompting for the user's preferred chat language.
+- Improved handling of LiteLLM exceptions.
+- Bugfix for double-counting tokens when reporting cache stats.
+- Bugfix for the LLM creating new files.
+- Other small bug fixes.
+- Aider wrote 55% of the code in this release.
+
+### Aider v0.62.0
+
+- Full support for Claude 3.5 Haiku
+  - Scored 75% on [aider's code editing leaderboard](https://aider.chat/docs/leaderboards/).
+  - Almost as good as Sonnet at much lower cost.
+  - Launch with `--haiku` to use it.
+- Easily apply file edits from ChatGPT, Claude or other web apps
+  - Chat with ChatGPT or Claude via their web app. 
+  - Give it your source files and ask for the changes you want.
+  - Use the web app's "copy response" button to copy the entire reply from the LLM.
+  - Run `aider --apply-clipboard-edits file-to-edit.js`.
+  - Aider will edit your file with the LLM's changes.
+- Bugfix for creating new files.
+- Aider wrote 84% of the code in this release.  
+
+### Aider v0.61.0
+
+- Load and save aider slash-commands to files:
+  - `/save <fname>` command will make a file of `/add` and `/read-only` commands that recreate the current file context in the chat.
+  - `/load <fname>` will replay the commands in the file.
+  - You can use `/load` to run any arbitrary set of slash-commands, not just `/add` and `/read-only`.
+  - Use `--load <fname>` to run a list of commands on launch, before the interactive chat begins.
+- Anonymous, opt-in [analytics](https://aider.chat/docs/more/analytics.html) with no personal data sharing.
+- Aider follows litellm's `supports_vision` attribute to enable image support for models.
+- Bugfix for when diff mode flexibly handles the model using the wrong filename.
+- Displays filenames in sorted order for `/add` and `/read-only`.
+- New `--no-fancy-input` switch disables prompt toolkit input, now still available with `--no-pretty`.
+- Override browser config with `--no-browser` or `--no-gui`.
+- Offer to open documentation URLs when errors occur.
+- Properly support all o1 models, regardless of provider.
+- Improved layout of filenames above input prompt.
+- Better handle corrupted repomap tags cache.
+- Improved handling of API errors, especially when accessing the weak model.
+- Aider wrote 68% of the code in this release.
+
+### Aider v0.60.1
+
+- Enable image support for Sonnet 10/22.
+- Display filenames in sorted order.
+
+### Aider v0.60.0
+
+- Full support for Sonnet 10/22, the new SOTA model on aider's code editing benchmark.
+  - Aider uses Sonnet 10/22 by default.
+- Improved formatting of added and read-only files above chat prompt, by @jbellis.
+- Improved support for o1 models by more flexibly parsing their nonconforming code edit replies.
+- Corrected diff edit format prompt that only the first match is replaced.
+- Stronger whole edit format prompt asking for clean file names.
+- Now offers to add `.env` to the `.gitignore` file.
+- Ships with a small model metadata json file to handle models not yet updated in litellm.
+- Model settings for o1 models on azure.
+- Bugfix to properly include URLs in `/help` RAG results.
+- Aider wrote 49% of the code in this release.
+
+### Aider v0.59.1
+
+- Check for obsolete `yes: true` in yaml config, show helpful error.
+- Model settings for openrouter/anthropic/claude-3.5-sonnet:beta
+
+### Aider v0.59.0
+
+- Improvements to `/read-only`:
+  - Now supports shell-style auto-complete of the full file system.
+  - Still auto-completes the full paths of the repo files like `/add`.
+  - Now supports globs like `src/**/*.py`
+- Renamed `--yes` to `--yes-always`.
+  - Now uses `AIDER_YES_ALWAYS` env var and `yes-always:` yaml key.
+  - Existing YAML and .env files will need to be updated.
+  - Can still abbreviate to `--yes` on the command line.
+- Config file now uses standard YAML list syntax with `  - list entries`, one per line.  
+- `/settings` now includes the same announcement lines that would print at launch.
+- Sanity checks the `--editor-model` on launch now, same as main and weak models.
+- Added `--skip-sanity-check-repo` switch to speedup launch in large repos.
+- Bugfix so architect mode handles Control-C properly.
+- Repo-map is deterministic now, with improved caching logic.
+- Improved commit message prompt.
+- Aider wrote 77% of the code in this release.
+
+### Aider v0.58.1
+
+- Fixed bug where cache warming pings caused subsequent user messages to trigger a tight loop of LLM requests.
+
+### Aider v0.58.0
+
+- [Use a pair of Architect/Editor models for improved coding](https://aider.chat/2024/09/26/architect.html)
+  - Use a strong reasoning model like o1-preview as your Architect.
+  - Use a cheaper, faster model like gpt-4o as your Editor.
+- New `--o1-preview` and `--o1-mini` shortcuts.
+- Support for new Gemini 002 models.
+- Better support for Qwen 2.5 models.
+- Many confirmation questions can be skipped for the rest of the session with "(D)on't ask again" response.
+- Autocomplete for `/read-only` supports the entire filesystem.
+- New settings for completion menu colors.
+- New `/copy` command to copy the last LLM response to the clipboard.
+- Renamed `/clipboard` to `/paste`.
+- Will now follow HTTP redirects when scraping urls.
+- New `--voice-format` switch to send voice audio as wav/mp3/webm, by @mbailey.
+- ModelSettings takes `extra_params` dict to specify any extras to pass to `litellm.completion()`.
+- Support for cursor shapes when in vim mode.
+- Numerous bug fixes.
+- Aider wrote 53% of the code in this release.
+
 ### Aider v0.57.1
 
 - Fixed dependency conflict between aider-chat[help] and [playwright].
@@ -665,7 +1019,7 @@
 ### Aider v0.14.0
 
 - [Support for Claude2 and other LLMs via OpenRouter](https://aider.chat/docs/faq.html#accessing-other-llms-with-openrouter) by @joshuavial
-- Documentation for [running the aider benchmarking suite](https://github.com/paul-gauthier/aider/tree/main/benchmark)
+- Documentation for [running the aider benchmarking suite](https://github.com/Aider-AI/aider/tree/main/benchmark)
 - Aider now requires Python >= 3.9
 
 

MANIFEST.in

@@ -0,0 +1,20 @@
+# This needs to sync with aider/help_pats.py
+
+global-exclude .DS_Store
+
+recursive-exclude aider/website/examples *
+recursive-exclude aider/website/_posts *
+
+exclude aider/website/HISTORY.md
+exclude aider/website/docs/benchmarks*.md
+exclude aider/website/docs/ctags.md
+exclude aider/website/docs/unified-diffs.md
+
+exclude aider/website/install.ps1
+exclude aider/website/install.sh
+
+recursive-exclude aider/website/docs/leaderboards *
+recursive-exclude aider/website/assets *
+recursive-exclude aider/website *.js
+recursive-exclude aider/website *.html
+recursive-exclude aider/website *.yml

README.md

@@ -5,9 +5,8 @@
 
 Aider lets you pair program with LLMs,
 to edit code in your local git repository.
-Start a new project or work with an existing git repo.
+Start a new project or work with an existing code base.
-Aider works best with GPT-4o & Claude 3.5 Sonnet and can 
+Aider works best with Claude 3.5 Sonnet, DeepSeek R1 & Chat V3, OpenAI o1, o3-mini & GPT-4o. Aider can [connect to almost any LLM, including local models](https://aider.chat/docs/llms.html).
-[connect to almost any LLM](https://aider.chat/docs/llms.html).
 
 <!-- SCREENCAST START -->
 <p align="center">
@@ -43,28 +42,36 @@ VIDEO END -->
 cog.out(open("aider/website/_includes/get-started.md").read())
 ]]]-->
 
-You can get started quickly like this:
+If you already have python 3.8-3.13 installed, you can get started quickly like this:
 
-```
+```bash
-python -m pip install aider-chat
+python -m pip install aider-install
+aider-install
 
-# Change directory into a git repo
+# Change directory into your code base
-cd /to/your/git/repo
+cd /to/your/project
 
-# Work with Claude 3.5 Sonnet on your repo
+# Work with DeepSeek via DeepSeek's API
-export ANTHROPIC_API_KEY=your-key-goes-here
+aider --model deepseek --api-key deepseek=your-key-goes-here
-aider
 
-# Work with GPT-4o on your repo
+# Work with Claude 3.5 Sonnet via Anthropic's API
-export OPENAI_API_KEY=your-key-goes-here
+aider --model sonnet --api-key anthropic=your-key-goes-here
-aider 
+
+# Work with GPT-4o via OpenAI's API
+aider --model gpt-4o --api-key openai=your-key-goes-here
+
+# Work with Sonnet via OpenRouter's API
+aider --model openrouter/anthropic/claude-3.5-sonnet --api-key openrouter=your-key-goes-here
+
+# Work with DeepSeek via OpenRouter's API
+aider --model openrouter/deepseek/deepseek-chat --api-key openrouter=your-key-goes-here
 ```
 <!--[[[end]]]-->
 
 See the
 [installation instructions](https://aider.chat/docs/install.html)
-and other
+and
-[documentation](https://aider.chat/docs/usage.html)
+[usage documentation](https://aider.chat/docs/usage.html)
 for more details.
 
 ## Features
@@ -73,21 +80,22 @@ for more details.
 - Ask for changes:
   - Add new features or test cases.
   - Describe a bug.
-  - Paste in an error message or or GitHub issue URL.
+  - Paste in an error message or GitHub issue URL.
   - Refactor code.
   - Update docs.
 - Aider will edit your files to complete your request.
 - Aider [automatically git commits](https://aider.chat/docs/git.html) changes with a sensible commit message.
+- [Use aider inside your favorite editor or IDE](https://aider.chat/docs/usage/watch.html).
 - Aider works with [most popular languages](https://aider.chat/docs/languages.html): python, javascript, typescript, php, html, css, and more...
-- Aider works best with GPT-4o & Claude 3.5 Sonnet and can [connect to almost any LLM](https://aider.chat/docs/llms.html).
 - Aider can edit multiple files at once for complex requests.
 - Aider uses a [map of your entire git repo](https://aider.chat/docs/repomap.html), which helps it work well in larger codebases.
-- Edit files in your editor while chatting with aider,
+- Edit files in your editor or IDE while chatting with aider,
 and it will always use the latest version.
 Pair program with AI.
 - [Add images to the chat](https://aider.chat/docs/usage/images-urls.html) (GPT-4o, Claude 3.5 Sonnet, etc).
 - [Add URLs to the chat](https://aider.chat/docs/usage/images-urls.html) and aider will read their content.
 - [Code with your voice](https://aider.chat/docs/usage/voice.html).
+- Aider works best with Claude 3.5 Sonnet, DeepSeek V3, o1 & GPT-4o and can [connect to almost any LLM](https://aider.chat/docs/llms.html).
 
 
 ## Top tier performance
@@ -107,7 +115,7 @@ projects like django, scikitlearn, matplotlib, etc.
 - [Configuration](https://aider.chat/docs/config.html)
 - [Troubleshooting](https://aider.chat/docs/troubleshooting.html)
 - [LLM Leaderboards](https://aider.chat/docs/leaderboards/)
-- [GitHub](https://github.com/paul-gauthier/aider)
+- [GitHub](https://github.com/Aider-AI/aider)
 - [Discord](https://discord.gg/Tv2uQnR88V)
 - [Blog](https://aider.chat/blog/)
 
@@ -118,14 +126,14 @@ projects like django, scikitlearn, matplotlib, etc.
 - *The best AI coding assistant so far.* -- [Matthew Berman](https://www.youtube.com/watch?v=df8afeb1FY8)
 - *Aider ... has easily quadrupled my coding productivity.* -- [SOLAR_FIELDS](https://news.ycombinator.com/item?id=36212100)
 - *It's a cool workflow... Aider's ergonomics are perfect for me.* -- [qup](https://news.ycombinator.com/item?id=38185326)
-- *It's really like having your senior developer live right in your Git repo - truly amazing!* -- [rappster](https://github.com/paul-gauthier/aider/issues/124)
+- *It's really like having your senior developer live right in your Git repo - truly amazing!* -- [rappster](https://github.com/Aider-AI/aider/issues/124)
-- *What an amazing tool. It's incredible.* -- [valyagolev](https://github.com/paul-gauthier/aider/issues/6#issue-1722897858)
+- *What an amazing tool. It's incredible.* -- [valyagolev](https://github.com/Aider-AI/aider/issues/6#issue-1722897858)
-- *Aider is such an astounding thing!* -- [cgrothaus](https://github.com/paul-gauthier/aider/issues/82#issuecomment-1631876700)
+- *Aider is such an astounding thing!* -- [cgrothaus](https://github.com/Aider-AI/aider/issues/82#issuecomment-1631876700)
 - *It was WAY faster than I would be getting off the ground and making the first few working versions.* -- [Daniel Feldman](https://twitter.com/d_feldman/status/1662295077387923456)
 - *THANK YOU for Aider! It really feels like a glimpse into the future of coding.* -- [derwiki](https://news.ycombinator.com/item?id=38205643)
 - *It's just amazing.  It is freeing me to do things I felt were out my comfort zone before.* -- [Dougie](https://discord.com/channels/1131200896827654144/1174002618058678323/1174084556257775656)
-- *This project is stellar.* -- [funkytaco](https://github.com/paul-gauthier/aider/issues/112#issuecomment-1637429008)
+- *This project is stellar.* -- [funkytaco](https://github.com/Aider-AI/aider/issues/112#issuecomment-1637429008)
-- *Amazing project, definitely the best AI coding assistant I've used.* -- [joshuavial](https://github.com/paul-gauthier/aider/issues/84)
+- *Amazing project, definitely the best AI coding assistant I've used.* -- [joshuavial](https://github.com/Aider-AI/aider/issues/84)
 - *I absolutely love using Aider ... It makes software development feel so much lighter as an experience.* -- [principalideal0](https://discord.com/channels/1131200896827654144/1133421607499595858/1229689636012691468)
 - *I have been recovering from multiple shoulder surgeries ... and have used aider extensively. It has allowed me to continue productivity.* -- [codeninja](https://www.reddit.com/r/OpenAI/s/nmNwkHy1zG)
 - *I am an aider addict. I'm getting so much more work done, but in less time.* -- [dandandan](https://discord.com/channels/1131200896827654144/1131200896827654149/1135913253483069470)

aider/__init__.py

@@ -1,6 +1,20 @@
+from packaging import version
+
+__version__ = "0.74.4.dev"
+safe_version = __version__
+
 try:
-    from aider.__version__ import __version__
+    from aider._version import __version__
 except Exception:
-    __version__ = "0.57.2.dev"
+    __version__ = safe_version + "+import"
+
+if type(__version__) is not str:
+    __version__ = safe_version + "+type"
+else:
+    try:
+        if version.parse(__version__) < version.parse(safe_version):
+            __version__ = safe_version + "+less"
+    except Exception:
+        __version__ = safe_version + "+parse"
 
 __all__ = [__version__]

aider/analytics.py

@@ -0,0 +1,250 @@
+import json
+import platform
+import sys
+import time
+import uuid
+from pathlib import Path
+
+from mixpanel import MixpanelException
+from posthog import Posthog
+
+from aider import __version__
+from aider.dump import dump  # noqa: F401
+from aider.models import model_info_manager
+
+PERCENT = 10
+
+
+def compute_hex_threshold(percent):
+    """Convert percentage to 6-digit hex threshold.
+
+    Args:
+        percent: Percentage threshold (0-100)
+
+    Returns:
+        str: 6-digit hex threshold
+    """
+    return format(int(0xFFFFFF * percent / 100), "06x")
+
+
+def is_uuid_in_percentage(uuid_str, percent):
+    """Check if a UUID string falls within the first X percent of the UUID space.
+
+    Args:
+        uuid_str: UUID string to test
+        percent: Percentage threshold (0-100)
+
+    Returns:
+        bool: True if UUID falls within the first X percent
+    """
+    if not (0 <= percent <= 100):
+        raise ValueError("Percentage must be between 0 and 100")
+
+    if not uuid_str:
+        return False
+
+    # Convert percentage to hex threshold (1% = "04...", 10% = "1a...", etc)
+    # Using first 6 hex digits
+    if percent == 0:
+        return False
+
+    threshold = compute_hex_threshold(percent)
+    return uuid_str[:6] <= threshold
+
+
+mixpanel_project_token = "6da9a43058a5d1b9f3353153921fb04d"
+posthog_project_api_key = "phc_99T7muzafUMMZX15H8XePbMSreEUzahHbtWjy3l5Qbv"
+posthog_host = "https://us.i.posthog.com"
+
+
+class Analytics:
+    # providers
+    mp = None
+    ph = None
+
+    # saved
+    user_id = None
+    permanently_disable = None
+    asked_opt_in = None
+
+    # ephemeral
+    logfile = None
+
+    def __init__(self, logfile=None, permanently_disable=False):
+        self.logfile = logfile
+        self.get_or_create_uuid()
+
+        if self.permanently_disable or permanently_disable or not self.asked_opt_in:
+            self.disable(permanently_disable)
+
+    def enable(self):
+        if not self.user_id:
+            self.disable(False)
+            return
+
+        if self.permanently_disable:
+            self.disable(True)
+            return
+
+        if not self.asked_opt_in:
+            self.disable(False)
+            return
+
+        # self.mp = Mixpanel(mixpanel_project_token)
+        self.ph = Posthog(
+            project_api_key=posthog_project_api_key,
+            host=posthog_host,
+            on_error=self.posthog_error,
+            enable_exception_autocapture=True,
+            super_properties=self.get_system_info(),  # Add system info to all events
+        )
+
+    def disable(self, permanently):
+        self.mp = None
+        self.ph = None
+
+        if permanently:
+            self.asked_opt_in = True
+            self.permanently_disable = True
+            self.save_data()
+
+    def need_to_ask(self, args_analytics):
+        if args_analytics is False:
+            return False
+
+        could_ask = not self.asked_opt_in and not self.permanently_disable
+        if not could_ask:
+            return False
+
+        if args_analytics is True:
+            return True
+
+        assert args_analytics is None, args_analytics
+
+        if not self.user_id:
+            return False
+
+        return is_uuid_in_percentage(self.user_id, PERCENT)
+
+    def get_data_file_path(self):
+        try:
+            data_file = Path.home() / ".aider" / "analytics.json"
+            data_file.parent.mkdir(parents=True, exist_ok=True)
+            return data_file
+        except OSError:
+            # If we can't create/access the directory, just disable analytics
+            self.disable(permanently=False)
+            return None
+
+    def get_or_create_uuid(self):
+        self.load_data()
+        if self.user_id:
+            return
+
+        self.user_id = str(uuid.uuid4())
+        self.save_data()
+
+    def load_data(self):
+        data_file = self.get_data_file_path()
+        if not data_file:
+            return
+
+        if data_file.exists():
+            try:
+                data = json.loads(data_file.read_text())
+                self.permanently_disable = data.get("permanently_disable")
+                self.user_id = data.get("uuid")
+                self.asked_opt_in = data.get("asked_opt_in", False)
+            except (json.decoder.JSONDecodeError, OSError):
+                self.disable(permanently=False)
+
+    def save_data(self):
+        data_file = self.get_data_file_path()
+        if not data_file:
+            return
+
+        data = dict(
+            uuid=self.user_id,
+            permanently_disable=self.permanently_disable,
+            asked_opt_in=self.asked_opt_in,
+        )
+
+        try:
+            data_file.write_text(json.dumps(data, indent=4))
+        except OSError:
+            # If we can't write the file, just disable analytics
+            self.disable(permanently=False)
+
+    def get_system_info(self):
+        return {
+            "python_version": sys.version.split()[0],
+            "os_platform": platform.system(),
+            "os_release": platform.release(),
+            "machine": platform.machine(),
+            "aider_version": __version__,
+        }
+
+    def _redact_model_name(self, model):
+        if not model:
+            return None
+
+        info = model_info_manager.get_model_from_cached_json_db(model.name)
+        if info:
+            return model.name
+        elif "/" in model.name:
+            return model.name.split("/")[0] + "/REDACTED"
+        return None
+
+    def posthog_error(self):
+        """disable posthog if we get an error"""
+        print("X" * 100)
+        # https://github.com/PostHog/posthog-python/blob/9e1bb8c58afaa229da24c4fb576c08bb88a75752/posthog/consumer.py#L86
+        # https://github.com/Aider-AI/aider/issues/2532
+        self.ph = None
+
+    def event(self, event_name, main_model=None, **kwargs):
+        if not self.mp and not self.ph and not self.logfile:
+            return
+
+        properties = {}
+
+        if main_model:
+            properties["main_model"] = self._redact_model_name(main_model)
+            properties["weak_model"] = self._redact_model_name(main_model.weak_model)
+            properties["editor_model"] = self._redact_model_name(main_model.editor_model)
+
+        properties.update(kwargs)
+
+        # Handle numeric values
+        for key, value in properties.items():
+            if isinstance(value, (int, float)):
+                properties[key] = value
+            else:
+                properties[key] = str(value)
+
+        if self.mp:
+            try:
+                self.mp.track(self.user_id, event_name, dict(properties))
+            except MixpanelException:
+                self.mp = None  # Disable mixpanel on connection errors
+
+        if self.ph:
+            self.ph.capture(self.user_id, event_name, dict(properties))
+
+        if self.logfile:
+            log_entry = {
+                "event": event_name,
+                "properties": properties,
+                "user_id": self.user_id,
+                "time": int(time.time()),
+            }
+            try:
+                with open(self.logfile, "a") as f:
+                    json.dump(log_entry, f)
+                    f.write("\n")
+            except OSError:
+                pass  # Ignore OS errors when writing to logfile
+
+
+if __name__ == "__main__":
+    dump(compute_hex_threshold(PERCENT))

aider/args.py

@@ -25,24 +25,13 @@ def get_parser(default_config_files, git_root):
         description="aider is AI pair programming in your terminal",
         add_config_file_help=True,
         default_config_files=default_config_files,
+        config_file_parser_class=configargparse.YAMLConfigFileParser,
         auto_env_var_prefix="AIDER_",
     )
-    group = parser.add_argument_group("Main")
+    group = parser.add_argument_group("Main model")
     group.add_argument(
         "files", metavar="FILE", nargs="*", help="files to edit with an LLM (optional)"
     )
-    group.add_argument(
-        "--openai-api-key",
-        metavar="OPENAI_API_KEY",
-        env_var="OPENAI_API_KEY",
-        help="Specify the OpenAI API key",
-    )
-    group.add_argument(
-        "--anthropic-api-key",
-        metavar="ANTHROPIC_API_KEY",
-        env_var="ANTHROPIC_API_KEY",
-        help="Specify the Anthropic API key",
-    )
     group.add_argument(
         "--model",
         metavar="MODEL",
@@ -57,7 +46,7 @@ def get_parser(default_config_files, git_root):
         const=opus_model,
         help=f"Use {opus_model} model for the main chat",
     )
-    sonnet_model = "claude-3-5-sonnet-20240620"
+    sonnet_model = "claude-3-5-sonnet-20241022"
     group.add_argument(
         "--sonnet",
         action="store_const",
@@ -65,6 +54,14 @@ def get_parser(default_config_files, git_root):
         const=sonnet_model,
         help=f"Use {sonnet_model} model for the main chat",
     )
+    haiku_model = "claude-3-5-haiku-20241022"
+    group.add_argument(
+        "--haiku",
+        action="store_const",
+        dest="model",
+        const=haiku_model,
+        help=f"Use {haiku_model} model for the main chat",
+    )
     gpt_4_model = "gpt-4-0613"
     group.add_argument(
         "--4",
@@ -74,7 +71,7 @@ def get_parser(default_config_files, git_root):
         const=gpt_4_model,
         help=f"Use {gpt_4_model} model for the main chat",
     )
-    gpt_4o_model = "gpt-4o-2024-08-06"
+    gpt_4o_model = "gpt-4o"
     group.add_argument(
         "--4o",
         action="store_const",
@@ -109,7 +106,7 @@ def get_parser(default_config_files, git_root):
         const=gpt_3_model_name,
         help=f"Use {gpt_3_model_name} model for the main chat",
     )
-    deepseek_model = "deepseek/deepseek-coder"
+    deepseek_model = "deepseek/deepseek-chat"
     group.add_argument(
         "--deepseek",
         action="store_const",
@@ -117,45 +114,77 @@ def get_parser(default_config_files, git_root):
         const=deepseek_model,
         help=f"Use {deepseek_model} model for the main chat",
     )
+    o1_mini_model = "o1-mini"
+    group.add_argument(
+        "--o1-mini",
+        action="store_const",
+        dest="model",
+        const=o1_mini_model,
+        help=f"Use {o1_mini_model} model for the main chat",
+    )
+    o1_preview_model = "o1-preview"
+    group.add_argument(
+        "--o1-preview",
+        action="store_const",
+        dest="model",
+        const=o1_preview_model,
+        help=f"Use {o1_preview_model} model for the main chat",
+    )
 
     ##########
-    group = parser.add_argument_group("Model Settings")
+    group = parser.add_argument_group("API Keys and settings")
+    group.add_argument(
+        "--openai-api-key",
+        help="Specify the OpenAI API key",
+    )
+    group.add_argument(
+        "--anthropic-api-key",
+        help="Specify the Anthropic API key",
+    )
+    group.add_argument(
+        "--openai-api-base",
+        help="Specify the api base url",
+    )
+    group.add_argument(
+        "--openai-api-type",
+        help="(deprecated, use --set-env OPENAI_API_TYPE=<value>)",
+    )
+    group.add_argument(
+        "--openai-api-version",
+        help="(deprecated, use --set-env OPENAI_API_VERSION=<value>)",
+    )
+    group.add_argument(
+        "--openai-api-deployment-id",
+        help="(deprecated, use --set-env OPENAI_API_DEPLOYMENT_ID=<value>)",
+    )
+    group.add_argument(
+        "--openai-organization-id",
+        help="(deprecated, use --set-env OPENAI_ORGANIZATION=<value>)",
+    )
+    group.add_argument(
+        "--set-env",
+        action="append",
+        metavar="ENV_VAR_NAME=value",
+        help="Set an environment variable (to control API settings, can be used multiple times)",
+        default=[],
+    )
+    group.add_argument(
+        "--api-key",
+        action="append",
+        metavar="PROVIDER=KEY",
+        help=(
+            "Set an API key for a provider (eg: --api-key provider=<key> sets"
+            " PROVIDER_API_KEY=<key>)"
+        ),
+        default=[],
+    )
+    group = parser.add_argument_group("Model settings")
     group.add_argument(
         "--list-models",
         "--models",
         metavar="MODEL",
         help="List known models which match the (partial) MODEL name",
     )
-    group.add_argument(
-        "--openai-api-base",
-        metavar="OPENAI_API_BASE",
-        env_var="OPENAI_API_BASE",
-        help="Specify the api base url",
-    )
-    group.add_argument(
-        "--openai-api-type",
-        metavar="OPENAI_API_TYPE",
-        env_var="OPENAI_API_TYPE",
-        help="Specify the api_type",
-    )
-    group.add_argument(
-        "--openai-api-version",
-        metavar="OPENAI_API_VERSION",
-        env_var="OPENAI_API_VERSION",
-        help="Specify the api_version",
-    )
-    group.add_argument(
-        "--openai-api-deployment-id",
-        metavar="OPENAI_API_DEPLOYMENT_ID",
-        env_var="OPENAI_API_DEPLOYMENT_ID",
-        help="Specify the deployment_id",
-    )
-    group.add_argument(
-        "--openai-organization-id",
-        metavar="OPENAI_ORGANIZATION_ID",
-        env_var="OPENAI_ORGANIZATION_ID",
-        help="Specify the OpenAI organization ID",
-    )
     group.add_argument(
         "--model-settings-file",
         metavar="MODEL_SETTINGS_FILE",
@@ -168,12 +197,29 @@ def get_parser(default_config_files, git_root):
         default=".aider.model.metadata.json",
         help="Specify a file with context window and costs for unknown models",
     )
+    group.add_argument(
+        "--alias",
+        action="append",
+        metavar="ALIAS:MODEL",
+        help="Add a model alias (can be used multiple times)",
+    )
+    group.add_argument(
+        "--reasoning-effort",
+        type=str,
+        help="Set the reasoning_effort API parameter (default: not set)",
+    )
     group.add_argument(
         "--verify-ssl",
         action=argparse.BooleanOptionalAction,
         default=True,
         help="Verify the SSL cert when connecting to models (default: True)",
     )
+    group.add_argument(
+        "--timeout",
+        type=float,
+        default=None,
+        help="Timeout in seconds for API calls (default: None)",
+    )
     group.add_argument(
         "--edit-format",
         "--chat-mode",
@@ -181,6 +227,13 @@ def get_parser(default_config_files, git_root):
         default=None,
         help="Specify what edit format the LLM should use (default depends on model)",
     )
+    group.add_argument(
+        "--architect",
+        action="store_const",
+        dest="edit_format",
+        const="architect",
+        help="Use architect edit format for the main chat",
+    )
     group.add_argument(
         "--weak-model",
         metavar="WEAK_MODEL",
@@ -190,6 +243,18 @@ def get_parser(default_config_files, git_root):
             " depends on --model)"
         ),
     )
+    group.add_argument(
+        "--editor-model",
+        metavar="EDITOR_MODEL",
+        default=None,
+        help="Specify the model to use for editor tasks (default depends on --model)",
+    )
+    group.add_argument(
+        "--editor-edit-format",
+        metavar="EDITOR_EDIT_FORMAT",
+        default=None,
+        help="Specify the edit format for the editor model (default: depends on editor model)",
+    )
     group.add_argument(
         "--show-model-warnings",
         action=argparse.BooleanOptionalAction,
@@ -197,17 +262,17 @@ def get_parser(default_config_files, git_root):
         help="Only work with models that have meta-data available (default: True)",
     )
     group.add_argument(
-        "--map-tokens",
+        "--max-chat-history-tokens",
         type=int,
         default=None,
-        help="Suggested number of tokens to use for repo map, use 0 to disable (default: 1024)",
+        help=(
-    )
+            "Soft limit on tokens for chat history, after which summarization begins."
-    group.add_argument(
+            " If unspecified, defaults to the model's max_chat_history_tokens."
-        "--map-refresh",
+        ),
-        choices=["auto", "always", "files", "manual"],
-        default="auto",
-        help="Control how often the repo map is refreshed (default: auto)",
     )
+
+    ##########
+    group = parser.add_argument_group("Cache settings")
     group.add_argument(
         "--cache-prompts",
         action=argparse.BooleanOptionalAction,
@@ -220,29 +285,30 @@ def get_parser(default_config_files, git_root):
         default=0,
         help="Number of times to ping at 5min intervals to keep prompt cache warm (default: 0)",
     )
+
+    ##########
+    group = parser.add_argument_group("Repomap settings")
+    group.add_argument(
+        "--map-tokens",
+        type=int,
+        default=None,
+        help="Suggested number of tokens to use for repo map, use 0 to disable",
+    )
+    group.add_argument(
+        "--map-refresh",
+        choices=["auto", "always", "files", "manual"],
+        default="auto",
+        help=(
+            "Control how often the repo map is refreshed. Options: auto, always, files, manual"
+            " (default: auto)"
+        ),
+    )
     group.add_argument(
         "--map-multiplier-no-files",
         type=float,
         default=2,
         help="Multiplier for map tokens when no files are specified (default: 2)",
     )
-    group.add_argument(
-        "--max-chat-history-tokens",
-        type=int,
-        default=None,
-        help=(
-            "Maximum number of tokens to use for chat history. If not specified, uses the model's"
-            " max_chat_history_tokens."
-        ),
-    )
-    # This is a duplicate of the argument in the preparser and is a no-op by this time of
-    # argument parsing, but it's here so that the help is displayed as expected.
-    group.add_argument(
-        "--env-file",
-        metavar="ENV_FILE",
-        default=default_env_file(git_root),
-        help="Specify the .env file to load (default: .env in git root)",
-    )
 
     ##########
     group = parser.add_argument_group("History Files")
@@ -278,7 +344,7 @@ def get_parser(default_config_files, git_root):
     )
 
     ##########
-    group = parser.add_argument_group("Output Settings")
+    group = parser.add_argument_group("Output settings")
     group.add_argument(
         "--dark-mode",
         action="store_true",
@@ -328,12 +394,46 @@ def get_parser(default_config_files, git_root):
         default="#0088ff",
         help="Set the color for assistant output (default: #0088ff)",
     )
+    group.add_argument(
+        "--completion-menu-color",
+        metavar="COLOR",
+        default=None,
+        help="Set the color for the completion menu (default: terminal's default text color)",
+    )
+    group.add_argument(
+        "--completion-menu-bg-color",
+        metavar="COLOR",
+        default=None,
+        help=(
+            "Set the background color for the completion menu (default: terminal's default"
+            " background color)"
+        ),
+    )
+    group.add_argument(
+        "--completion-menu-current-color",
+        metavar="COLOR",
+        default=None,
+        help=(
+            "Set the color for the current item in the completion menu (default: terminal's default"
+            " background color)"
+        ),
+    )
+    group.add_argument(
+        "--completion-menu-current-bg-color",
+        metavar="COLOR",
+        default=None,
+        help=(
+            "Set the background color for the current item in the completion menu (default:"
+            " terminal's default text color)"
+        ),
+    )
     group.add_argument(
         "--code-theme",
         default="default",
         help=(
             "Set the markdown code theme (default: default, other options include monokai,"
-            " solarized-dark, solarized-light)"
+            " solarized-dark, solarized-light, or a Pygments builtin style,"
+            " see https://pygments.org/styles for available themes)"
         ),
     )
     group.add_argument(
@@ -344,7 +444,7 @@ def get_parser(default_config_files, git_root):
     )
 
     ##########
-    group = parser.add_argument_group("Git Settings")
+    group = parser.add_argument_group("Git settings")
     group.add_argument(
         "--git",
         action=argparse.BooleanOptionalAction,
@@ -425,6 +525,18 @@ def get_parser(default_config_files, git_root):
         default=False,
         help="Perform a dry run without modifying files (default: False)",
     )
+    group.add_argument(
+        "--skip-sanity-check-repo",
+        action="store_true",
+        help="Skip the sanity check for the git repository (default: False)",
+        default=False,
+    )
+    group.add_argument(
+        "--watch-files",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Enable/disable watching files for ai coding comments (default: False)",
+    )
     group = parser.add_argument_group("Fixing and committing")
     group.add_argument(
         "--lint",
@@ -461,48 +573,32 @@ def get_parser(default_config_files, git_root):
     group.add_argument(
         "--test",
         action="store_true",
-        help="Run tests and fix problems found",
+        help="Run tests, fix problems found and then exit",
         default=False,
     )
 
     ##########
-    group = parser.add_argument_group("Other Settings")
+    group = parser.add_argument_group("Analytics")
     group.add_argument(
-        "--file",
+        "--analytics",
-        action="append",
+        action=argparse.BooleanOptionalAction,
-        metavar="FILE",
+        default=None,
-        help="specify a file to edit (can be used multiple times)",
+        help="Enable/disable analytics for current session (default: random)",
     )
     group.add_argument(
-        "--read",
+        "--analytics-log",
-        action="append",
+        metavar="ANALYTICS_LOG_FILE",
-        metavar="FILE",
+        help="Specify a file to log analytics events",
-        help="specify a read-only file (can be used multiple times)",
     )
     group.add_argument(
-        "--vim",
+        "--analytics-disable",
         action="store_true",
-        help="Use VI editing mode in the terminal (default: False)",
+        help="Permanently disable analytics",
         default=False,
     )
-    group.add_argument(
+
-        "--voice-language",
+    #########
-        metavar="VOICE_LANGUAGE",
+    group = parser.add_argument_group("Upgrading")
-        default="en",
-        help="Specify the language for voice using ISO 639-1 code (default: auto)",
-    )
-    group.add_argument(
-        "--chat-language",
-        metavar="CHAT_LANGUAGE",
-        default=None,
-        help="Specify the language to use in the chat (default: None, uses system settings)",
-    )
-    group.add_argument(
-        "--version",
-        action="version",
-        version=f"%(prog)s {__version__}",
-        help="Show the version number and exit",
-    )
     group.add_argument(
         "--just-check-update",
         action="store_true",
@@ -515,6 +611,12 @@ def get_parser(default_config_files, git_root):
         help="Check for new aider versions on launch",
         default=True,
     )
+    group.add_argument(
+        "--show-release-notes",
+        action=argparse.BooleanOptionalAction,
+        help="Show release notes on first run of new version (default: None, ask user)",
+        default=None,
+    )
     group.add_argument(
         "--install-main-branch",
         action="store_true",
@@ -529,41 +631,14 @@ def get_parser(default_config_files, git_root):
         default=False,
     )
     group.add_argument(
-        "--apply",
+        "--version",
-        metavar="FILE",
+        action="version",
-        help="Apply the changes from the given file instead of running the chat (debug)",
+        version=f"%(prog)s {__version__}",
-    )
+        help="Show the version number and exit",
-    group.add_argument(
-        "--yes",
-        action="store_true",
-        help="Always say yes to every confirmation",
-        default=None,
-    )
-    group.add_argument(
-        "-v",
-        "--verbose",
-        action="store_true",
-        help="Enable verbose output",
-        default=False,
-    )
-    group.add_argument(
-        "--show-repo-map",
-        action="store_true",
-        help="Print the repo map and exit (debug)",
-        default=False,
-    )
-    group.add_argument(
-        "--show-prompts",
-        action="store_true",
-        help="Print the system prompts and exit (debug)",
-        default=False,
-    )
-    group.add_argument(
-        "--exit",
-        action="store_true",
-        help="Do all startup activities then exit before accepting user input (debug)",
-        default=False,
     )
+
+    ##########
+    group = parser.add_argument_group("Modes")
     group.add_argument(
         "--message",
         "--msg",
@@ -582,11 +657,126 @@ def get_parser(default_config_files, git_root):
             " (disables chat mode)"
         ),
     )
+    group.add_argument(
+        "--gui",
+        "--browser",
+        action=argparse.BooleanOptionalAction,
+        help="Run aider in your browser (default: False)",
+        default=False,
+    )
+    group.add_argument(
+        "--copy-paste",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Enable automatic copy/paste of chat between aider and web UI (default: False)",
+    )
+    group.add_argument(
+        "--apply",
+        metavar="FILE",
+        help="Apply the changes from the given file instead of running the chat (debug)",
+    )
+    group.add_argument(
+        "--apply-clipboard-edits",
+        action="store_true",
+        help="Apply clipboard contents as edits using the main model's editor format",
+        default=False,
+    )
+    group.add_argument(
+        "--exit",
+        action="store_true",
+        help="Do all startup activities then exit before accepting user input (debug)",
+        default=False,
+    )
+    group.add_argument(
+        "--show-repo-map",
+        action="store_true",
+        help="Print the repo map and exit (debug)",
+        default=False,
+    )
+    group.add_argument(
+        "--show-prompts",
+        action="store_true",
+        help="Print the system prompts and exit (debug)",
+        default=False,
+    )
+
+    ##########
+    group = parser.add_argument_group("Voice settings")
+    group.add_argument(
+        "--voice-format",
+        metavar="VOICE_FORMAT",
+        default="wav",
+        choices=["wav", "mp3", "webm"],
+        help="Audio format for voice recording (default: wav). webm and mp3 require ffmpeg",
+    )
+    group.add_argument(
+        "--voice-language",
+        metavar="VOICE_LANGUAGE",
+        default="en",
+        help="Specify the language for voice using ISO 639-1 code (default: auto)",
+    )
+    group.add_argument(
+        "--voice-input-device",
+        metavar="VOICE_INPUT_DEVICE",
+        default=None,
+        help="Specify the input device name for voice recording",
+    )
+
+    ######
+    group = parser.add_argument_group("Other settings")
+    group.add_argument(
+        "--file",
+        action="append",
+        metavar="FILE",
+        help="specify a file to edit (can be used multiple times)",
+    )
+    group.add_argument(
+        "--read",
+        action="append",
+        metavar="FILE",
+        help="specify a read-only file (can be used multiple times)",
+    )
+    group.add_argument(
+        "--vim",
+        action="store_true",
+        help="Use VI editing mode in the terminal (default: False)",
+        default=False,
+    )
+    group.add_argument(
+        "--chat-language",
+        metavar="CHAT_LANGUAGE",
+        default=None,
+        help="Specify the language to use in the chat (default: None, uses system settings)",
+    )
+    group.add_argument(
+        "--yes-always",
+        action="store_true",
+        help="Always say yes to every confirmation",
+        default=None,
+    )
+    group.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+        default=False,
+    )
+    group.add_argument(
+        "--load",
+        metavar="LOAD_FILE",
+        help="Load and execute /commands from a file on launch",
+    )
     group.add_argument(
         "--encoding",
         default="utf-8",
         help="Specify the encoding for input and output (default: utf-8)",
     )
+    group.add_argument(
+        "--line-endings",
+        choices=["platform", "lf", "crlf"],
+        default="platform",
+        help="Line endings to use when writing files (default: platform)",
+    )
     group.add_argument(
         "-c",
         "--config",
@@ -597,12 +787,13 @@ def get_parser(default_config_files, git_root):
             " or home directory)"
         ),
     )
+    # This is a duplicate of the argument in the preparser and is a no-op by this time of
+    # argument parsing, but it's here so that the help is displayed as expected.
     group.add_argument(
-        "--gui",
+        "--env-file",
-        "--browser",
+        metavar="ENV_FILE",
-        action="store_true",
+        default=default_env_file(git_root),
-        help="Run aider in your browser",
+        help="Specify the .env file to load (default: .env in git root)",
-        default=False,
     )
     group.add_argument(
         "--suggest-shell-commands",
@@ -610,6 +801,34 @@ def get_parser(default_config_files, git_root):
         default=True,
         help="Enable/disable suggesting shell commands (default: True)",
     )
+    group.add_argument(
+        "--fancy-input",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable fancy input with history and completion (default: True)",
+    )
+    group.add_argument(
+        "--multiline",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Enable/disable multi-line input mode with Meta-Enter to submit (default: False)",
+    )
+    group.add_argument(
+        "--detect-urls",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable detection and offering to add URLs to chat (default: True)",
+    )
+    group.add_argument(
+        "--editor",
+        help="Specify which editor to use for the /editor command",
+    )
+    group.add_argument(
+        "--install-tree-sitter-language-pack",
+        action="store_true",
+        help="Install the tree_sitter_language_pack (experimental)",
+        default=False,
+    )
 
     return parser
 
@@ -625,7 +844,6 @@ def get_md_help():
     parser.formatter_class = MarkdownHelpFormatter
 
     return argparse.ArgumentParser.format_help(parser)
-    return parser.format_help()
 
 
 def get_sample_yaml():
@@ -639,7 +857,6 @@ def get_sample_yaml():
     parser.formatter_class = YamlHelpFormatter
 
     return argparse.ArgumentParser.format_help(parser)
-    return parser.format_help()
 
 
 def get_sample_dotenv():
@@ -653,7 +870,6 @@ def get_sample_dotenv():
     parser.formatter_class = DotEnvFormatter
 
     return argparse.ArgumentParser.format_help(parser)
-    return parser.format_help()
 
 
 def main():

aider/args_formatter.py

@@ -147,7 +147,10 @@ class YamlHelpFormatter(argparse.HelpFormatter):
         elif action.nargs in ("*", "+") or isinstance(action, argparse._AppendAction):
             parts.append(f"#{switch}: xxx")
             parts.append("## Specify multiple values like this:")
-            parts.append(f"#{switch}: [xxx,yyyy,zzz]\n")
+            parts.append(f"#{switch}:")
+            parts.append(f"#  - xxx")
+            parts.append(f"#  - yyy")
+            parts.append(f"#  - zzz")
         else:
             parts.append(f"#{switch}: xxx\n")
 

aider/coders/__init__.py

@@ -1,13 +1,16 @@
+from .architect_coder import ArchitectCoder
 from .ask_coder import AskCoder
 from .base_coder import Coder
 from .editblock_coder import EditBlockCoder
 from .editblock_fenced_coder import EditBlockFencedCoder
+from .editor_editblock_coder import EditorEditBlockCoder
+from .editor_whole_coder import EditorWholeFileCoder
 from .help_coder import HelpCoder
-
-# from .single_wholefile_func_coder import SingleWholeFileFunctionCoder
 from .udiff_coder import UnifiedDiffCoder
 from .wholefile_coder import WholeFileCoder
 
+# from .single_wholefile_func_coder import SingleWholeFileFunctionCoder
+
 __all__ = [
     HelpCoder,
     AskCoder,
@@ -17,4 +20,7 @@ __all__ = [
     WholeFileCoder,
     UnifiedDiffCoder,
     #    SingleWholeFileFunctionCoder,
+    ArchitectCoder,
+    EditorEditBlockCoder,
+    EditorWholeFileCoder,
 ]

aider/coders/architect_coder.py

@@ -0,0 +1,47 @@
+from .architect_prompts import ArchitectPrompts
+from .ask_coder import AskCoder
+from .base_coder import Coder
+
+
+class ArchitectCoder(AskCoder):
+    edit_format = "architect"
+    gpt_prompts = ArchitectPrompts()
+
+    def reply_completed(self):
+        content = self.partial_response_content
+
+        if not content or not content.strip():
+            return
+
+        if not self.io.confirm_ask("Edit the files?"):
+            return
+
+        kwargs = dict()
+
+        # Use the editor_model from the main_model if it exists, otherwise use the main_model itself
+        editor_model = self.main_model.editor_model or self.main_model
+
+        kwargs["main_model"] = editor_model
+        kwargs["edit_format"] = self.main_model.editor_edit_format
+        kwargs["suggest_shell_commands"] = False
+        kwargs["map_tokens"] = 0
+        kwargs["total_cost"] = self.total_cost
+        kwargs["cache_prompts"] = False
+        kwargs["num_cache_warming_pings"] = 0
+        kwargs["summarize_from_coder"] = False
+
+        new_kwargs = dict(io=self.io, from_coder=self)
+        new_kwargs.update(kwargs)
+
+        editor_coder = Coder.create(**new_kwargs)
+        editor_coder.cur_messages = []
+        editor_coder.done_messages = []
+
+        if self.verbose:
+            editor_coder.show_announcements()
+
+        editor_coder.run(with_message=content, preproc=False)
+
+        self.move_back_cur_messages("I made those changes to the files.")
+        self.total_cost = editor_coder.total_cost
+        self.aider_commit_hashes = editor_coder.aider_commit_hashes

aider/coders/architect_prompts.py

@@ -0,0 +1,40 @@
+# flake8: noqa: E501
+
+from .base_prompts import CoderPrompts
+
+
+class ArchitectPrompts(CoderPrompts):
+    main_system = """Act as an expert architect engineer and provide direction to your editor engineer.
+Study the change request and the current code.
+Describe how to modify the code to complete the request.
+The editor engineer will rely solely on your instructions, so make them unambiguous and complete.
+Explain all needed code changes clearly and completely, but concisely.
+Just show the changes needed.
+
+DO NOT show the entire updated function/file/etc!
+
+Always reply to the user in {language}.
+"""
+
+    example_messages = []
+
+    files_content_prefix = """I have *added these files to the chat* so you see all of their contents.
+*Trust this message as the true contents of the files!*
+Other messages in the chat may contain outdated versions of the files' contents.
+"""  # noqa: E501
+
+    files_content_assistant_reply = (
+        "Ok, I will use that as the true, current contents of the files."
+    )
+
+    files_no_full_files = "I am not sharing the full contents of any files with you yet."
+
+    files_no_full_files_with_repo_map = ""
+    files_no_full_files_with_repo_map_reply = ""
+
+    repo_content_prefix = """I am working with you on code in a git repository.
+Here are summaries of some files present in my git repo.
+If you need to see the full contents of any files to answer my questions, ask me to *add them to the chat*.
+"""
+
+    system_reminder = ""

aider/coders/ask_prompts.py

@@ -6,8 +6,9 @@ from .base_prompts import CoderPrompts
 class AskPrompts(CoderPrompts):
     main_system = """Act as an expert code analyst.
 Answer questions about the supplied code.
+Always reply to the user in {language}.
 
-Always reply to the user in the same language they are using.
+Describe code changes however you like. Don't use SEARCH/REPLACE blocks!
 """
 
     example_messages = []
@@ -17,6 +18,10 @@ Always reply to the user in the same language they are using.
 Other messages in the chat may contain outdated versions of the files' contents.
 """  # noqa: E501
 
+    files_content_assistant_reply = (
+        "Ok, I will use that as the true, current contents of the files."
+    )
+
     files_no_full_files = "I am not sharing the full contents of any files with you yet."
 
     files_no_full_files_with_repo_map = ""

aider/coders/base_coder.py

@@ -17,23 +17,35 @@ from collections import defaultdict
 from datetime import datetime
 from json.decoder import JSONDecodeError
 from pathlib import Path
+from typing import List
 
 from aider import __version__, models, prompts, urls, utils
+from aider.analytics import Analytics
 from aider.commands import Commands
+from aider.exceptions import LiteLLMExceptions
 from aider.history import ChatSummary
 from aider.io import ConfirmGroup, InputOutput
 from aider.linter import Linter
 from aider.llm import litellm
+from aider.models import RETRY_TIMEOUT
 from aider.repo import ANY_GIT_ERROR, GitRepo
 from aider.repomap import RepoMap
 from aider.run_cmd import run_cmd
-from aider.sendchat import retry_exceptions, send_completion
 from aider.utils import format_content, format_messages, format_tokens, is_image_file
 
 from ..dump import dump  # noqa: F401
 from .chat_chunks import ChatChunks
 
 
+class UnknownEditFormat(ValueError):
+    def __init__(self, edit_format, valid_formats):
+        self.edit_format = edit_format
+        self.valid_formats = valid_formats
+        super().__init__(
+            f"Unknown edit format {edit_format}. Valid formats are: {', '.join(valid_formats)}"
+        )
+
+
 class MissingAPIKeyError(ValueError):
     pass
 
@@ -47,7 +59,8 @@ def wrap_fence(name):
 
 
 all_fences = [
-    ("``" + "`", "``" + "`"),
+    ("`" * 3, "`" * 3),
+    ("`" * 4, "`" * 4),  # LLMs ignore and revert to triple-backtick, causing #2879
     wrap_fence("source"),
     wrap_fence("code"),
     wrap_fence("pre"),
@@ -72,7 +85,7 @@ class Coder:
     max_reflections = 3
     edit_format = None
     yield_stream = False
-    temperature = 0
+    temperature = None
     auto_lint = True
     auto_test = False
     test_cmd = None
@@ -88,8 +101,10 @@ class Coder:
     cache_warming_thread = None
     num_cache_warming_pings = 0
     suggest_shell_commands = True
+    detect_urls = True
     ignore_mentions = None
     chat_language = None
+    file_watcher = None
 
     @classmethod
     def create(
@@ -129,7 +144,13 @@ class Coder:
             # the system prompt.
             done_messages = from_coder.done_messages
             if edit_format != from_coder.edit_format and done_messages and summarize_from_coder:
+                try:
                     done_messages = from_coder.summarizer.summarize_all(done_messages)
+                except ValueError:
+                    # If summarization fails, keep the original messages and warn the user
+                    io.tool_warning(
+                        "Chat history summarization failed, continuing with full history"
+                    )
 
             # Bring along context from the old Coder
             update = dict(
@@ -140,12 +161,14 @@ class Coder:
                 aider_commit_hashes=from_coder.aider_commit_hashes,
                 commands=from_coder.commands.clone(),
                 total_cost=from_coder.total_cost,
+                ignore_mentions=from_coder.ignore_mentions,
+                file_watcher=from_coder.file_watcher,
             )
-
             use_kwargs.update(update)  # override to complete the switch
             use_kwargs.update(kwargs)  # override passed kwargs
 
             kwargs = use_kwargs
+            from_coder.ok_to_warm_cache = False
 
         for coder in coders.__all__:
             if hasattr(coder, "edit_format") and coder.edit_format == edit_format:
@@ -153,11 +176,15 @@ class Coder:
                 res.original_kwargs = dict(kwargs)
                 return res
 
-        raise ValueError(f"Unknown edit format {edit_format}")
+        valid_formats = [
+            str(c.edit_format)
+            for c in coders.__all__
+            if hasattr(c, "edit_format") and c.edit_format is not None
+        ]
+        raise UnknownEditFormat(edit_format, valid_formats)
 
     def clone(self, **kwargs):
         new_coder = Coder.create(from_coder=self, **kwargs)
-        new_coder.ignore_mentions = self.ignore_mentions
         return new_coder
 
     def get_announcements(self):
@@ -180,6 +207,13 @@ class Coder:
             output += ", infinite output"
         lines.append(output)
 
+        if self.edit_format == "architect":
+            output = (
+                f"Editor model: {main_model.editor_model.name} with"
+                f" {main_model.editor_edit_format} edit format"
+            )
+            lines.append(output)
+
         if weak_model is not main_model:
             output = f"Weak model: {weak_model.name}"
             lines.append(output)
@@ -204,10 +238,10 @@ class Coder:
             if map_tokens > 0:
                 refresh = self.repo_map.refresh
                 lines.append(f"Repo-map: using {map_tokens} tokens, {refresh} refresh")
-                max_map_tokens = 2048
+                max_map_tokens = self.main_model.get_repo_map_tokens() * 2
                 if map_tokens > max_map_tokens:
                     lines.append(
-                        f"Warning: map-tokens > {max_map_tokens} is not recommended as too much"
+                        f"Warning: map-tokens > {max_map_tokens} is not recommended. Too much"
                         " irrelevant code can confuse LLMs."
                     )
             else:
@@ -219,11 +253,20 @@ class Coder:
         for fname in self.get_inchat_relative_files():
             lines.append(f"Added {fname} to the chat.")
 
+        for fname in self.abs_read_only_fnames:
+            rel_fname = self.get_rel_fname(fname)
+            lines.append(f"Added {rel_fname} to the chat (read-only).")
+
         if self.done_messages:
             lines.append("Restored previous conversation history.")
 
+        if self.io.multiline_mode:
+            lines.append("Multiline mode: Enabled. Enter inserts newline, Alt-Enter submits text")
+
         return lines
 
+    ok_to_warm_cache = False
+
     def __init__(
         self,
         main_model,
@@ -251,20 +294,39 @@ class Coder:
         commands=None,
         summarizer=None,
         total_cost=0.0,
+        analytics=None,
         map_refresh="auto",
         cache_prompts=False,
         num_cache_warming_pings=0,
         suggest_shell_commands=True,
         chat_language=None,
+        detect_urls=True,
+        ignore_mentions=None,
+        file_watcher=None,
+        auto_copy_context=False,
     ):
+        # Fill in a dummy Analytics if needed, but it is never .enable()'d
+        self.analytics = analytics if analytics is not None else Analytics()
+
+        self.event = self.analytics.event
         self.chat_language = chat_language
         self.commit_before_message = []
         self.aider_commit_hashes = set()
         self.rejected_urls = set()
         self.abs_root_path_cache = {}
+
+        self.auto_copy_context = auto_copy_context
+
+        self.ignore_mentions = ignore_mentions
+        if not self.ignore_mentions:
             self.ignore_mentions = set()
 
+        self.file_watcher = file_watcher
+        if self.file_watcher:
+            self.file_watcher.coder = self
+
         self.suggest_shell_commands = suggest_shell_commands
+        self.detect_urls = detect_urls
 
         self.num_cache_warming_pings = num_cache_warming_pings
 
@@ -300,7 +362,6 @@ class Coder:
             self.done_messages = []
 
         self.io = io
-        self.stream = stream
 
         self.shell_commands = []
 
@@ -315,6 +376,8 @@ class Coder:
 
         self.main_model = main_model
 
+        self.stream = stream and main_model.streaming
+
         if cache_prompts and self.main_model.cache_control:
             self.add_cache_headers = True
 
@@ -340,6 +403,9 @@ class Coder:
 
         for fname in fnames:
             fname = Path(fname)
+            if self.repo and self.repo.git_ignored_file(fname):
+                self.io.tool_warning(f"Skipping {fname} that matches gitignore spec.")
+
             if self.repo and self.repo.ignored_file(fname):
                 self.io.tool_warning(f"Skipping {fname} that matches aiderignore spec.")
                 continue
@@ -402,6 +468,7 @@ class Coder:
 
         self.summarizer_thread = None
         self.summarized_done_messages = []
+        self.summarizing_messages = None
 
         if not self.done_messages and restore_chat_history:
             history_md = self.io.read_text(self.io.chat_history_file)
@@ -468,7 +535,7 @@ class Coder:
             return False
 
         # only show pretty output if fences are the normal triple-backtick
-        if self.fence != self.fences[0]:
+        if self.fence[0][0] != "`":
             return False
 
         return True
@@ -562,9 +629,19 @@ class Coder:
     def get_ident_filename_matches(self, idents):
         all_fnames = defaultdict(set)
         for fname in self.get_all_relative_files():
-            base = Path(fname).with_suffix("").name.lower()
+            # Skip empty paths or just '.'
+            if not fname or fname == ".":
+                continue
+
+            try:
+                # Handle dotfiles properly
+                path = Path(fname)
+                base = path.stem.lower()  # Use stem instead of with_suffix("").name
                 if len(base) >= 5:
                     all_fnames[base].add(fname)
+            except ValueError:
+                # Skip paths that can't be processed
+                continue
 
         matches = set()
         for ident in idents:
@@ -630,6 +707,8 @@ class Coder:
 
     def get_readonly_files_messages(self):
         readonly_messages = []
+
+        # Handle non-image files
         read_only_content = self.get_read_only_files_content()
         if read_only_content:
             readonly_messages += [
@@ -641,6 +720,15 @@ class Coder:
                     content="Ok, I will use these files as references.",
                 ),
             ]
+
+        # Handle image files
+        images_message = self.get_images_message(self.abs_read_only_fnames)
+        if images_message is not None:
+            readonly_messages += [
+                images_message,
+                dict(role="assistant", content="Ok, I will use these images as references."),
+            ]
+
         return readonly_messages
 
     def get_chat_files_messages(self):
@@ -648,7 +736,7 @@ class Coder:
         if self.abs_fnames:
             files_content = self.gpt_prompts.files_content_prefix
             files_content += self.get_files_content()
-            files_reply = "Ok, any changes I propose will be to those files."
+            files_reply = self.gpt_prompts.files_content_assistant_reply
         elif self.get_repo_map() and self.gpt_prompts.files_no_full_files_with_repo_map:
             files_content = self.gpt_prompts.files_no_full_files_with_repo_map
             files_reply = self.gpt_prompts.files_no_full_files_with_repo_map_reply
@@ -662,7 +750,7 @@ class Coder:
                 dict(role="assistant", content=files_reply),
             ]
 
-        images_message = self.get_images_message()
+        images_message = self.get_images_message(self.abs_fnames)
         if images_message is not None:
             chat_files_messages += [
                 images_message,
@@ -671,23 +759,42 @@ class Coder:
 
         return chat_files_messages
 
-    def get_images_message(self):
+    def get_images_message(self, fnames):
-        if not self.main_model.accepts_images:
+        supports_images = self.main_model.info.get("supports_vision")
+        supports_pdfs = self.main_model.info.get("supports_pdf_input") or self.main_model.info.get(
+            "max_pdf_size_mb"
+        )
+
+        # https://github.com/BerriAI/litellm/pull/6928
+        supports_pdfs = supports_pdfs or "claude-3-5-sonnet-20241022" in self.main_model.name
+
+        if not (supports_images or supports_pdfs):
             return None
 
         image_messages = []
-        for fname, content in self.get_abs_fnames_content():
+        for fname in fnames:
-            if is_image_file(fname):
+            if not is_image_file(fname):
+                continue
+
+            mime_type, _ = mimetypes.guess_type(fname)
+            if not mime_type:
+                continue
+
             with open(fname, "rb") as image_file:
                 encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
-                mime_type, _ = mimetypes.guess_type(fname)
-                if mime_type and mime_type.startswith("image/"):
             image_url = f"data:{mime_type};base64,{encoded_string}"
             rel_fname = self.get_rel_fname(fname)
+
+            if mime_type.startswith("image/") and supports_images:
                 image_messages += [
                     {"type": "text", "text": f"Image file: {rel_fname}"},
                     {"type": "image_url", "image_url": {"url": image_url, "detail": "high"}},
                 ]
+            elif mime_type == "application/pdf" and supports_pdfs:
+                image_messages += [
+                    {"type": "text", "text": f"PDF file: {rel_fname}"},
+                    {"type": "image_url", "image_url": image_url},
+                ]
 
         if not image_messages:
             return None
@@ -706,6 +813,7 @@ class Coder:
         self.lint_outcome = None
         self.test_outcome = None
         self.shell_commands = []
+        self.message_cost = 0
 
         if self.repo:
             self.commit_before_message.append(self.repo.get_head_commit_sha())
@@ -716,9 +824,10 @@ class Coder:
                 self.io.user_input(with_message)
                 self.run_one(with_message, preproc)
                 return self.partial_response_content
-
             while True:
                 try:
+                    if not self.io.placeholder:
+                        self.copy_context()
                     user_message = self.get_input()
                     self.run_one(user_message, preproc)
                     self.show_undo_hint()
@@ -727,6 +836,10 @@ class Coder:
         except EOFError:
             return
 
+    def copy_context(self):
+        if self.auto_copy_context:
+            self.commands.cmd_copy_context()
+
     def get_input(self):
         inchat_files = self.get_inchat_relative_files()
         read_only_files = [self.get_rel_fname(fname) for fname in self.abs_read_only_fnames]
@@ -749,7 +862,7 @@ class Coder:
             return self.commands.run(inp)
 
         self.check_for_file_mentions(inp)
-        self.check_for_urls(inp)
+        inp = self.check_for_urls(inp)
 
         return inp
 
@@ -775,21 +888,43 @@ class Coder:
             self.num_reflections += 1
             message = self.reflected_message
 
-    def check_for_urls(self, inp):
+    def check_and_open_urls(self, exc, friendly_msg=None):
+        """Check exception for URLs, offer to open in a browser, with user-friendly error msgs."""
+        text = str(exc)
+
+        if friendly_msg:
+            self.io.tool_warning(text)
+            self.io.tool_error(f"{friendly_msg}")
+        else:
+            self.io.tool_error(text)
+
+        url_pattern = re.compile(r"(https?://[^\s/$.?#].[^\s]*)")
+        urls = list(set(url_pattern.findall(text)))  # Use set to remove duplicates
+        for url in urls:
+            url = url.rstrip(".',\"")
+            self.io.offer_url(url)
+        return urls
+
+    def check_for_urls(self, inp: str) -> List[str]:
+        """Check input for URLs and offer to add them to the chat."""
+        if not self.detect_urls:
+            return inp
+
         url_pattern = re.compile(r"(https?://[^\s/$.?#].[^\s]*[^\s,.])")
         urls = list(set(url_pattern.findall(inp)))  # Use set to remove duplicates
-        added_urls = []
         group = ConfirmGroup(urls)
         for url in urls:
             if url not in self.rejected_urls:
-                if self.io.confirm_ask("Add URL to the chat?", subject=url, group=group):
+                url = url.rstrip(".',\"")
+                if self.io.confirm_ask(
+                    "Add URL to the chat?", subject=url, group=group, allow_never=True
+                ):
                     inp += "\n\n"
-                    inp += self.commands.cmd_web(url)
+                    inp += self.commands.cmd_web(url, return_content=True)
-                    added_urls.append(url)
                 else:
                     self.rejected_urls.add(url)
 
-        return added_urls
+        return inp
 
     def keyboard_interrupt(self):
         now = time.time()
@@ -797,6 +932,7 @@ class Coder:
         thresh = 2  # seconds
         if self.last_keyboard_interrupt and now - self.last_keyboard_interrupt < thresh:
             self.io.tool_warning("\n\n^C KeyboardInterrupt")
+            self.event("exit", reason="Control-C")
             sys.exit()
 
         self.io.tool_warning("\n\n^C again to exit")
@@ -816,8 +952,9 @@ class Coder:
         self.summarizer_thread.start()
 
     def summarize_worker(self):
+        self.summarizing_messages = list(self.done_messages)
         try:
-            self.summarized_done_messages = self.summarizer.summarize(self.done_messages)
+            self.summarized_done_messages = self.summarizer.summarize(self.summarizing_messages)
         except ValueError as err:
             self.io.tool_warning(err.args[0])
 
@@ -831,7 +968,9 @@ class Coder:
         self.summarizer_thread.join()
         self.summarizer_thread = None
 
+        if self.summarizing_messages == self.done_messages:
             self.done_messages = self.summarized_done_messages
+        self.summarizing_messages = None
         self.summarized_done_messages = []
 
     def move_back_cur_messages(self, message):
@@ -920,13 +1059,31 @@ class Coder:
                 platform=platform_text
             )
 
+        if self.chat_language:
+            language = self.chat_language
+        else:
+            language = "the same language they are using"
+
+        if self.fence[0] == "`" * 4:
+            quad_backtick_reminder = (
+                "\nIMPORTANT: Use *quadruple* backticks ```` as fences, not triple backticks!\n"
+            )
+        else:
+            quad_backtick_reminder = ""
+
         prompt = prompt.format(
             fence=self.fence,
+            quad_backtick_reminder=quad_backtick_reminder,
             lazy_prompt=lazy_prompt,
             platform=platform_text,
             shell_cmd_prompt=shell_cmd_prompt,
             shell_cmd_reminder=shell_cmd_reminder,
+            language=language,
         )
+
+        if self.main_model.system_prompt_prefix:
+            prompt = self.main_model.system_prompt_prefix + prompt
+
         return prompt
 
     def format_chat_chunks(self):
@@ -1009,18 +1166,21 @@ class Coder:
             # add the reminder anyway
             total_tokens = 0
 
+        if chunks.cur:
             final = chunks.cur[-1]
+        else:
+            final = None
 
         max_input_tokens = self.main_model.info.get("max_input_tokens") or 0
         # Add the reminder prompt if we still have room to include it.
         if (
-            max_input_tokens is None
+            not max_input_tokens
             or total_tokens < max_input_tokens
             and self.gpt_prompts.system_reminder
         ):
             if self.main_model.reminder == "sys":
                 chunks.reminder = reminder_message
-            elif self.main_model.reminder == "user" and final["role"] == "user":
+            elif self.main_model.reminder == "user" and final and final["role"] == "user":
                 # stuff it into the user message
                 new_content = (
                     final["content"]
@@ -1043,8 +1203,11 @@ class Coder:
             return
         if not self.num_cache_warming_pings:
             return
+        if not self.ok_to_warm_cache:
+            return
 
         delay = 5 * 60 - 5
+        delay = float(os.environ.get("AIDER_CACHE_KEEPALIVE_DELAY", delay))
         self.next_cache_warm = time.time() + delay
         self.warming_pings_left = self.num_cache_warming_pings
         self.cache_warming_chunks = chunks
@@ -1053,7 +1216,7 @@ class Coder:
             return
 
         def warm_cache_worker():
-            while True:
+            while self.ok_to_warm_cache:
                 time.sleep(1)
                 if self.warming_pings_left <= 0:
                     continue
@@ -1064,13 +1227,15 @@ class Coder:
                 self.warming_pings_left -= 1
                 self.next_cache_warm = time.time() + delay
 
+                kwargs = dict(self.main_model.extra_params) or dict()
+                kwargs["max_tokens"] = 1
+
                 try:
                     completion = litellm.completion(
                         model=self.main_model.name,
                         messages=self.cache_warming_chunks.cacheable_messages(),
                         stream=False,
-                        max_tokens=1,
+                        **kwargs,
-                        extra_headers=self.main_model.extra_headers,
                     )
                 except Exception as err:
                     self.io.tool_warning(f"Cache warming error: {str(err)}")
@@ -1089,23 +1254,55 @@ class Coder:
 
         return chunks
 
+    def check_tokens(self, messages):
+        """Check if the messages will fit within the model's token limits."""
+        input_tokens = self.main_model.token_count(messages)
+        max_input_tokens = self.main_model.info.get("max_input_tokens") or 0
+
+        if max_input_tokens and input_tokens >= max_input_tokens:
+            self.io.tool_error(
+                f"Your estimated chat context of {input_tokens:,} tokens exceeds the"
+                f" {max_input_tokens:,} token limit for {self.main_model.name}!"
+            )
+            self.io.tool_output("To reduce the chat context:")
+            self.io.tool_output("- Use /drop to remove unneeded files from the chat")
+            self.io.tool_output("- Use /clear to clear the chat history")
+            self.io.tool_output("- Break your code into smaller files")
+            self.io.tool_output(
+                "It's probably safe to try and send the request, most providers won't charge if"
+                " the context limit is exceeded."
+            )
+
+            if not self.io.confirm_ask("Try to proceed anyway?"):
+                return False
+        return True
+
     def send_message(self, inp):
+        self.event("message_send_starting")
+
         self.cur_messages += [
             dict(role="user", content=inp),
         ]
 
         chunks = self.format_messages()
         messages = chunks.all_messages()
+        if not self.check_tokens(messages):
+            return
         self.warm_cache(chunks)
 
         if self.verbose:
             utils.show_messages(messages, functions=self.functions)
 
         self.multi_response_content = ""
-        self.mdstream = self.io.assistant_output("", self.stream)
+        if self.show_pretty() and self.stream:
+            self.mdstream = self.io.get_assistant_mdstream()
+        else:
+            self.mdstream = None
 
         retry_delay = 0.125
 
+        litellm_ex = LiteLLMExceptions()
+
         self.usage_report = None
         exhausted = False
         interrupted = False
@@ -1114,31 +1311,44 @@ class Coder:
                 try:
                     yield from self.send(messages, functions=self.functions)
                     break
-                except retry_exceptions() as err:
+                except litellm_ex.exceptions_tuple() as err:
-                    self.io.tool_warning(str(err))
+                    ex_info = litellm_ex.get_ex_info(err)
-                    retry_delay *= 2
+
-                    if retry_delay > 60:
+                    if ex_info.name == "ContextWindowExceededError":
+                        exhausted = True
                         break
+
+                    should_retry = ex_info.retry
+                    if should_retry:
+                        retry_delay *= 2
+                        if retry_delay > RETRY_TIMEOUT:
+                            should_retry = False
+
+                    if not should_retry:
+                        self.mdstream = None
+                        self.check_and_open_urls(err, ex_info.description)
+                        break
+
+                    err_msg = str(err)
+                    if ex_info.description:
+                        self.io.tool_warning(err_msg)
+                        self.io.tool_error(ex_info.description)
+                    else:
+                        self.io.tool_error(err_msg)
+
                     self.io.tool_output(f"Retrying in {retry_delay:.1f} seconds...")
                     time.sleep(retry_delay)
                     continue
                 except KeyboardInterrupt:
                     interrupted = True
                     break
-                except litellm.ContextWindowExceededError:
-                    # The input is overflowing the context window!
-                    exhausted = True
-                    break
-                except litellm.exceptions.BadRequestError as br_err:
-                    self.io.tool_error(f"BadRequestError: {br_err}")
-                    return
                 except FinishReasonLength:
                     # We hit the output limit!
                     if not self.main_model.info.get("supports_assistant_prefill"):
                         exhausted = True
                         break
 
-                    self.multi_response_content = self.get_multi_response_content()
+                    self.multi_response_content = self.get_multi_response_content_in_progress()
 
                     if messages[-1]["role"] == "assistant":
                         messages[-1]["content"] = self.multi_response_content
@@ -1147,23 +1357,38 @@ class Coder:
                             dict(role="assistant", content=self.multi_response_content, prefix=True)
                         )
                 except Exception as err:
-                    self.io.tool_error(f"Unexpected error: {err}")
+                    self.mdstream = None
                     lines = traceback.format_exception(type(err), err, err.__traceback__)
-                    self.io.tool_error("".join(lines))
+                    self.io.tool_warning("".join(lines))
+                    self.io.tool_error(str(err))
+                    self.event("message_send_exception", exception=str(err))
                     return
         finally:
             if self.mdstream:
                 self.live_incremental_response(True)
                 self.mdstream = None
 
-            self.partial_response_content = self.get_multi_response_content(True)
+            self.partial_response_content = self.get_multi_response_content_in_progress(True)
+            self.partial_response_content = self.main_model.remove_reasoning_content(
+                self.partial_response_content
+            )
             self.multi_response_content = ""
 
         self.io.tool_output()
 
         self.show_usage_report()
 
+        self.add_assistant_reply_to_cur_messages()
+
         if exhausted:
+            if self.cur_messages and self.cur_messages[-1]["role"] == "user":
+                self.cur_messages += [
+                    dict(
+                        role="assistant",
+                        content="FinishReasonLength exception: you sent too many tokens",
+                    ),
+                ]
+
             self.show_exhausted_error()
             self.num_exhausted_context_windows += 1
             return
@@ -1179,15 +1404,32 @@ class Coder:
         else:
             content = ""
 
+        if not interrupted:
+            add_rel_files_message = self.check_for_file_mentions(content)
+            if add_rel_files_message:
+                if self.reflected_message:
+                    self.reflected_message += "\n\n" + add_rel_files_message
+                else:
+                    self.reflected_message = add_rel_files_message
+                return
+
+            try:
+                self.reply_completed()
+            except KeyboardInterrupt:
+                interrupted = True
+
         if interrupted:
-            content += "\n^C KeyboardInterrupt"
+            if self.cur_messages and self.cur_messages[-1]["role"] == "user":
-            self.cur_messages += [dict(role="assistant", content=content)]
+                self.cur_messages[-1]["content"] += "\n^C KeyboardInterrupt"
+            else:
+                self.cur_messages += [dict(role="user", content="^C KeyboardInterrupt")]
+            self.cur_messages += [
+                dict(role="assistant", content="I see that you interrupted my previous reply.")
+            ]
             return
 
         edited = self.apply_updates()
 
-        self.update_cur_messages()
-
         if edited:
             self.aider_edited_files.update(edited)
             saved_message = self.auto_commit(edited)
@@ -1208,7 +1450,6 @@ class Coder:
                 ok = self.io.confirm_ask("Attempt to fix lint errors?")
                 if ok:
                     self.reflected_message = lint_errors
-                    self.update_cur_messages()
                     return
 
         shared_output = self.run_shell_commands()
@@ -1225,15 +1466,10 @@ class Coder:
                 ok = self.io.confirm_ask("Attempt to fix test errors?")
                 if ok:
                     self.reflected_message = test_errors
-                    self.update_cur_messages()
                     return
 
-        add_rel_files_message = self.check_for_file_mentions(content)
+    def reply_completed(self):
-        if add_rel_files_message:
+        pass
-            if self.reflected_message:
-                self.reflected_message += "\n\n" + add_rel_files_message
-            else:
-                self.reflected_message = add_rel_files_message
 
     def show_exhausted_error(self):
         output_tokens = 0
@@ -1274,9 +1510,7 @@ class Coder:
             res.append("- Ask for smaller changes in each request.")
             res.append("- Break your code into smaller source files.")
             if "diff" not in self.main_model.edit_format:
-                res.append(
+                res.append("- Use a stronger model that can return diffs.")
-                    "- Use a stronger model like gpt-4o, sonnet or opus that can return diffs."
-                )
 
         if input_tokens >= max_input_tokens or total_tokens >= max_input_tokens:
             res.append("")
@@ -1286,15 +1520,15 @@ class Coder:
             res.append("- Use /clear to clear the chat history.")
             res.append("- Break your code into smaller source files.")
 
-        res.append("")
-        res.append(f"For more info: {urls.token_limits}")
-
         res = "".join([line + "\n" for line in res])
         self.io.tool_error(res)
+        self.io.offer_url(urls.token_limits)
 
     def lint_edited(self, fnames):
         res = ""
         for fname in fnames:
+            if not fname:
+                continue
             errors = self.linter.lint(self.abs_root_path(fname))
 
             if errors:
@@ -1307,7 +1541,11 @@ class Coder:
 
         return res
 
-    def update_cur_messages(self):
+    def __del__(self):
+        """Cleanup when the Coder object is destroyed."""
+        self.ok_to_warm_cache = False
+
+    def add_assistant_reply_to_cur_messages(self):
         if self.partial_response_content:
             self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
         if self.partial_response_function_call:
@@ -1323,7 +1561,7 @@ class Coder:
         words = set(word for word in content.split())
 
         # drop sentence punctuation from the end
-        words = set(word.rstrip(",.!;:") for word in words)
+        words = set(word.rstrip(",.!;:?") for word in words)
 
         # strip away all kinds of quotes
         quotes = "".join(['"', "'", "`"])
@@ -1331,9 +1569,18 @@ class Coder:
 
         addable_rel_fnames = self.get_addable_relative_files()
 
+        # Get basenames of files already in chat or read-only
+        existing_basenames = {os.path.basename(f) for f in self.get_inchat_relative_files()} | {
+            os.path.basename(self.get_rel_fname(f)) for f in self.abs_read_only_fnames
+        }
+
         mentioned_rel_fnames = set()
         fname_to_rel_fnames = {}
         for rel_fname in addable_rel_fnames:
+            # Skip files that share a basename with files already in chat
+            if os.path.basename(rel_fname) in existing_basenames:
+                continue
+
             normalized_rel_fname = rel_fname.replace("\\", "/")
             normalized_words = set(word.replace("\\", "/") for word in words)
             if normalized_rel_fname in normalized_words:
@@ -1364,7 +1611,9 @@ class Coder:
         added_fnames = []
         group = ConfirmGroup(new_mentions)
         for rel_fname in sorted(new_mentions):
-            if self.io.confirm_ask(f"Add {rel_fname} to the chat?", group=group):
+            if self.io.confirm_ask(
+                "Add file to the chat?", subject=rel_fname, group=group, allow_never=True
+            ):
                 self.add_rel_fname(rel_fname)
                 added_fnames.append(rel_fname)
             else:
@@ -1382,21 +1631,13 @@ class Coder:
 
         self.io.log_llm_history("TO LLM", format_messages(messages))
 
-        if self.main_model.use_temperature:
-            temp = self.temperature
-        else:
-            temp = None
-
         completion = None
         try:
-            hash_object, completion = send_completion(
+            hash_object, completion = model.send_completion(
-                model.name,
                 messages,
                 functions,
                 self.stream,
-                temp,
+                self.temperature,
-                extra_headers=model.extra_headers,
-                max_tokens=model.max_tokens,
             )
             self.chat_completion_call_hashes.append(hash_object.hexdigest())
 
@@ -1404,6 +1645,16 @@ class Coder:
                 yield from self.show_send_output_stream(completion)
             else:
                 self.show_send_output(completion)
+
+            # Calculate costs for successful responses
+            self.calculate_and_show_tokens_and_cost(messages, completion)
+
+        except LiteLLMExceptions().exceptions_tuple() as err:
+            ex_info = LiteLLMExceptions().get_ex_info(err)
+            if ex_info.name == "ContextWindowExceededError":
+                # Still calculate costs for context window errors
+                self.calculate_and_show_tokens_and_cost(messages, completion)
+            raise
         except KeyboardInterrupt as kbi:
             self.keyboard_interrupt()
             raise kbi
@@ -1421,8 +1672,6 @@ class Coder:
                 if args:
                     self.io.ai_output(json.dumps(args, indent=4))
 
-            self.calculate_and_show_tokens_and_cost(messages, completion)
-
     def show_send_output(self, completion):
         if self.verbose:
             print(completion)
@@ -1459,7 +1708,7 @@ class Coder:
             raise Exception("No data found in LLM response!")
 
         show_resp = self.render_incremental_response(True)
-        self.io.assistant_output(show_resp)
+        self.io.assistant_output(show_resp, pretty=self.show_pretty())
 
         if (
             hasattr(completion.choices[0], "finish_reason")
@@ -1515,7 +1764,7 @@ class Coder:
         self.mdstream.update(show_resp, final=final)
 
     def render_incremental_response(self, final):
-        return self.get_multi_response_content()
+        return self.get_multi_response_content_in_progress()
 
     def calculate_and_show_tokens_and_cost(self, messages, completion=None):
         prompt_tokens = 0
@@ -1535,7 +1784,6 @@ class Coder:
                 completion.usage, "cache_creation_input_tokens"
             ):
                 self.message_tokens_sent += prompt_tokens
-                self.message_tokens_sent += cache_hit_tokens
                 self.message_tokens_sent += cache_write_tokens
             else:
                 self.message_tokens_sent += prompt_tokens
@@ -1617,18 +1865,35 @@ class Coder:
         self.usage_report = tokens_report + sep + cost_report
 
     def show_usage_report(self):
-        if self.usage_report:
+        if not self.usage_report:
+            return
+
         self.io.tool_output(self.usage_report)
+
+        prompt_tokens = self.message_tokens_sent
+        completion_tokens = self.message_tokens_received
+        self.event(
+            "message_send",
+            main_model=self.main_model,
+            edit_format=self.edit_format,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=prompt_tokens + completion_tokens,
+            cost=self.message_cost,
+            total_cost=self.total_cost,
+        )
+
         self.message_cost = 0.0
         self.message_tokens_sent = 0
         self.message_tokens_received = 0
 
-    def get_multi_response_content(self, final=False):
+    def get_multi_response_content_in_progress(self, final=False):
         cur = self.multi_response_content or ""
         new = self.partial_response_content or ""
 
         if new.rstrip() != new and not final:
             new = new.rstrip()
+
         return cur + new
 
     def get_rel_fname(self, fname):
@@ -1696,6 +1961,10 @@ class Coder:
             self.check_for_dirty_commit(path)
             return True
 
+        if self.repo and self.repo.git_ignored_file(path):
+            self.io.tool_warning(f"Skipping edits to {path} that matches gitignore spec.")
+            return
+
         if not Path(full_path).exists():
             if not self.io.confirm_ask("Create new file?", subject=path):
                 self.io.tool_output(f"Skipping edits to {path}")
@@ -1790,8 +2059,10 @@ class Coder:
         edited = set()
         try:
             edits = self.get_edits()
+            edits = self.apply_edits_dry_run(edits)
             edits = self.prepare_to_edit(edits)
             edited = set(edit[0] for edit in edits)
+
             self.apply_edits(edits)
         except ValueError as err:
             self.num_malformed_responses += 1
@@ -1919,6 +2190,9 @@ class Coder:
     def apply_edits(self, edits):
         return
 
+    def apply_edits_dry_run(self, edits):
+        return edits
+
     def run_shell_commands(self):
         if not self.suggest_shell_commands:
             return ""
@@ -1942,7 +2216,11 @@ class Coder:
         )
         prompt = "Run shell command?" if command_count == 1 else "Run shell commands?"
         if not self.io.confirm_ask(
-            prompt, subject="\n".join(commands), explicit_yes_required=True, group=group
+            prompt,
+            subject="\n".join(commands),
+            explicit_yes_required=True,
+            group=group,
+            allow_never=True,
         ):
             return
 
@@ -1956,13 +2234,14 @@ class Coder:
             self.io.tool_output(f"Running {command}")
             # Add the command to input history
             self.io.add_to_input_history(f"/run {command.strip()}")
-            exit_status, output = run_cmd(command, error_print=self.io.tool_error)
+            exit_status, output = run_cmd(command, error_print=self.io.tool_error, cwd=self.root)
             if output:
                 accumulated_output += f"Output from {command}\n{output}\n"
 
-        if accumulated_output.strip() and not self.io.confirm_ask(
+        if accumulated_output.strip() and self.io.confirm_ask(
-            "Add command output to the chat?"
+            "Add command output to the chat?", allow_never=True
         ):
-            accumulated_output = ""
+            num_lines = len(accumulated_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.")
             return accumulated_output

aider/coders/base_prompts.py

@@ -22,6 +22,8 @@ You always COMPLETELY IMPLEMENT the needed code!
 Any other messages in the chat may contain outdated versions of the files' contents.
 """  # noqa: E501
 
+    files_content_assistant_reply = "Ok, any changes I propose will be to those files."
+
     files_no_full_files = "I am not sharing any files that you can edit yet."
 
     files_no_full_files_with_repo_map = """Don't try and edit any existing code without asking me to add the files to the chat!

aider/coders/editblock_coder.py

@@ -35,29 +35,47 @@ class EditBlockCoder(Coder):
 
         return edits
 
-    def apply_edits(self, edits):
+    def apply_edits_dry_run(self, edits):
+        return self.apply_edits(edits, dry_run=True)
+
+    def apply_edits(self, edits, dry_run=False):
         failed = []
         passed = []
+        updated_edits = []
 
         for edit in edits:
             path, original, updated = edit
             full_path = self.abs_root_path(path)
+            new_content = None
+
+            if Path(full_path).exists():
                 content = self.io.read_text(full_path)
                 new_content = do_replace(full_path, content, original, updated, self.fence)
-            if not new_content:
+
+            # If the edit failed, and
+            # this is not a "create a new file" with an empty original...
+            # https://github.com/Aider-AI/aider/issues/2258
+            if not new_content and original.strip():
                 # try patching any of the other files in the chat
                 for full_path in self.abs_fnames:
                     content = self.io.read_text(full_path)
                     new_content = do_replace(full_path, content, original, updated, self.fence)
                     if new_content:
+                        path = self.get_rel_fname(full_path)
                         break
 
+            updated_edits.append((path, original, updated))
+
             if new_content:
+                if not dry_run:
                     self.io.write_text(full_path, new_content)
                 passed.append(edit)
             else:
                 failed.append(edit)
 
+        if dry_run:
+            return updated_edits
+
         if not failed:
             return
 
@@ -365,9 +383,9 @@ def do_replace(fname, content, before_text, after_text, fence=None):
     return new_content
 
 
-HEAD = r"<{5,9} SEARCH"
+HEAD = r"^<{5,9} SEARCH\s*$"
-DIVIDER = r"={5,9}"
+DIVIDER = r"^={5,9}\s*$"
-UPDATED = r">{5,9} REPLACE"
+UPDATED = r"^>{5,9} REPLACE\s*$"
 
 HEAD_ERR = "<<<<<<< SEARCH"
 DIVIDER_ERR = "======="
@@ -383,6 +401,9 @@ missing_filename_err = (
     " {fence[0]}"
 )
 
+# Always be willing to treat triple-backticks as a fence when searching for filenames
+triple_backticks = "`" * 3
+
 
 def strip_filename(filename, fence):
     filename = filename.strip()
@@ -391,7 +412,7 @@ def strip_filename(filename, fence):
         return
 
     start_fence = fence[0]
-    if filename.startswith(start_fence):
+    if filename.startswith(start_fence) or filename.startswith(triple_backticks):
         return
 
     filename = filename.rstrip(":")
@@ -400,7 +421,7 @@ def strip_filename(filename, fence):
     filename = filename.strip("`")
     filename = filename.strip("*")
 
-    # https://github.com/paul-gauthier/aider/issues/1158
+    # https://github.com/Aider-AI/aider/issues/1158
     # filename = filename.replace("\\_", "_")
 
     return filename
@@ -528,7 +549,7 @@ def find_filename(lines, fence, valid_fnames):
             filenames.append(filename)
 
         # Only continue as long as we keep seeing fences
-        if not line.startswith(fence[0]):
+        if not line.startswith(fence[0]) and not line.startswith(triple_backticks):
             break
 
     if not filenames:

aider/coders/editblock_prompts.py

@@ -11,7 +11,7 @@ Respect and use existing conventions, libraries, etc that are already present in
 Take requests for changes to the supplied code.
 If the request is ambiguous, ask questions.
 
-Always reply to the user in the same language they are using.
+Always reply to the user in {language}.
 
 Once you understand the request you MUST:
 
@@ -34,8 +34,10 @@ ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
 4. *Concisely* suggest any shell commands the user might want to run in ```bash blocks.
 
 Just suggest shell commands this way, not example code.
-Only suggest complete shell commands that area ready to execute, without placeholders.
+Only suggest complete shell commands that are ready to execute, without placeholders.
-Only suggest at most a few shell commands at a time, not more than 1-3.
+Only suggest at most a few shell commands at a time, not more than 1-3, one per line.
+Do not suggest multi-line shell commands.
+All shell commands will run from the root directory of the user's project.
 
 Use the appropriate shell based on the user's system info:
 {platform}
@@ -155,12 +157,13 @@ Every *SEARCH/REPLACE block* must use this format:
 8. The closing fence: {fence[1]}
 
 Use the *FULL* file path, as shown to you by the user.
-
+{quad_backtick_reminder}
 Every *SEARCH* section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, etc.
 If the file contains code or other data wrapped/escaped in json/xml/quotes or other containers, you need to propose edits to the literal contents of the file, including the container markup.
 
-*SEARCH/REPLACE* blocks will replace *all* matching occurrences.
+*SEARCH/REPLACE* blocks will *only* replace the first match occurrence.
-Include enough lines to make the SEARCH blocks uniquely match the lines to change.
+Including multiple unique *SEARCH/REPLACE* blocks if needed.
+Include enough lines in each SEARCH section to uniquely match each set of lines that need to change.
 
 Keep *SEARCH/REPLACE* blocks concise.
 Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
@@ -180,6 +183,9 @@ If you want to put code in a new file, use a *SEARCH/REPLACE block* with:
 
 To rename files which have been added to the chat, use shell commands at the end of your response.
 
+If the user just says something like "ok" or "go ahead" or "do that" they probably want you to make SEARCH/REPLACE blocks for the code changes you just proposed.
+The user will say when they've applied your edits. If they haven't explicitly confirmed the edits have been applied, they probably want proper SEARCH/REPLACE blocks.
+
 {lazy_prompt}
 ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
 {shell_cmd_reminder}

aider/coders/editor_editblock_coder.py

@@ -0,0 +1,8 @@
+from .editblock_coder import EditBlockCoder
+from .editor_editblock_prompts import EditorEditBlockPrompts
+
+
+class EditorEditBlockCoder(EditBlockCoder):
+    "A coder that uses search/replace blocks, focused purely on editing files."
+    edit_format = "editor-diff"
+    gpt_prompts = EditorEditBlockPrompts()

aider/coders/editor_editblock_prompts.py

@@ -0,0 +1,16 @@
+# flake8: noqa: E501
+
+from .editblock_prompts import EditBlockPrompts
+
+
+class EditorEditBlockPrompts(EditBlockPrompts):
+    main_system = """Act as an expert software developer who edits source code.
+{lazy_prompt}
+Describe each change with a *SEARCH/REPLACE block* per the examples below.
+All changes to files must use this *SEARCH/REPLACE block* format.
+ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
+"""
+
+    shell_cmd_prompt = ""
+    no_shell_cmd_prompt = ""
+    shell_cmd_reminder = ""

aider/coders/editor_whole_coder.py

@@ -0,0 +1,8 @@
+from .editor_whole_prompts import EditorWholeFilePrompts
+from .wholefile_coder import WholeFileCoder
+
+
+class EditorWholeFileCoder(WholeFileCoder):
+    "A coder that operates on entire files, focused purely on editing files."
+    edit_format = "editor-whole"
+    gpt_prompts = EditorWholeFilePrompts()

aider/coders/editor_whole_prompts.py

@@ -0,0 +1,10 @@
+# flake8: noqa: E501
+
+from .wholefile_prompts import WholeFilePrompts
+
+
+class EditorWholeFilePrompts(WholeFilePrompts):
+    main_system = """Act as an expert software developer and make changes to source code.
+{lazy_prompt}
+Output a copy of each file that needs changes.
+"""

aider/coders/search_replace.py

@@ -3,7 +3,11 @@
 import sys
 from pathlib import Path
 
-import git
+try:
+    import git
+except ImportError:
+    git = None
+
 from diff_match_patch import diff_match_patch
 from tqdm import tqdm
 

aider/coders/single_wholefile_func_coder.py

@@ -38,7 +38,7 @@ class SingleWholeFileFunctionCoder(Coder):
         self.gpt_prompts = SingleWholeFileFunctionPrompts()
         super().__init__(*args, **kwargs)
 
-    def update_cur_messages(self, edited):
+    def add_assistant_reply_to_cur_messages(self, edited):
         if edited:
             self.cur_messages += [
                 dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)

aider/coders/udiff_prompts.py

@@ -12,7 +12,7 @@ Respect and use existing conventions, libraries, etc that are already present in
 Take requests for changes to the supplied code.
 If the request is ambiguous, ask questions.
 
-Always reply to the user in the same language they are using.
+Always reply to the user in {language}.
 
 For each file that needs to be changed, write out the changes similar to a unified diff like `diff -U0` would produce.
 """

aider/coders/wholefile_coder.py

@@ -17,10 +17,10 @@ class WholeFileCoder(Coder):
         try:
             return self.get_edits(mode="diff")
         except ValueError:
-            return self.get_multi_response_content()
+            return self.get_multi_response_content_in_progress()
 
     def get_edits(self, mode="update"):
-        content = self.get_multi_response_content()
+        content = self.get_multi_response_content_in_progress()
 
         chat_files = self.get_inchat_relative_files()
 
@@ -58,6 +58,8 @@ class WholeFileCoder(Coder):
                     fname = fname.strip("*")  # handle **filename.py**
                     fname = fname.rstrip(":")
                     fname = fname.strip("`")
+                    fname = fname.lstrip("#")
+                    fname = fname.strip()
 
                     # Issue #1232
                     if len(fname) > 250:

aider/coders/wholefile_func_coder.py

@@ -49,7 +49,7 @@ class WholeFileFunctionCoder(Coder):
         self.gpt_prompts = WholeFileFunctionPrompts()
         super().__init__(*args, **kwargs)
 
-    def update_cur_messages(self, edited):
+    def add_assistant_reply_to_cur_messages(self, edited):
         if edited:
             self.cur_messages += [
                 dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)

aider/coders/wholefile_prompts.py

@@ -8,7 +8,7 @@ class WholeFilePrompts(CoderPrompts):
 Take requests for changes to the supplied code.
 If the request is ambiguous, ask questions.
 
-Always reply to the user in the same language they are using.
+Always reply to the user in {language}.
 
 {lazy_prompt}
 Once you understand the request you MUST:
@@ -52,7 +52,7 @@ path/to/filename.js
 {fence[1]}
 
 Every *file listing* MUST use this format:
-- First line: the filename with any originally provided path
+- First line: the filename with any originally provided path; no extra markup, punctuation, comments, etc. **JUST** the filename with path.
 - Second line: opening {fence[0]}
 - ... entire content of the file ...
 - Final line: closing {fence[1]}

aider/commands.py

@@ -1,15 +1,20 @@
+import glob
 import os
 import re
 import subprocess
 import sys
 import tempfile
 from collections import OrderedDict
+from os.path import expanduser
 from pathlib import Path
 
 import pyperclip
 from PIL import Image, ImageGrab
+from prompt_toolkit.completion import Completion, PathCompleter
+from prompt_toolkit.document import Document
 
 from aider import models, prompts, voice
+from aider.editor import pipe_editor
 from aider.format_settings import format_settings
 from aider.help import Help, install_help_extra
 from aider.llm import litellm
@@ -38,10 +43,22 @@ class Commands:
             verify_ssl=self.verify_ssl,
             args=self.args,
             parser=self.parser,
+            verbose=self.verbose,
+            editor=self.editor,
         )
 
     def __init__(
-        self, io, coder, voice_language=None, verify_ssl=True, args=None, parser=None, verbose=False
+        self,
+        io,
+        coder,
+        voice_language=None,
+        voice_input_device=None,
+        voice_format=None,
+        verify_ssl=True,
+        args=None,
+        parser=None,
+        verbose=False,
+        editor=None,
     ):
         self.io = io
         self.coder = coder
@@ -54,14 +71,17 @@ class Commands:
             voice_language = None
 
         self.voice_language = voice_language
+        self.voice_format = voice_format
+        self.voice_input_device = voice_input_device
 
         self.help = None
+        self.editor = editor
 
     def cmd_model(self, args):
         "Switch to a new LLM"
 
         model_name = args.strip()
-        model = models.Model(model_name)
+        model = models.Model(model_name, weak_model=self.coder.main_model.weak_model.name)
         models.sanity_check_models(self.io, model)
         raise SwitchCoder(main_model=model)
 
@@ -87,6 +107,13 @@ class Commands:
                 ("help", "Get help about using aider (usage, config, troubleshoot)."),
                 ("ask", "Ask questions about your code without making any changes."),
                 ("code", "Ask for changes to your code (using the best edit format)."),
+                (
+                    "architect",
+                    (
+                        "Work with an architect model to design code changes, and an editor to make"
+                        " them."
+                    ),
+                ),
             ]
         )
 
@@ -135,7 +162,7 @@ class Commands:
         else:
             self.io.tool_output("Please provide a partial model name to search for.")
 
-    def cmd_web(self, args):
+    def cmd_web(self, args, return_content=False):
         "Scrape a webpage, convert to markdown and send in a message"
 
         url = args.strip()
@@ -154,15 +181,28 @@ class Commands:
             )
 
         content = self.scraper.scrape(url) or ""
-        content = f"{url}:\n\n" + content
+        content = f"Here is the content of {url}:\n\n" + content
-
+        if return_content:
-        self.io.tool_output("... done.")
-
             return content
 
+        self.io.tool_output("... added to chat.")
+
+        self.coder.cur_messages += [
+            dict(role="user", content=content),
+            dict(role="assistant", content="Ok."),
+        ]
+
     def is_command(self, inp):
         return inp[0] in "/!"
 
+    def get_raw_completions(self, cmd):
+        assert cmd.startswith("/")
+        cmd = cmd[1:]
+        cmd = cmd.replace("-", "_")
+
+        raw_completer = getattr(self, f"completions_raw_{cmd}", None)
+        return raw_completer
+
     def get_completions(self, cmd):
         assert cmd.startswith("/")
         cmd = cmd[1:]
@@ -211,6 +251,7 @@ class Commands:
 
     def run(self, inp):
         if inp.startswith("!"):
+            self.coder.event("command_run")
             return self.do_run("run", inp[1:])
 
         res = self.matching_commands(inp)
@@ -218,9 +259,13 @@ class Commands:
             return
         matching_commands, first_word, rest_inp = res
         if len(matching_commands) == 1:
-            return self.do_run(matching_commands[0][1:], rest_inp)
+            command = matching_commands[0][1:]
+            self.coder.event(f"command_{command}")
+            return self.do_run(command, rest_inp)
         elif first_word in matching_commands:
-            return self.do_run(first_word[1:], rest_inp)
+            command = first_word[1:]
+            self.coder.event(f"command_{command}")
+            return self.do_run(command, rest_inp)
         elif len(matching_commands) > 1:
             self.io.tool_error(f"Ambiguous command: {', '.join(matching_commands)}")
         else:
@@ -359,6 +404,7 @@ class Commands:
 
         fence = "`" * 3
 
+        file_res = []
         # files
         for fname in self.coder.abs_fnames:
             relative_fname = self.coder.get_rel_fname(fname)
@@ -369,7 +415,7 @@ class Commands:
                 # approximate
                 content = f"{relative_fname}\n{fence}\n" + content + "{fence}\n"
                 tokens = self.coder.main_model.token_count(content)
-            res.append((tokens, f"{relative_fname}", "/drop to remove"))
+            file_res.append((tokens, f"{relative_fname}", "/drop to remove"))
 
         # read-only files
         for fname in self.coder.abs_read_only_fnames:
@@ -379,7 +425,10 @@ class Commands:
                 # approximate
                 content = f"{relative_fname}\n{fence}\n" + content + "{fence}\n"
                 tokens = self.coder.main_model.token_count(content)
-                res.append((tokens, f"{relative_fname} (read-only)", "/drop to remove"))
+                file_res.append((tokens, f"{relative_fname} (read-only)", "/drop to remove"))
+
+        file_res.sort()
+        res.extend(file_res)
 
         self.io.tool_output(
             f"Approximate context window usage for {self.coder.main_model.name}, in tokens:"
@@ -556,6 +605,10 @@ class Commands:
 
         self.io.tool_output(f"Diff since {commit_before_message[:7]}...")
 
+        if self.coder.pretty:
+            run_cmd(f"git diff {commit_before_message}")
+            return
+
         diff = self.coder.repo.diff_commits(
             self.coder.pretty,
             commit_before_message,
@@ -569,8 +622,62 @@ class Commands:
             fname = f'"{fname}"'
         return fname
 
-    def completions_read_only(self):
+    def completions_raw_read_only(self, document, complete_event):
-        return self.completions_add()
+        # Get the text before the cursor
+        text = document.text_before_cursor
+
+        # Skip the first word and the space after it
+        after_command = text.split()[-1]
+
+        # Create a new Document object with the text after the command
+        new_document = Document(after_command, cursor_position=len(after_command))
+
+        def get_paths():
+            return [self.coder.root] if self.coder.root else None
+
+        path_completer = PathCompleter(
+            get_paths=get_paths,
+            only_directories=False,
+            expanduser=True,
+        )
+
+        # Adjust the start_position to replace all of 'after_command'
+        adjusted_start_position = -len(after_command)
+
+        # Collect all completions
+        all_completions = []
+
+        # Iterate over the completions and modify them
+        for completion in path_completer.get_completions(new_document, complete_event):
+            quoted_text = self.quote_fname(after_command + completion.text)
+            all_completions.append(
+                Completion(
+                    text=quoted_text,
+                    start_position=adjusted_start_position,
+                    display=completion.display,
+                    style=completion.style,
+                    selected_style=completion.selected_style,
+                )
+            )
+
+        # Add completions from the 'add' command
+        add_completions = self.completions_add()
+        for completion in add_completions:
+            if after_command in completion:
+                all_completions.append(
+                    Completion(
+                        text=completion,
+                        start_position=adjusted_start_position,
+                        display=completion,
+                    )
+                )
+
+        # Sort all completions based on their text
+        sorted_completions = sorted(all_completions, key=lambda c: c.text)
+
+        # Yield the sorted completions
+        for completion in sorted_completions:
+            yield completion
 
     def completions_add(self):
         files = set(self.coder.get_all_relative_files())
@@ -588,7 +695,7 @@ class Commands:
             else:
                 try:
                     raw_matched_files = list(Path(self.coder.root).glob(pattern))
-                except IndexError:
+                except (IndexError, AttributeError):
                     raw_matched_files = []
         except ValueError as err:
             self.io.tool_error(f"Error matching {pattern}: {err}")
@@ -653,12 +760,13 @@ class Commands:
 
             if 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()
                     all_matched_files.add(str(fname))
                 except OSError as e:
                     self.io.tool_error(f"Error creating file {fname}: {e}")
 
-        for matched_file in all_matched_files:
+        for matched_file in sorted(all_matched_files):
             abs_file_path = self.coder.abs_root_path(matched_file)
 
             if not abs_file_path.startswith(self.coder.root) and not is_image_file(matched_file):
@@ -667,8 +775,13 @@ class Commands:
                 )
                 continue
 
+            if self.coder.repo and self.coder.repo.git_ignored_file(matched_file):
+                self.io.tool_error(f"Can't add {matched_file} which is in gitignore")
+                continue
+
             if abs_file_path in self.coder.abs_fnames:
-                self.io.tool_warning(f"{matched_file} is already in the chat")
+                self.io.tool_error(f"{matched_file} is already in the chat as an editable file")
+                continue
             elif abs_file_path in self.coder.abs_read_only_fnames:
                 if self.coder.repo and self.coder.repo.path_in_repo(matched_file):
                     self.coder.abs_read_only_fnames.remove(abs_file_path)
@@ -681,7 +794,9 @@ class Commands:
                         f"Cannot add {matched_file} as it's not part of the repository"
                     )
             else:
-                if is_image_file(matched_file) and not self.coder.main_model.accepts_images:
+                if is_image_file(matched_file) and not self.coder.main_model.info.get(
+                    "supports_vision"
+                ):
                     self.io.tool_error(
                         f"Cannot add image file {matched_file} as the"
                         f" {self.coder.main_model.name} does not support images."
@@ -692,7 +807,8 @@ class Commands:
                     self.io.tool_error(f"Unable to read {matched_file}")
                 else:
                     self.coder.abs_fnames.add(abs_file_path)
-                    self.io.tool_output(f"Added {matched_file} to the chat")
+                    fname = self.coder.get_rel_fname(abs_file_path)
+                    self.io.tool_output(f"Added {fname} to the chat")
                     self.coder.check_added_files()
 
     def completions_drop(self):
@@ -715,15 +831,33 @@ class Commands:
             # Expand tilde in the path
             expanded_word = os.path.expanduser(word)
 
-            # Handle read-only files separately, without glob_filtered_to_repo
+            # Handle read-only files with substring matching and samefile check
-            read_only_matched = [f for f in self.coder.abs_read_only_fnames if expanded_word in f]
+            read_only_matched = []
+            for f in self.coder.abs_read_only_fnames:
+                if expanded_word in f:
+                    read_only_matched.append(f)
+                    continue
+
+                # Try samefile comparison for relative paths
+                try:
+                    abs_word = os.path.abspath(expanded_word)
+                    if os.path.samefile(abs_word, f):
+                        read_only_matched.append(f)
+                except (FileNotFoundError, OSError):
+                    continue
 
-            if read_only_matched:
             for matched_file in read_only_matched:
                 self.coder.abs_read_only_fnames.remove(matched_file)
                 self.io.tool_output(f"Removed read-only file {matched_file} from the chat")
 
+            # For editable files, use glob if word contains glob chars, otherwise use substring
+            if any(c in expanded_word for c in "*?[]"):
                 matched_files = self.glob_filtered_to_repo(expanded_word)
+            else:
+                # Use substring matching like we do for read-only files
+                matched_files = [
+                    self.coder.get_rel_fname(f) for f in self.coder.abs_fnames if expanded_word in f
+                ]
 
             if not matched_files:
                 matched_files.append(expanded_word)
@@ -735,7 +869,7 @@ class Commands:
                     self.io.tool_output(f"Removed {matched_file} from the chat")
 
     def cmd_git(self, args):
-        "Run a git command"
+        "Run a git command (output excluded from chat)"
         combined_output = None
         try:
             args = "git " + args
@@ -783,54 +917,47 @@ class Commands:
     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
+            args, verbose=self.verbose, error_print=self.io.tool_error, cwd=self.coder.root
         )
-        instructions = None
 
         if combined_output is None:
             return
 
+        # Calculate token count of output
+        token_count = self.coder.main_model.token_count(combined_output)
+        k_tokens = token_count / 1000
+
         if add_on_nonzero_exit:
             add = exit_status != 0
         else:
-            self.io.tool_output()
+            add = self.io.confirm_ask(f"Add {k_tokens:.1f}k tokens of command output to the chat?")
-            response = self.io.prompt_ask(
-                "Add the output to the chat?\n(Y)es/(n)o/message with instructions:",
-            ).strip()
-            self.io.tool_output()
-
-            if response.lower() in ["yes", "y"]:
-                add = True
-            elif response.lower() in ["no", "n"]:
-                add = False
-            else:
-                add = True
-                instructions = response
-                if response.strip():
-                    self.io.user_input(response, log_only=True)
-                    self.io.add_to_input_history(response)
 
         if add:
-            for line in combined_output.splitlines():
+            num_lines = len(combined_output.strip().splitlines())
-                self.io.tool_output(line, log_only=True)
+            line_plural = "line" if num_lines == 1 else "lines"
+            self.io.tool_output(f"Added {num_lines} {line_plural} of output to the chat.")
 
             msg = prompts.run_output.format(
                 command=args,
                 output=combined_output,
             )
 
-            if instructions:
+            self.coder.cur_messages += [
-                msg = instructions + "\n\n" + msg
+                dict(role="user", content=msg),
+                dict(role="assistant", content="Ok."),
+            ]
 
-            return msg
+            if add and exit_status != 0:
+                self.io.placeholder = "What's wrong? Fix"
 
     def cmd_exit(self, args):
         "Exit the application"
+        self.coder.event("exit", reason="/exit")
         sys.exit()
 
     def cmd_quit(self, args):
         "Exit the application"
-        sys.exit()
+        self.cmd_exit(args)
 
     def cmd_ls(self, args):
         "List all known files and indicate which are included in the chat session"
@@ -894,7 +1021,8 @@ class Commands:
             self.basic_help()
             return
 
-        from aider.coders import Coder
+        self.coder.event("interactive help")
+        from aider.coders.base_coder import Coder
 
         if not self.help:
             res = install_help_extra(self.io)
@@ -938,19 +1066,23 @@ class Commands:
         )
 
     def cmd_ask(self, args):
-        "Ask questions about the code base without editing any files"
+        """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")
 
     def cmd_code(self, args):
-        "Ask for changes to your code"
+        """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)
 
+    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")
+
     def _generic_chat_command(self, args, edit_format):
         if not args.strip():
-            self.io.tool_error(f"Please provide a question or topic for the {edit_format} chat.")
+            # Switch to the corresponding chat mode if no args provided
-            return
+            return self.cmd_chat_mode(edit_format)
 
-        from aider.coders import Coder
+        from aider.coders.base_coder import Coder
 
         coder = Coder.create(
             io=self.io,
@@ -997,46 +1129,27 @@ class Commands:
                 self.io.tool_error("To use /voice you must provide an OpenAI API key.")
                 return
             try:
-                self.voice = voice.Voice()
+                self.voice = voice.Voice(
+                    audio_format=self.voice_format or "wav", device_name=self.voice_input_device
+                )
             except voice.SoundDeviceError:
                 self.io.tool_error(
                     "Unable to import `sounddevice` and/or `soundfile`, is portaudio installed?"
                 )
                 return
 
-        history_iter = self.io.get_input_history()
-
-        history = []
-        size = 0
-        for line in history_iter:
-            if line.startswith("/"):
-                continue
-            if line in history:
-                continue
-            if size + len(line) > 1024:
-                break
-            size += len(line)
-            history.append(line)
-
-        history.reverse()
-        history = "\n".join(history)
-
         try:
-            text = self.voice.record_and_transcribe(history, language=self.voice_language)
+            text = self.voice.record_and_transcribe(None, language=self.voice_language)
         except litellm.OpenAIError as err:
             self.io.tool_error(f"Unable to use OpenAI whisper model: {err}")
             return
 
         if text:
-            self.io.add_to_input_history(text)
+            self.io.placeholder = text
-            self.io.print()
-            self.io.user_input(text, log_only=False)
-            self.io.print()
 
-        return text
+    def cmd_paste(self, args):
-
+        """Paste image/text from the clipboard into the chat.\
-    def cmd_clipboard(self, args):
+        Optionally provide a name for the image."""
-        "Add image/text from the clipboard to the chat (optionally provide a name for the image)"
         try:
             # Check for image first
             image = ImageGrab.grabclipboard()
@@ -1085,33 +1198,61 @@ class Commands:
             self.io.tool_error(f"Error processing clipboard content: {e}")
 
     def cmd_read_only(self, args):
-        "Add files to the chat that are for reference, not to be edited"
+        "Add files to the chat that are for reference only, or turn added files to read-only"
         if not args.strip():
-            self.io.tool_error("Please provide filenames or directories to read.")
+            # Convert all files in chat to read-only
+            for fname in list(self.coder.abs_fnames):
+                self.coder.abs_fnames.remove(fname)
+                self.coder.abs_read_only_fnames.add(fname)
+                rel_fname = self.coder.get_rel_fname(fname)
+                self.io.tool_output(f"Converted {rel_fname} to read-only")
             return
 
         filenames = parse_quoted_filenames(args)
-        for word in filenames:
+        all_paths = []
-            # Expand the home directory if the path starts with "~"
-            expanded_path = os.path.expanduser(word)
-            abs_path = self.coder.abs_root_path(expanded_path)
 
-            if not os.path.exists(abs_path):
+        # First collect all expanded paths
-                self.io.tool_error(f"Path not found: {abs_path}")
+        for pattern in filenames:
-                continue
+            expanded_pattern = expanduser(pattern)
+            if os.path.isabs(expanded_pattern):
+                # For absolute paths, glob it
+                matches = list(glob.glob(expanded_pattern))
+            else:
+                # For relative paths and globs, use glob from the root directory
+                matches = list(Path(self.coder.root).glob(expanded_pattern))
 
+            if not matches:
+                self.io.tool_error(f"No matches found for: {pattern}")
+            else:
+                all_paths.extend(matches)
+
+        # Then process them in sorted order
+        for path in sorted(all_paths):
+            abs_path = self.coder.abs_root_path(path)
             if os.path.isfile(abs_path):
-                self._add_read_only_file(abs_path, word)
+                self._add_read_only_file(abs_path, path)
             elif os.path.isdir(abs_path):
-                self._add_read_only_directory(abs_path, word)
+                self._add_read_only_directory(abs_path, path)
             else:
                 self.io.tool_error(f"Not a file or directory: {abs_path}")
 
     def _add_read_only_file(self, abs_path, original_name):
-        if abs_path in self.coder.abs_fnames:
+        if is_image_file(original_name) and not self.coder.main_model.info.get("supports_vision"):
-            self.io.tool_error(f"{original_name} is already in the chat as an editable file")
+            self.io.tool_error(
-        elif abs_path in self.coder.abs_read_only_fnames:
+                f"Cannot add image file {original_name} as the"
+                f" {self.coder.main_model.name} does not support images."
+            )
+            return
+
+        if abs_path in self.coder.abs_read_only_fnames:
             self.io.tool_error(f"{original_name} is already in the chat as a read-only file")
+            return
+        elif abs_path in self.coder.abs_fnames:
+            self.coder.abs_fnames.remove(abs_path)
+            self.coder.abs_read_only_fnames.add(abs_path)
+            self.io.tool_output(
+                f"Moved {original_name} from editable to read-only files in the chat"
+            )
         else:
             self.coder.abs_read_only_fnames.add(abs_path)
             self.io.tool_output(f"Added {original_name} to read-only files.")
@@ -1152,7 +1293,102 @@ class Commands:
     def cmd_settings(self, args):
         "Print out the current settings"
         settings = format_settings(self.parser, self.args)
-        self.io.tool_output(settings)
+        announcements = "\n".join(self.coder.get_announcements())
+        output = f"{announcements}\n{settings}"
+        self.io.tool_output(output)
+
+    def completions_raw_load(self, document, complete_event):
+        return self.completions_raw_read_only(document, complete_event)
+
+    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.")
+            return
+
+        try:
+            with open(args.strip(), "r", encoding=self.io.encoding, errors="replace") as f:
+                commands = f.readlines()
+        except FileNotFoundError:
+            self.io.tool_error(f"File not found: {args}")
+            return
+        except Exception as e:
+            self.io.tool_error(f"Error reading file: {e}")
+            return
+
+        for cmd in commands:
+            cmd = cmd.strip()
+            if not cmd or cmd.startswith("#"):
+                continue
+
+            self.io.tool_output(f"\nExecuting: {cmd}")
+            try:
+                self.run(cmd)
+            except SwitchCoder:
+                self.io.tool_error(
+                    f"Command '{cmd}' is only supported in interactive mode, skipping."
+                )
+
+    def completions_raw_save(self, document, complete_event):
+        return self.completions_raw_read_only(document, complete_event)
+
+    def cmd_save(self, args):
+        "Save commands to a file that can reconstruct the current chat session's files"
+        if not args.strip():
+            self.io.tool_error("Please provide a filename to save the commands to.")
+            return
+
+        try:
+            with open(args.strip(), "w", encoding=self.io.encoding) as f:
+                f.write("/drop\n")
+                # Write commands to add editable files
+                for fname in sorted(self.coder.abs_fnames):
+                    rel_fname = self.coder.get_rel_fname(fname)
+                    f.write(f"/add       {rel_fname}\n")
+
+                # Write commands to add read-only files
+                for fname in sorted(self.coder.abs_read_only_fnames):
+                    # Use absolute path for files outside repo root, relative path for files inside
+                    if Path(fname).is_relative_to(self.coder.root):
+                        rel_fname = self.coder.get_rel_fname(fname)
+                        f.write(f"/read-only {rel_fname}\n")
+                    else:
+                        f.write(f"/read-only {fname}\n")
+
+            self.io.tool_output(f"Saved commands to {args.strip()}")
+        except Exception as e:
+            self.io.tool_error(f"Error saving commands to file: {e}")
+
+    def cmd_multiline_mode(self, args):
+        "Toggle multiline mode (swaps behavior of Enter and Meta+Enter)"
+        self.io.toggle_multiline_mode()
+
+    def cmd_copy(self, args):
+        "Copy the last assistant message to the clipboard"
+        all_messages = self.coder.done_messages + self.coder.cur_messages
+        assistant_messages = [msg for msg in reversed(all_messages) if msg["role"] == "assistant"]
+
+        if not assistant_messages:
+            self.io.tool_error("No assistant messages found to copy.")
+            return
+
+        last_assistant_message = assistant_messages[0]["content"]
+
+        try:
+            pyperclip.copy(last_assistant_message)
+            preview = (
+                last_assistant_message[:50] + "..."
+                if len(last_assistant_message) > 50
+                else last_assistant_message
+            )
+            self.io.tool_output(f"Copied last assistant message to clipboard. Preview: {preview}")
+        except pyperclip.PyperclipException as e:
+            self.io.tool_error(f"Failed to copy to clipboard: {str(e)}")
+            self.io.tool_output(
+                "You may need to install xclip or xsel on Linux, or pbcopy on macOS."
+            )
+        except Exception as e:
+            self.io.tool_error(f"An unexpected error occurred while copying to clipboard: {str(e)}")
 
     def cmd_report(self, args):
         "Report a problem by opening a GitHub Issue"
@@ -1168,6 +1404,57 @@ class Commands:
 
         report_github_issue(issue_text, title=title, confirm=False)
 
+    def cmd_editor(self, initial_content=""):
+        "Open an editor to write a prompt"
+
+        user_input = pipe_editor(initial_content, suffix="md", editor=self.editor)
+        if user_input.strip():
+            self.io.set_placeholder(user_input.rstrip())
+
+    def cmd_copy_context(self, args=None):
+        """Copy the current chat context as markdown, suitable to paste into a web UI"""
+
+        chunks = self.coder.format_chat_chunks()
+
+        markdown = ""
+
+        # Only include specified chunks in order
+        for messages in [chunks.repo, chunks.readonly_files, chunks.chat_files]:
+            for msg in messages:
+                # Only include user messages
+                if msg["role"] != "user":
+                    continue
+
+                content = msg["content"]
+
+                # Handle image/multipart content
+                if isinstance(content, list):
+                    for part in content:
+                        if part.get("type") == "text":
+                            markdown += part["text"] + "\n\n"
+                else:
+                    markdown += content + "\n\n"
+
+        args = args or ""
+        markdown += f"""
+Just tell me how to edit the files to make the changes.
+Don't give me back entire files.
+Just show me the edits I need to make.
+
+{args}
+"""
+
+        try:
+            pyperclip.copy(markdown)
+            self.io.tool_output("Copied code context to clipboard.")
+        except pyperclip.PyperclipException as e:
+            self.io.tool_error(f"Failed to copy to clipboard: {str(e)}")
+            self.io.tool_output(
+                "You may need to install xclip or xsel on Linux, or pbcopy on macOS."
+            )
+        except Exception as e:
+            self.io.tool_error(f"An unexpected error occurred while copying to clipboard: {str(e)}")
+
 
 def expand_subdir(file_path):
     if file_path.is_file():

aider/copypaste.py

@@ -0,0 +1,72 @@
+import threading
+import time
+
+import pyperclip
+
+
+class ClipboardWatcher:
+    """Watches clipboard for changes and updates IO placeholder"""
+
+    def __init__(self, io, verbose=False):
+        self.io = io
+        self.verbose = verbose
+        self.stop_event = None
+        self.watcher_thread = None
+        self.last_clipboard = None
+        self.io.clipboard_watcher = self
+
+    def start(self):
+        """Start watching clipboard for changes"""
+        self.stop_event = threading.Event()
+        self.last_clipboard = pyperclip.paste()
+
+        def watch_clipboard():
+            while not self.stop_event.is_set():
+                try:
+                    current = pyperclip.paste()
+                    if current != self.last_clipboard:
+                        self.last_clipboard = current
+                        self.io.interrupt_input()
+                        self.io.placeholder = current
+                        if len(current.splitlines()) > 1:
+                            self.io.placeholder = "\n" + self.io.placeholder + "\n"
+
+                    time.sleep(0.5)
+                except Exception as e:
+                    if self.verbose:
+                        from aider.dump import dump
+
+                        dump(f"Clipboard watcher error: {e}")
+                    continue
+
+        self.watcher_thread = threading.Thread(target=watch_clipboard, daemon=True)
+        self.watcher_thread.start()
+
+    def stop(self):
+        """Stop watching clipboard for changes"""
+        if self.stop_event:
+            self.stop_event.set()
+        if self.watcher_thread:
+            self.watcher_thread.join()
+            self.watcher_thread = None
+            self.stop_event = None
+
+
+def main():
+    """Example usage of the clipboard watcher"""
+    from aider.io import InputOutput
+
+    io = InputOutput()
+    watcher = ClipboardWatcher(io, verbose=True)
+
+    try:
+        watcher.start()
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopped watching clipboard")
+        watcher.stop()
+
+
+if __name__ == "__main__":
+    main()

aider/diffs.py

@@ -50,7 +50,6 @@ def diff_partial_update(lines_orig, lines_updated, final=False, fname=None):
     # dump(lines_orig)
     # dump(lines_updated)
 
-    assert_newlines(lines_orig)
     assert_newlines(lines_orig)
 
     num_orig_lines = len(lines_orig)

aider/editor.py

@@ -0,0 +1,146 @@
+"""
+Editor module for handling system text editor interactions.
+
+This module provides functionality to:
+- Discover and launch the system's configured text editor
+- Create and manage temporary files for editing
+- Handle editor preferences from environment variables
+- Support cross-platform editor operations
+"""
+
+import os
+import platform
+import shlex
+import subprocess
+import tempfile
+
+from rich.console import Console
+
+DEFAULT_EDITOR_NIX = "vi"
+DEFAULT_EDITOR_OS_X = "vim"
+DEFAULT_EDITOR_WINDOWS = "notepad"
+
+console = Console()
+
+
+def print_status_message(success, message, style=None):
+    """
+    Print a status message with appropriate styling.
+
+    :param success: Whether the operation was successful
+    :param message: The message to display
+    :param style: Optional style override. If None, uses green for success and red for failure
+    """
+    if style is None:
+        style = "bold green" if success else "bold red"
+    console.print(message, style=style)
+    print("")
+
+
+def write_temp_file(
+    input_data="",
+    suffix=None,
+    prefix=None,
+    dir=None,
+):
+    """
+    Create a temporary file with the given input data.
+
+    :param input_data: Content to write to the temporary file
+    :param suffix: Optional file extension (without the dot)
+    :param prefix: Optional prefix for the temporary filename
+    :param dir: Optional directory to create the file in
+    :return: Path to the created temporary file
+    :raises: OSError if file creation or writing fails
+    """
+    kwargs = {"prefix": prefix, "dir": dir}
+    if suffix:
+        kwargs["suffix"] = f".{suffix}"
+    fd, filepath = tempfile.mkstemp(**kwargs)
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(input_data)
+    except Exception:
+        os.close(fd)
+        raise
+    return filepath
+
+
+def get_environment_editor(default=None):
+    """
+    Fetches the preferred editor from the environment variables.
+
+    This function checks the following environment variables in order to
+    determine the user's preferred editor:
+
+     - VISUAL
+     - EDITOR
+
+    :param default: The default editor to return if no environment variable is set.
+    :type default: str or None
+    :return: The preferred editor as specified by environment variables or the default value.
+    :rtype: str or None
+    """
+    editor = os.environ.get("VISUAL", os.environ.get("EDITOR", default))
+    return editor
+
+
+def discover_editor(editor_override=None):
+    """
+    Discovers and returns the appropriate editor command as a list of arguments.
+
+    Handles cases where the editor command includes arguments, including quoted arguments
+    with spaces (e.g. 'vim -c "set noswapfile"').
+
+    :return: A list of command parts ready for subprocess execution
+    :rtype: list[str]
+    """
+    system = platform.system()
+    if system == "Windows":
+        default_editor = DEFAULT_EDITOR_WINDOWS
+    elif system == "Darwin":
+        default_editor = DEFAULT_EDITOR_OS_X
+    else:
+        default_editor = DEFAULT_EDITOR_NIX
+    if editor_override:
+        editor = editor_override
+    else:
+        editor = get_environment_editor(default_editor)
+    try:
+        return shlex.split(editor)
+    except ValueError as e:
+        raise RuntimeError(f"Invalid editor command format '{editor}': {e}")
+
+
+def pipe_editor(input_data="", suffix=None, editor=None):
+    """
+    Opens the system editor with optional input data and returns the edited content.
+
+    This function creates a temporary file with the provided input data, opens it in
+    the system editor, waits for the user to make changes and close the editor, then
+    reads and returns the modified content. The temporary file is deleted afterwards.
+
+    :param input_data: Initial content to populate the editor with
+    :type input_data: str
+    :param suffix: Optional file extension for the temporary file (e.g. '.txt', '.md')
+    :type suffix: str or None
+    :return: The edited content after the editor is closed
+    :rtype: str
+    """
+    filepath = write_temp_file(input_data, suffix)
+    command_parts = discover_editor(editor)
+    command_parts.append(filepath)
+    subprocess.call(command_parts, shell=True)
+    with open(filepath, "r") as f:
+        output_data = f.read()
+    try:
+        os.remove(filepath)
+    except PermissionError:
+        print_status_message(
+            False,
+            (
+                f"WARNING: Unable to delete temporary file {filepath!r}. You may need to delete it"
+                " manually."
+            ),
+        )
+    return output_data

aider/exceptions.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+
+from aider.dump import dump  # noqa: F401
+
+
+@dataclass
+class ExInfo:
+    name: str
+    retry: bool
+    description: str
+
+
+EXCEPTIONS = [
+    ExInfo("APIConnectionError", True, None),
+    ExInfo("APIError", True, None),
+    ExInfo("APIResponseValidationError", True, None),
+    ExInfo(
+        "AuthenticationError",
+        False,
+        "The API provider is not able to authenticate you. Check your API key.",
+    ),
+    ExInfo("AzureOpenAIError", True, None),
+    ExInfo("BadRequestError", False, None),
+    ExInfo("BudgetExceededError", True, None),
+    ExInfo(
+        "ContentPolicyViolationError",
+        True,
+        "The API provider has refused the request due to a safety policy about the content.",
+    ),
+    ExInfo("ContextWindowExceededError", False, None),  # special case handled in base_coder
+    ExInfo("InternalServerError", True, "The API provider's servers are down or overloaded."),
+    ExInfo("InvalidRequestError", True, None),
+    ExInfo("JSONSchemaValidationError", True, None),
+    ExInfo("NotFoundError", False, None),
+    ExInfo("OpenAIError", True, None),
+    ExInfo(
+        "RateLimitError",
+        True,
+        "The API provider has rate limited you. Try again later or check your quotas.",
+    ),
+    ExInfo("RouterRateLimitError", True, None),
+    ExInfo("ServiceUnavailableError", True, "The API provider's servers are down or overloaded."),
+    ExInfo("UnprocessableEntityError", True, None),
+    ExInfo("UnsupportedParamsError", True, None),
+    ExInfo(
+        "Timeout",
+        True,
+        "The API provider timed out without returning a response. They may be down or overloaded.",
+    ),
+]
+
+
+class LiteLLMExceptions:
+    exceptions = dict()
+    exception_info = {exi.name: exi for exi in EXCEPTIONS}
+
+    def __init__(self):
+        self._load()
+
+    def _load(self, strict=False):
+        import litellm
+
+        for var in dir(litellm):
+            if var.endswith("Error"):
+                if var not in self.exception_info:
+                    raise ValueError(f"{var} is in litellm but not in aider's exceptions list")
+
+        for var in self.exception_info:
+            ex = getattr(litellm, var)
+            self.exceptions[ex] = self.exception_info[var]
+
+    def exceptions_tuple(self):
+        return tuple(self.exceptions)
+
+    def get_ex_info(self, ex):
+        """Return the ExInfo for a given exception instance"""
+        import litellm
+
+        if ex.__class__ is litellm.APIConnectionError:
+            if "google.auth" in str(ex):
+                return ExInfo(
+                    "APIConnectionError", False, "You need to: pip install google-generativeai"
+                )
+            if "boto3" in str(ex):
+                return ExInfo("APIConnectionError", False, "You need to: pip install boto3")
+        return self.exceptions.get(ex.__class__, ExInfo(None, None, None))

aider/gui.py

@@ -160,7 +160,7 @@ class GUI:
 
             st.warning(
                 "This browser version of aider is experimental. Please share feedback in [GitHub"
-                " issues](https://github.com/paul-gauthier/aider/issues)."
+                " issues](https://github.com/Aider-AI/aider/issues)."
             )
 
     def do_settings_tab(self):
@@ -528,7 +528,7 @@ def gui_main():
         page_icon=urls.favicon,
         menu_items={
             "Get Help": urls.website,
-            "Report a bug": "https://github.com/paul-gauthier/aider/issues",
+            "Report a bug": "https://github.com/Aider-AI/aider/issues",
             "About": "# Aider\nAI pair programming in your browser.",
         },
     )

aider/help.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python
 
+import json
 import os
+import shutil
 import warnings
 from pathlib import Path
 
@@ -38,24 +40,45 @@ def get_package_files():
 
 
 def fname_to_url(filepath):
-    website = "website/"
+    website = "website"
-    index = "/index.md"
+    index = "index.md"
     md = ".md"
 
-    docid = ""
+    # Convert backslashes to forward slashes for consistency
-    if filepath.startswith("website/_includes/"):
+    filepath = filepath.replace("\\", "/")
-        pass
-    elif filepath.startswith(website):
-        docid = filepath[len(website) :]
 
-        if filepath.endswith(index):
+    # Convert to Path object for easier manipulation
-            filepath = filepath[: -len(index)] + "/"
+    path = Path(filepath)
-        elif filepath.endswith(md):
-            filepath = filepath[: -len(md)] + ".html"
 
-        docid = "https://aider.chat/" + filepath
+    # Split the path into parts
+    parts = path.parts
 
-    return docid
+    # Find the 'website' part in the path
+    try:
+        website_index = [p.lower() for p in parts].index(website.lower())
+    except ValueError:
+        return ""  # 'website' not found in the path
+
+    # Extract the part of the path starting from 'website'
+    relevant_parts = parts[website_index + 1 :]
+
+    # Handle _includes directory
+    if relevant_parts and relevant_parts[0].lower() == "_includes":
+        return ""
+
+    # Join the remaining parts
+    url_path = "/".join(relevant_parts)
+
+    # Handle index.md and other .md files
+    if url_path.lower().endswith(index.lower()):
+        url_path = url_path[: -len(index)]
+    elif url_path.lower().endswith(md.lower()):
+        url_path = url_path[: -len(md)] + ".html"
+
+    # Ensure the URL starts and ends with '/'
+    url_path = url_path.strip("/")
+
+    return f"https://aider.chat/{url_path}"
 
 
 def get_index():
@@ -69,12 +92,17 @@ def get_index():
 
     dname = Path.home() / ".aider" / "caches" / ("help." + __version__)
 
+    index = None
+    try:
         if dname.exists():
             storage_context = StorageContext.from_defaults(
                 persist_dir=dname,
             )
             index = load_index_from_storage(storage_context)
-    else:
+    except (OSError, json.JSONDecodeError):
+        shutil.rmtree(dname)
+
+    if index is None:
         parser = MarkdownNodeParser()
 
         nodes = []

aider/help_pats.py

@@ -1,4 +1,7 @@
+# This needs to sync with MANIFEST.in
+
 exclude_website_pats = [
+    "**/.DS_Store",
     "examples/**",
     "_posts/**",
     "HISTORY.md",

aider/history.py

@@ -2,7 +2,6 @@ import argparse
 
 from aider import models, prompts
 from aider.dump import dump  # noqa: F401
-from aider.sendchat import simple_send_with_retries
 
 
 class ChatSummary:
@@ -26,6 +25,12 @@ class ChatSummary:
         return sized
 
     def summarize(self, messages, depth=0):
+        messages = 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):
         if not self.models:
             raise ValueError("No models available for summarization")
 
@@ -88,7 +93,7 @@ class ChatSummary:
         if summary_tokens + tail_tokens < self.max_tokens:
             return result
 
-        return self.summarize(result, depth + 1)
+        return self.summarize_real(result, depth + 1)
 
     def summarize_all(self, messages):
         content = ""
@@ -108,9 +113,7 @@ class ChatSummary:
 
         for model in self.models:
             try:
-                summary = simple_send_with_retries(
+                summary = model.simple_send_with_retries(summarize_messages)
-                    model.name, summarize_messages, extra_headers=model.extra_headers
-                )
                 if summary is not None:
                     summary = prompts.summary_prefix + summary
                     return [dict(role="user", content=summary)]

aider/io.py

@@ -1,29 +1,57 @@
 import base64
+import functools
 import os
+import signal
+import time
+import webbrowser
 from collections import defaultdict
 from dataclasses import dataclass
 from datetime import datetime
+from io import StringIO
 from pathlib import Path
 
 from prompt_toolkit.completion import Completer, Completion, ThreadedCompleter
+from prompt_toolkit.cursor_shapes import ModalCursorShapeConfig
 from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.filters import Condition, is_searching
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.keys import Keys
 from prompt_toolkit.lexers import PygmentsLexer
+from prompt_toolkit.output.vt100 import is_dumb_terminal
 from prompt_toolkit.shortcuts import CompleteStyle, PromptSession
 from prompt_toolkit.styles import Style
 from pygments.lexers import MarkdownLexer, guess_lexer_for_filename
 from pygments.token import Token
+from rich.columns import Columns
 from rich.console import Console
+from rich.markdown import Markdown
 from rich.style import Style as RichStyle
 from rich.text import Text
-from rich.markdown import Markdown
+
 from aider.mdstream import MarkdownStream
 
 from .dump import dump  # noqa: F401
 from .utils import is_image_file
 
 
+def restore_multiline(func):
+    """Decorator to restore multiline mode after function execution"""
+
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        orig_multiline = self.multiline_mode
+        self.multiline_mode = False
+        try:
+            return func(self, *args, **kwargs)
+        except Exception:
+            raise
+        finally:
+            self.multiline_mode = orig_multiline
+
+    return wrapper
+
+
 @dataclass
 class ConfirmGroup:
     preference: str = None
@@ -91,17 +119,16 @@ class AutoCompleter(Completer):
                 (token[1], f"`{token[1]}`") for token in tokens if token[0] in Token.Name
             )
 
-    def get_command_completions(self, text, words):
+    def get_command_completions(self, document, complete_event, text, words):
-        candidates = []
         if len(words) == 1 and not text[-1].isspace():
             partial = words[0].lower()
             candidates = [cmd for cmd in self.command_names if cmd.startswith(partial)]
-            return candidates
+            for candidate in sorted(candidates):
+                yield Completion(candidate, start_position=-len(words[-1]))
+            return
 
-        if len(words) <= 1:
+        if len(words) <= 1 or text[-1].isspace():
-            return []
+            return
-        if text[-1].isspace():
-            return []
 
         cmd = words[0]
         partial = words[-1].lower()
@@ -112,6 +139,11 @@ class AutoCompleter(Completer):
         elif cmd not in matches:
             return
 
+        raw_completer = self.commands.get_raw_completions(cmd)
+        if raw_completer:
+            yield from raw_completer(document, complete_event)
+            return
+
         if cmd not in self.command_completions:
             candidates = self.commands.get_completions(cmd)
             self.command_completions[cmd] = candidates
@@ -122,7 +154,8 @@ class AutoCompleter(Completer):
             return
 
         candidates = [word for word in candidates if partial in word.lower()]
-        return candidates
+        for candidate in sorted(candidates):
+            yield Completion(candidate, start_position=-len(words[-1]))
 
     def get_completions(self, document, complete_event):
         self.tokenize()
@@ -137,10 +170,7 @@ class AutoCompleter(Completer):
             return
 
         if text[0] == "/":
-            candidates = self.get_command_completions(text, words)
+            yield from self.get_command_completions(document, complete_event, text, words)
-            if candidates is not None:
-                for candidate in sorted(candidates):
-                    yield Completion(candidate, start_position=-len(words[-1]))
             return
 
         candidates = self.words
@@ -165,6 +195,7 @@ class AutoCompleter(Completer):
 class InputOutput:
     num_error_outputs = 0
     num_user_asks = 0
+    clipboard_watcher = None
 
     def __init__(
         self,
@@ -179,13 +210,26 @@ class InputOutput:
         tool_error_color="red",
         tool_warning_color="#FFA500",
         assistant_output_color="blue",
+        completion_menu_color=None,
+        completion_menu_bg_color=None,
+        completion_menu_current_color=None,
+        completion_menu_current_bg_color=None,
         code_theme="default",
         encoding="utf-8",
+        line_endings="platform",
         dry_run=False,
         llm_history_file=None,
         editingmode=EditingMode.EMACS,
+        fancy_input=True,
+        file_watcher=None,
+        multiline_mode=False,
+        root=".",
     ):
+        self.placeholder = None
+        self.interrupted = False
+        self.never_prompts = set()
         self.editingmode = editingmode
+        self.multiline_mode = multiline_mode
         no_color = os.environ.get("NO_COLOR")
         if no_color is not None and no_color != "":
             pretty = False
@@ -195,6 +239,11 @@ class InputOutput:
         self.tool_error_color = tool_error_color if pretty else None
         self.tool_warning_color = tool_warning_color if pretty else None
         self.assistant_output_color = assistant_output_color
+        self.completion_menu_color = completion_menu_color if pretty else None
+        self.completion_menu_bg_color = completion_menu_bg_color if pretty else None
+        self.completion_menu_current_color = completion_menu_current_color if pretty else None
+        self.completion_menu_current_bg_color = completion_menu_current_bg_color if pretty else None
+
         self.code_theme = code_theme
 
         self.input = input
@@ -214,20 +263,37 @@ class InputOutput:
             self.chat_history_file = None
 
         self.encoding = encoding
+        valid_line_endings = {"platform", "lf", "crlf"}
+        if line_endings not in valid_line_endings:
+            raise ValueError(
+                f"Invalid line_endings value: {line_endings}. "
+                f"Must be one of: {', '.join(valid_line_endings)}"
+            )
+        self.newline = (
+            None if line_endings == "platform" else "\n" if line_endings == "lf" else "\r\n"
+        )
         self.dry_run = dry_run
 
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         self.append_chat_history(f"\n# aider chat started at {current_time}\n\n")
 
         self.prompt_session = None
-        if self.pretty:
+        self.is_dumb_terminal = is_dumb_terminal()
-            # Initialize PromptSession
+
+        if self.is_dumb_terminal:
+            self.pretty = False
+            fancy_input = False
+
+        if fancy_input:
+            # Initialize PromptSession only if we have a capable terminal
             session_kwargs = {
                 "input": self.input,
                 "output": self.output,
                 "lexer": PygmentsLexer(MarkdownLexer),
                 "editing_mode": self.editingmode,
             }
+            if self.editingmode == EditingMode.VI:
+                session_kwargs["cursor"] = ModalCursorShapeConfig()
             if self.input_history_file is not None:
                 session_kwargs["history"] = FileHistory(self.input_history_file)
             try:
@@ -238,6 +304,46 @@ class InputOutput:
                 self.tool_error(f"Can't initialize prompt toolkit: {err}")  # non-pretty
         else:
             self.console = Console(force_terminal=False, no_color=True)  # non-pretty
+            if self.is_dumb_terminal:
+                self.tool_output("Detected dumb terminal, disabling fancy input and pretty output.")
+
+        self.file_watcher = file_watcher
+        self.root = root
+
+    def _get_style(self):
+        style_dict = {}
+        if not self.pretty:
+            return Style.from_dict(style_dict)
+
+        if self.user_input_color:
+            style_dict.setdefault("", self.user_input_color)
+            style_dict.update(
+                {
+                    "pygments.literal.string": f"bold italic {self.user_input_color}",
+                }
+            )
+
+        # Conditionally add 'completion-menu' style
+        completion_menu_style = []
+        if self.completion_menu_bg_color:
+            completion_menu_style.append(f"bg:{self.completion_menu_bg_color}")
+        if self.completion_menu_color:
+            completion_menu_style.append(self.completion_menu_color)
+        if completion_menu_style:
+            style_dict["completion-menu"] = " ".join(completion_menu_style)
+
+        # Conditionally add 'completion-menu.completion.current' style
+        completion_menu_current_style = []
+        if self.completion_menu_current_bg_color:
+            completion_menu_current_style.append(f"bg:{self.completion_menu_current_bg_color}")
+        if self.completion_menu_current_color:
+            completion_menu_current_style.append(self.completion_menu_current_color)
+        if completion_menu_current_style:
+            style_dict["completion-menu.completion.current"] = " ".join(
+                completion_menu_current_style
+            )
+
+        return Style.from_dict(style_dict)
 
     def read_image(self, filename):
         try:
@@ -257,35 +363,61 @@ class InputOutput:
             self.tool_error(f"{filename}: {e}")
             return
 
-    def read_text(self, filename):
+    def read_text(self, filename, silent=False):
         if is_image_file(filename):
             return self.read_image(filename)
 
         try:
             with open(str(filename), "r", encoding=self.encoding) as f:
                 return f.read()
-        except OSError as err:
-            self.tool_error(f"{filename}: unable to read: {err}")
-            return
         except FileNotFoundError:
+            if not silent:
                 self.tool_error(f"{filename}: file not found error")
             return
         except IsADirectoryError:
+            if not silent:
                 self.tool_error(f"{filename}: is a directory")
             return
+        except OSError as err:
+            if not silent:
+                self.tool_error(f"{filename}: unable to read: {err}")
+            return
         except UnicodeError as e:
+            if not silent:
                 self.tool_error(f"{filename}: {e}")
                 self.tool_error("Use --encoding to set the unicode encoding.")
             return
 
-    def write_text(self, filename, content):
+    def write_text(self, filename, content, max_retries=5, initial_delay=0.1):
+        """
+        Writes content to a file, retrying with progressive backoff if the file is locked.
+
+        :param filename: Path to the file to write.
+        :param content: Content to write to the file.
+        :param max_retries: Maximum number of retries if a file lock is encountered.
+        :param initial_delay: Initial delay (in seconds) before the first retry.
+        """
         if self.dry_run:
             return
+
+        delay = initial_delay
+        for attempt in range(max_retries):
             try:
-            with open(str(filename), "w", encoding=self.encoding) as f:
+                with open(str(filename), "w", encoding=self.encoding, newline=self.newline) as f:
                     f.write(content)
+                return  # Successfully wrote the file
+            except PermissionError as err:
+                if attempt < max_retries - 1:
+                    time.sleep(delay)
+                    delay *= 2  # Exponential backoff
+                else:
+                    self.tool_error(
+                        f"Unable to write file {filename} after {max_retries} attempts: {err}"
+                    )
+                    raise
             except OSError as err:
                 self.tool_error(f"Unable to write file {filename}: {err}")
+                raise
 
     def rule(self):
         if self.pretty:
@@ -294,6 +426,13 @@ class InputOutput:
         else:
             print()
 
+    def interrupt_input(self):
+        if self.prompt_session and self.prompt_session.app:
+            # Store any partial input before interrupting
+            self.placeholder = self.prompt_session.app.current_buffer.text
+            self.interrupted = True
+            self.prompt_session.app.exit()
+
     def get_input(
         self,
         root,
@@ -308,23 +447,20 @@ class InputOutput:
         rel_fnames = list(rel_fnames)
         show = ""
         if rel_fnames:
-            show = " ".join(rel_fnames) + "\n"
+            rel_read_only_fnames = [
+                get_rel_fname(fname, root) for fname in (abs_read_only_fnames or [])
+            ]
+            show = self.format_files_for_input(rel_fnames, rel_read_only_fnames)
         if edit_format:
             show += edit_format
+        if self.multiline_mode:
+            show += (" " if edit_format else "") + "multi"
         show += "> "
 
         inp = ""
         multiline_input = False
 
-        if self.user_input_color and self.pretty:
+        style = self._get_style()
-            style = Style.from_dict(
-                {
-                    "": self.user_input_color,
-                    "pygments.literal.string": f"bold italic {self.user_input_color}",
-                }
-            )
-        else:
-            style = None
 
         completer_instance = ThreadedCompleter(
             AutoCompleter(
@@ -337,10 +473,50 @@ class InputOutput:
             )
         )
 
+        def suspend_to_bg(event):
+            """Suspend currently running application."""
+            event.app.suspend_to_background()
+
         kb = KeyBindings()
 
-        @kb.add("escape", "c-m", eager=True)
+        @kb.add(Keys.ControlZ, filter=Condition(lambda: hasattr(signal, "SIGTSTP")))
         def _(event):
+            "Suspend to background with ctrl-z"
+            suspend_to_bg(event)
+
+        @kb.add("c-space")
+        def _(event):
+            "Ignore Ctrl when pressing space bar"
+            event.current_buffer.insert_text(" ")
+
+        @kb.add("c-up")
+        def _(event):
+            "Navigate backward through history"
+            event.current_buffer.history_backward()
+
+        @kb.add("c-down")
+        def _(event):
+            "Navigate forward through history"
+            event.current_buffer.history_forward()
+
+        @kb.add("enter", eager=True, filter=~is_searching)
+        def _(event):
+            "Handle Enter key press"
+            if self.multiline_mode:
+                # In multiline mode, Enter adds a newline
+                event.current_buffer.insert_text("\n")
+            else:
+                # In normal mode, Enter submits
+                event.current_buffer.validate_and_handle()
+
+        @kb.add("escape", "enter", eager=True, filter=~is_searching)  # This is Alt+Enter
+        def _(event):
+            "Handle Alt+Enter key press"
+            if self.multiline_mode:
+                # In multiline mode, Alt+Enter submits
+                event.current_buffer.validate_and_handle()
+            else:
+                # In normal mode, Alt+Enter adds a newline
                 event.current_buffer.insert_text("\n")
 
         while True:
@@ -349,27 +525,90 @@ class InputOutput:
 
             try:
                 if self.prompt_session:
+                    # Use placeholder if set, then clear it
+                    default = self.placeholder or ""
+                    self.placeholder = None
+
+                    self.interrupted = False
+                    if not multiline_input:
+                        if self.file_watcher:
+                            self.file_watcher.start()
+                        if self.clipboard_watcher:
+                            self.clipboard_watcher.start()
+
+                    def get_continuation(width, line_number, is_soft_wrap):
+                        return ". "
+
                     line = self.prompt_session.prompt(
                         show,
+                        default=default,
                         completer=completer_instance,
                         reserve_space_for_menu=4,
                         complete_style=CompleteStyle.MULTI_COLUMN,
                         style=style,
                         key_bindings=kb,
+                        complete_while_typing=True,
+                        prompt_continuation=get_continuation,
                     )
                 else:
                     line = input(show)
+
+                # Check if we were interrupted by a file change
+                if self.interrupted:
+                    line = line or ""
+                    if self.file_watcher:
+                        cmd = self.file_watcher.process_changes()
+                        return cmd
+
+            except EOFError:
+                raise
+            except Exception as err:
+                import traceback
+
+                self.tool_error(str(err))
+                self.tool_error(traceback.format_exc())
+                return ""
             except UnicodeEncodeError as err:
                 self.tool_error(str(err))
                 return ""
+            finally:
+                if self.file_watcher:
+                    self.file_watcher.stop()
+                if self.clipboard_watcher:
+                    self.clipboard_watcher.stop()
 
-            if line and line[0] == "{" and not multiline_input:
+            if line.strip("\r\n") and not multiline_input:
+                stripped = line.strip("\r\n")
+                if stripped == "{":
                     multiline_input = True
-                inp += line[1:] + "\n"
+                    multiline_tag = None
-                continue
+                    inp += ""
-            elif line and line[-1] == "}" and multiline_input:
+                elif stripped[0] == "{":
-                inp += line[:-1] + "\n"
+                    # Extract tag if it exists (only alphanumeric chars)
+                    tag = "".join(c for c in stripped[1:] if c.isalnum())
+                    if stripped == "{" + tag:
+                        multiline_input = True
+                        multiline_tag = tag
+                        inp += ""
+                    else:
+                        inp = line
                         break
+                else:
+                    inp = line
+                    break
+                continue
+            elif multiline_input and line.strip():
+                if multiline_tag:
+                    # Check if line is exactly "tag}"
+                    if line.strip("\r\n") == f"{multiline_tag}}}":
+                        break
+                    else:
+                        inp += line + "\n"
+                # Check if line is exactly "}"
+                elif line.strip("\r\n") == "}":
+                    break
+                else:
+                    inp += line + "\n"
             elif multiline_input:
                 inp += line + "\n"
             else:
@@ -383,10 +622,13 @@ class InputOutput:
     def add_to_input_history(self, inp):
         if not self.input_history_file:
             return
+        try:
             FileHistory(self.input_history_file).append_string(inp)
             # Also add to the in-memory history if it exists
-        if hasattr(self, "session") and hasattr(self.session, "history"):
+            if self.prompt_session and self.prompt_session.history:
-            self.session.history.append_string(inp)
+                self.prompt_session.history.append_string(inp)
+        except OSError as err:
+            self.tool_warning(f"Unable to write to input history file: {err}")
 
     def get_input_history(self):
         if not self.input_history_file:
@@ -403,8 +645,7 @@ class InputOutput:
             log_file.write(f"{role.upper()} {timestamp}\n")
             log_file.write(content + "\n")
 
-    def user_input(self, inp, log_only=True):
+    def display_user_input(self, inp):
-        if not log_only:
         if self.pretty and self.user_input_color:
             style = dict(style=self.user_input_color)
         else:
@@ -412,6 +653,10 @@ class InputOutput:
 
         self.console.print(Text(inp), **style)
 
+    def user_input(self, inp, log_only=True):
+        if not log_only:
+            self.display_user_input(inp)
+
         prefix = "####"
         if inp:
             hist = inp.splitlines()
@@ -430,23 +675,53 @@ class InputOutput:
         hist = "\n" + content.strip() + "\n\n"
         self.append_chat_history(hist)
 
+    def offer_url(self, url, prompt="Open URL for more info?", allow_never=True):
+        """Offer to open a URL in the browser, returns True if opened."""
+        if url in self.never_prompts:
+            return False
+        if self.confirm_ask(prompt, subject=url, allow_never=allow_never):
+            webbrowser.open(url)
+            return True
+        return False
+
+    @restore_multiline
     def confirm_ask(
-        self, question, default="y", subject=None, explicit_yes_required=False, group=None
+        self,
+        question,
+        default="y",
+        subject=None,
+        explicit_yes_required=False,
+        group=None,
+        allow_never=False,
     ):
         self.num_user_asks += 1
 
+        question_id = (question, subject)
+
+        if question_id in self.never_prompts:
+            return False
+
         if group and not group.show_group:
             group = None
+        if group:
+            allow_never = True
 
-        valid_responses = ["yes", "no"]
+        valid_responses = ["yes", "no", "skip", "all"]
         options = " (Y)es/(N)o"
         if group:
             if not explicit_yes_required:
                 options += "/(A)ll"
-                valid_responses.append("all")
             options += "/(S)kip all"
-            valid_responses.append("skip")
+        if allow_never:
+            options += "/(D)on't ask again"
+            valid_responses.append("don't")
+
+        if default.lower().startswith("y"):
             question += options + " [Yes]: "
+        elif default.lower().startswith("n"):
+            question += options + " [No]: "
+        else:
+            question += options + f" [{default}]: "
 
         if subject:
             self.tool_output()
@@ -459,10 +734,7 @@ class InputOutput:
             else:
                 self.tool_output(subject, bold=True)
 
-        if self.pretty and self.user_input_color:
+        style = self._get_style()
-            style = {"": self.user_input_color}
-        else:
-            style = dict()
 
         def is_valid_response(text):
             if not text:
@@ -481,13 +753,14 @@ class InputOutput:
                 if self.prompt_session:
                     res = self.prompt_session.prompt(
                         question,
-                        style=Style.from_dict(style),
+                        style=style,
+                        complete_while_typing=False,
                     )
                 else:
                     res = input(question)
 
                 if not res:
-                    res = "y"  # Default to Yes if no input
+                    res = default
                     break
                 res = res.lower()
                 good = any(valid_response.startswith(res) for valid_response in valid_responses)
@@ -499,6 +772,12 @@ class InputOutput:
 
         res = res.lower()[0]
 
+        if res == "d" and allow_never:
+            self.never_prompts.add(question_id)
+            hist = f"{question.strip()} {res}"
+            self.append_chat_history(hist, linebreak=True, blockquote=True)
+            return False
+
         if explicit_yes_required:
             is_yes = res == "y"
         else:
@@ -518,6 +797,7 @@ class InputOutput:
 
         return is_yes
 
+    @restore_multiline
     def prompt_ask(self, question, default="", subject=None):
         self.num_user_asks += 1
 
@@ -525,10 +805,7 @@ class InputOutput:
             self.tool_output()
             self.tool_output(subject, bold=True)
 
-        if self.pretty and self.user_input_color:
+        style = self._get_style()
-            style = Style.from_dict({"": self.user_input_color})
-        else:
-            style = None
 
         if self.yes is True:
             res = "yes"
@@ -536,7 +813,12 @@ class InputOutput:
             res = "no"
         else:
             if self.prompt_session:
-                res = self.prompt_session.prompt(question + " ", default=default, style=style)
+                res = self.prompt_session.prompt(
+                    question + " ",
+                    default=default,
+                    style=style,
+                    complete_while_typing=True,
+                )
             else:
                 res = input(question + " ")
 
@@ -556,8 +838,16 @@ class InputOutput:
                 hist = message.strip() if strip else message
                 self.append_chat_history(hist, linebreak=True, blockquote=True)
 
+        if not isinstance(message, Text):
             message = Text(message)
         style = dict(style=color) if self.pretty and color else dict()
+        try:
+            self.console.print(message, **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.console.print(message, **style)
 
     def tool_error(self, message="", strip=True):
@@ -586,15 +876,19 @@ class InputOutput:
         style = RichStyle(**style)
         self.console.print(*messages, style=style)
 
-    def assistant_output(self, message, stream=False):
+    def get_assistant_mdstream(self):
-        mdStream = None
-        show_resp = message
-        
-        if self.pretty:
-            if stream:
         mdargs = dict(style=self.assistant_output_color, code_theme=self.code_theme)
         mdStream = MarkdownStream(mdargs=mdargs)
-            else:
+        return mdStream
+
+    def assistant_output(self, message, pretty=None):
+        show_resp = message
+
+        # Coder will force pretty off if fence is not triple-backticks
+        if pretty is None:
+            pretty = self.pretty
+
+        if pretty:
             show_resp = Markdown(
                 message, style=self.assistant_output_color, code_theme=self.code_theme
             )
@@ -602,11 +896,26 @@ class InputOutput:
             show_resp = Text(message or "<no response>")
 
         self.console.print(show_resp)
-        return mdStream
+
+    def set_placeholder(self, placeholder):
+        """Set a one-time placeholder text for the next input prompt."""
+        self.placeholder = placeholder
 
     def print(self, message=""):
         print(message)
 
+    def toggle_multiline_mode(self):
+        """Toggle between normal and multiline input modes"""
+        self.multiline_mode = not self.multiline_mode
+        if self.multiline_mode:
+            self.tool_output(
+                "Multiline mode: Enabled. Enter inserts newline, Alt-Enter submits text"
+            )
+        else:
+            self.tool_output(
+                "Multiline mode: Disabled. Alt-Enter inserts newline, Enter submits text"
+            )
+
     def append_chat_history(self, text, linebreak=False, blockquote=False, strip=True):
         if blockquote:
             if strip:
@@ -620,11 +929,63 @@ class InputOutput:
             text += "\n"
         if self.chat_history_file is not None:
             try:
-                with self.chat_history_file.open("a", encoding=self.encoding) as f:
+                with self.chat_history_file.open("a", encoding=self.encoding, errors="ignore") as f:
                     f.write(text)
-            except (PermissionError, OSError):
+            except (PermissionError, OSError) as err:
-                self.tool_error(
+                print(f"Warning: Unable to write to chat history file {self.chat_history_file}.")
-                    f"Warning: Unable to write to chat history file {self.chat_history_file}."
+                print(err)
-                    " Permission denied."
-                )
                 self.chat_history_file = None  # Disable further attempts to write
+
+    def format_files_for_input(self, rel_fnames, rel_read_only_fnames):
+        if not self.pretty:
+            read_only_files = []
+            for full_path in sorted(rel_read_only_fnames or []):
+                read_only_files.append(f"{full_path} (read only)")
+
+            editable_files = []
+            for full_path in sorted(rel_fnames):
+                if full_path in rel_read_only_fnames:
+                    continue
+                editable_files.append(f"{full_path}")
+
+            return "\n".join(read_only_files + editable_files) + "\n"
+
+        output = StringIO()
+        console = Console(file=output, force_terminal=False)
+
+        read_only_files = sorted(rel_read_only_fnames or [])
+        editable_files = [f for f in sorted(rel_fnames) if f not in rel_read_only_fnames]
+
+        if read_only_files:
+            # Use shorter of abs/rel paths for readonly files
+            ro_paths = []
+            for rel_path in read_only_files:
+                abs_path = os.path.abspath(os.path.join(self.root, rel_path))
+                ro_paths.append(abs_path if len(abs_path) < len(rel_path) else rel_path)
+
+            files_with_label = ["Readonly:"] + ro_paths
+            read_only_output = StringIO()
+            Console(file=read_only_output, force_terminal=False).print(Columns(files_with_label))
+            read_only_lines = read_only_output.getvalue().splitlines()
+            console.print(Columns(files_with_label))
+
+        if editable_files:
+            files_with_label = editable_files
+            if read_only_files:
+                files_with_label = ["Editable:"] + editable_files
+                editable_output = StringIO()
+                Console(file=editable_output, force_terminal=False).print(Columns(files_with_label))
+                editable_lines = editable_output.getvalue().splitlines()
+
+                if len(read_only_lines) > 1 or len(editable_lines) > 1:
+                    console.print()
+            console.print(Columns(files_with_label))
+
+        return output.getvalue()
+
+
+def get_rel_fname(fname, root):
+    try:
+        return os.path.relpath(fname, root)
+    except ValueError:
+        return fname

aider/linter.py

@@ -8,9 +8,10 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from grep_ast import TreeContext, filename_to_lang
-from tree_sitter_languages import get_parser  # noqa: E402
+from grep_ast.tsl import get_parser  # noqa: E402
 
 from aider.dump import dump  # noqa: F401
+from aider.run_cmd import run_cmd_subprocess  # noqa: F401
 
 # tree_sitter is throwing a FutureWarning
 warnings.simplefilter("ignore", category=FutureWarning)
@@ -44,26 +45,22 @@ class Linter:
 
     def run_cmd(self, cmd, rel_fname, code):
         cmd += " " + rel_fname
-        cmd = cmd.split()
 
+        returncode = 0
+        stdout = ""
         try:
-            process = subprocess.Popen(
+            returncode, stdout = run_cmd_subprocess(
                 cmd,
                 cwd=self.root,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
                 encoding=self.encoding,
-                errors="replace",
             )
         except OSError as err:
             print(f"Unable to execute lint command: {err}")
             return
-        stdout, _ = process.communicate()
         errors = stdout
-        if process.returncode == 0:
+        if returncode == 0:
             return  # zero exit status
 
-        cmd = " ".join(cmd)
         res = f"## Running: {cmd}\n\n"
         res += errors
 
@@ -83,7 +80,11 @@ class Linter:
 
     def lint(self, fname, cmd=None):
         rel_fname = self.get_rel_fname(fname)
+        try:
             code = Path(fname).read_text(encoding=self.encoding, errors="replace")
+        except OSError as err:
+            print(f"Unable to read {fname}: {err}")
+            return
 
         if cmd:
             cmd = cmd.strip()
@@ -148,12 +149,12 @@ class Linter:
         try:
             result = subprocess.run(
                 flake8_cmd,
-                cwd=self.root,
                 capture_output=True,
                 text=True,
                 check=False,
                 encoding=self.encoding,
                 errors="replace",
+                cwd=self.root,
             )
             errors = result.stdout + result.stderr
         except Exception as e:
@@ -211,13 +212,18 @@ def basic_lint(fname, code):
 
     try:
         parser = get_parser(lang)
-    except OSError as err:
+    except Exception as err:
         print(f"Unable to load parser: {err}")
         return
 
     tree = parser.parse(bytes(code, "utf-8"))
 
+    try:
         errors = traverse_tree(tree.root_node)
+    except RecursionError:
+        print(f"Unable to lint {fname} due to RecursionError")
+        return
+
     if not errors:
         return
 

aider/llm.py

@@ -2,6 +2,8 @@ import importlib
 import os
 import warnings
 
+from aider.dump import dump  # noqa: F401
+
 warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
 
 AIDER_SITE_URL = "https://aider.chat"
@@ -13,6 +15,8 @@ os.environ["LITELLM_MODE"] = "PRODUCTION"
 
 # `import litellm` takes 1.5 seconds, defer it!
 
+VERBOSE = False
+
 
 class LazyLiteLLM:
     _lazy_module = None
@@ -27,6 +31,9 @@ class LazyLiteLLM:
         if self._lazy_module is not None:
             return
 
+        if VERBOSE:
+            print("Loading litellm...")
+
         self._lazy_module = importlib.import_module("litellm")
 
         self._lazy_module.suppress_debug_info = True

aider/main.py

@@ -5,27 +5,56 @@ import re
 import sys
 import threading
 import traceback
+import webbrowser
+from dataclasses import fields
 from pathlib import Path
 
-import git
+try:
+    import git
+except ImportError:
+    git = None
+
+import importlib_resources
 from dotenv import load_dotenv
 from prompt_toolkit.enums import EditingMode
 
-from aider import __version__, models, utils
+from aider import __version__, models, urls, utils
+from aider.analytics import Analytics
 from aider.args import get_parser
 from aider.coders import Coder
+from aider.coders.base_coder import UnknownEditFormat
 from aider.commands import Commands, SwitchCoder
+from aider.copypaste import ClipboardWatcher
 from aider.format_settings import format_settings, scrub_sensitive_info
 from aider.history import ChatSummary
 from aider.io import InputOutput
 from aider.llm import litellm  # noqa: F401; properly init litellm on launch
+from aider.models import ModelSettings
 from aider.repo import ANY_GIT_ERROR, GitRepo
 from aider.report import report_uncaught_exceptions
 from aider.versioncheck import check_version, install_from_main_branch, install_upgrade
+from aider.watch import FileWatcher
 
 from .dump import dump  # noqa: F401
 
 
+def check_config_files_for_yes(config_files):
+    found = False
+    for config_file in config_files:
+        if Path(config_file).exists():
+            try:
+                with open(config_file, "r") as f:
+                    for line in f:
+                        if line.strip().startswith("yes:"):
+                            print("Configuration error detected.")
+                            print(f"The file {config_file} contains a line starting with 'yes:'")
+                            print("Please replace 'yes:' with 'yes-always:' in this file.")
+                            found = True
+            except Exception:
+                pass
+    return found
+
+
 def get_git_root():
     """Try and guess the git repo, since the conf.yml can be at the repo root"""
     try:
@@ -40,7 +69,7 @@ def guessed_wrong_repo(io, git_root, fnames, git_dname):
 
     try:
         check_repo = Path(GitRepo(io, fnames, git_dname).root).resolve()
-    except FileNotFoundError:
+    except (OSError,) + ANY_GIT_ERROR:
         return
 
     # we had no guess, rely on the "true" repo result
@@ -68,15 +97,30 @@ def make_new_repo(git_root, io):
 
 
 def setup_git(git_root, io):
+    if git is None:
+        return
+
+    try:
+        cwd = Path.cwd()
+    except OSError:
+        cwd = None
+
     repo = None
 
     if git_root:
+        try:
             repo = git.Repo(git_root)
-    elif Path.cwd() == Path.home():
+        except ANY_GIT_ERROR:
-        io.tool_warning("You should probably run aider in a directory, not your home dir.")
+            pass
+    elif cwd == Path.home():
+        io.tool_warning(
+            "You should probably run aider in your project's directory, not your home dir."
+        )
         return
-    elif io.confirm_ask("No git repo found, create one to track aider's changes (recommended)?"):
+    elif cwd and io.confirm_ask(
-        git_root = str(Path.cwd().resolve())
+        "No git repo found, create one to track aider's changes (recommended)?"
+    ):
+        git_root = str(cwd.resolve())
         repo = make_new_repo(git_root, io)
 
     if not repo:
@@ -114,32 +158,51 @@ def check_gitignore(git_root, io, ask=True):
 
     try:
         repo = git.Repo(git_root)
-        if repo.ignored(".aider"):
+        patterns_to_add = []
-            return
-    except ANY_GIT_ERROR:
-        pass
 
-    pat = ".aider*"
+        if not repo.ignored(".aider"):
+            patterns_to_add.append(".aider*")
+
+        env_path = Path(git_root) / ".env"
+        if env_path.exists() and not repo.ignored(".env"):
+            patterns_to_add.append(".env")
+
+        if not patterns_to_add:
+            return
 
         gitignore_file = Path(git_root) / ".gitignore"
         if gitignore_file.exists():
+            try:
                 content = io.read_text(gitignore_file)
                 if content is None:
                     return
-        if pat in content.splitlines():
+                if not content.endswith("\n"):
+                    content += "\n"
+            except OSError as e:
+                io.tool_error(f"Error when trying to read {gitignore_file}: {e}")
                 return
         else:
             content = ""
-
+    except ANY_GIT_ERROR:
-    if ask and not io.confirm_ask(f"Add {pat} to .gitignore (recommended)?"):
         return
 
-    if content and not content.endswith("\n"):
+    if ask:
-        content += "\n"
+        io.tool_output("You can skip this check with --no-gitignore")
-    content += pat + "\n"
+        if not io.confirm_ask(f"Add {', '.join(patterns_to_add)} to .gitignore (recommended)?"):
-    io.write_text(gitignore_file, content)
+            return
 
-    io.tool_output(f"Added {pat} to .gitignore")
+    content += "\n".join(patterns_to_add) + "\n"
+
+    try:
+        io.write_text(gitignore_file, content)
+        io.tool_output(f"Added {', '.join(patterns_to_add)} to .gitignore")
+    except OSError as e:
+        io.tool_error(f"Error when trying to write to {gitignore_file}: {e}")
+        io.tool_output(
+            "Try running with appropriate permissions or manually add these patterns to .gitignore:"
+        )
+        for pattern in patterns_to_add:
+            io.tool_output(f"  {pattern}")
 
 
 def check_streamlit_install(io):
@@ -151,6 +214,34 @@ def check_streamlit_install(io):
     )
 
 
+def install_tree_sitter_language_pack(io):
+    return utils.check_pip_install_extra(
+        io,
+        "tree_sitter_language_pack",
+        "Install tree_sitter_language_pack?",
+        [
+            "tree-sitter-language-pack==0.4.0",
+            "tree-sitter==0.24.0",
+        ],
+    )
+
+
+def write_streamlit_credentials():
+    from streamlit.file_util import get_streamlit_file_path
+
+    # See https://github.com/Aider-AI/aider/issues/772
+
+    credential_path = Path(get_streamlit_file_path()) / "credentials.toml"
+    if not os.path.exists(credential_path):
+        empty_creds = '[general]\nemail = ""\n'
+
+        os.makedirs(os.path.dirname(credential_path), exist_ok=True)
+        with open(credential_path, "w") as f:
+            f.write(empty_creds)
+    else:
+        print("Streamlit credentials already exist.")
+
+
 def launch_gui(args):
     from streamlit.web import cli
 
@@ -159,6 +250,9 @@ def launch_gui(args):
     print()
     print("CONTROL-C to exit...")
 
+    # Necessary so streamlit does not prompt the user for an email address.
+    write_streamlit_credentials()
+
     target = gui.__file__
 
     st_args = ["run", target]
@@ -169,7 +263,10 @@ def launch_gui(args):
         "--server.runOnSave=false",
     ]
 
-    if "-dev" in __version__:
+    # https://github.com/Aider-AI/aider/issues/2193
+    is_dev = "-dev" in str(__version__)
+
+    if is_dev:
         print("Watching for file changes.")
     else:
         st_args += [
@@ -217,16 +314,23 @@ def parse_lint_cmds(lint_cmds, io):
     return res
 
 
-def generate_search_path_list(default_fname, git_root, command_line_file):
+def generate_search_path_list(default_file, git_root, command_line_file):
     files = []
-    default_file = Path(default_fname)
     files.append(Path.home() / default_file)  # homedir
     if git_root:
         files.append(Path(git_root) / default_file)  # git root
-    files.append(default_file.resolve())
+    files.append(default_file)
     if command_line_file:
         files.append(command_line_file)
-    files = [Path(fn).resolve() for fn in files]
+
+    resolved_files = []
+    for fn in files:
+        try:
+            resolved_files.append(Path(fn).resolve())
+        except OSError:
+            pass
+
+    files = resolved_files
     files.reverse()
     uniq = []
     for fn in files:
@@ -266,7 +370,7 @@ def register_models(git_root, model_settings_fname, io, verbose=False):
     return None
 
 
-def load_dotenv_files(git_root, dotenv_fname):
+def load_dotenv_files(git_root, dotenv_fname, encoding="utf-8"):
     dotenv_files = generate_search_path_list(
         ".env",
         git_root,
@@ -274,19 +378,30 @@ def load_dotenv_files(git_root, dotenv_fname):
     )
     loaded = []
     for fname in dotenv_files:
+        try:
             if Path(fname).exists():
+                load_dotenv(fname, override=True, encoding=encoding)
                 loaded.append(fname)
-            load_dotenv(fname, override=True)
+        except OSError as e:
+            print(f"OSError loading {fname}: {e}")
+        except Exception as e:
+            print(f"Error loading {fname}: {e}")
     return loaded
 
 
 def register_litellm_models(git_root, model_metadata_fname, io, verbose=False):
-    model_metatdata_files = generate_search_path_list(
+    model_metadata_files = []
+
+    # Add the resource file path
+    resource_metadata = importlib_resources.files("aider.resources").joinpath("model-metadata.json")
+    model_metadata_files.append(str(resource_metadata))
+
+    model_metadata_files += generate_search_path_list(
         ".aider.model.metadata.json", git_root, model_metadata_fname
     )
 
     try:
-        model_metadata_files_loaded = models.register_litellm_models(model_metatdata_files)
+        model_metadata_files_loaded = models.register_litellm_models(model_metadata_files)
         if len(model_metadata_files_loaded) > 0 and verbose:
             io.tool_output("Loaded model metadata from:")
             for model_metadata_file in model_metadata_files_loaded:
@@ -304,11 +419,18 @@ def sanity_check_repo(repo, io):
         io.tool_error("The git repo does not seem to have a working tree?")
         return False
 
+    bad_ver = False
     try:
         repo.get_tracked_files()
         if not repo.git_repo_error:
             return True
         error_msg = str(repo.git_repo_error)
+    except UnicodeDecodeError as exc:
+        error_msg = (
+            "Failed to read the Git repository. This issue is likely caused by a path encoded "
+            f'in a format different from the expected encoding "{sys.getfilesystemencoding()}".\n'
+            f"Internal error: {str(exc)}"
+        )
     except ANY_GIT_ERROR as exc:
         error_msg = str(exc)
         bad_ver = "version in (1, 2)" in error_msg
@@ -320,7 +442,7 @@ def sanity_check_repo(repo, io):
         io.tool_error("Aider only works with git repos with version number 1 or 2.")
         io.tool_output("You may be able to convert your repo: git update-index --index-version=2")
         io.tool_output("Or run aider --no-git to proceed without using git.")
-        io.tool_output("https://github.com/paul-gauthier/aider/issues/211")
+        io.offer_url(urls.git_index_version, "Open documentation url for more info?")
         return False
 
     io.tool_error("Unable to read git repository, it may be corrupt?")
@@ -334,14 +456,21 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     if argv is None:
         argv = sys.argv[1:]
 
-    if force_git_root:
+    if git is None:
+        git_root = None
+    elif force_git_root:
         git_root = force_git_root
     else:
         git_root = get_git_root()
 
     conf_fname = Path(".aider.conf.yml")
 
-    default_config_files = [conf_fname.resolve()]  # CWD
+    default_config_files = []
+    try:
+        default_config_files += [conf_fname.resolve()]  # CWD
+    except OSError:
+        pass
+
     if git_root:
         git_conf = Path(git_root) / conf_fname  # git root
         if git_conf not in default_config_files:
@@ -350,7 +479,13 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     default_config_files = list(map(str, default_config_files))
 
     parser = get_parser(default_config_files, git_root)
+    try:
         args, unknown = parser.parse_known_args(argv)
+    except AttributeError as e:
+        if all(word in str(e) for word in ["bool", "object", "has", "no", "attribute", "strip"]):
+            if check_config_files_for_yes(default_config_files):
+                return 1
+        raise e
 
     if args.verbose:
         print("Config files search order, if no --config:")
@@ -361,19 +496,32 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     default_config_files.reverse()
 
     parser = get_parser(default_config_files, git_root)
+
     args, unknown = parser.parse_known_args(argv)
 
     # Load the .env file specified in the arguments
-    loaded_dotenvs = load_dotenv_files(git_root, args.env_file)
+    loaded_dotenvs = load_dotenv_files(git_root, args.env_file, args.encoding)
 
     # Parse again to include any arguments that might have been defined in .env
     args = parser.parse_args(argv)
 
+    if git is None:
+        args.git = False
+
+    if args.analytics_disable:
+        analytics = Analytics(permanently_disable=True)
+        print("Analytics have been permanently disabled.")
+
     if not args.verify_ssl:
         import httpx
 
+        os.environ["SSL_VERIFY"] = ""
         litellm._load_litellm()
         litellm._lazy_module.client_session = httpx.Client(verify=False)
+        litellm._lazy_module.aclient_session = httpx.AsyncClient(verify=False)
+
+    if args.timeout:
+        models.request_timeout = args.timeout
 
     if args.dark_mode:
         args.user_input_color = "#32FF32"
@@ -389,28 +537,36 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         args.assistant_output_color = "blue"
         args.code_theme = "default"
 
-    if return_coder and args.yes is None:
+    if return_coder and args.yes_always is None:
-        args.yes = True
+        args.yes_always = True
 
     editing_mode = EditingMode.VI if args.vim else EditingMode.EMACS
 
     def get_io(pretty):
         return InputOutput(
             pretty,
-            args.yes,
+            args.yes_always,
             args.input_history_file,
             args.chat_history_file,
             input=input,
             output=output,
             user_input_color=args.user_input_color,
             tool_output_color=args.tool_output_color,
+            tool_warning_color=args.tool_warning_color,
             tool_error_color=args.tool_error_color,
+            completion_menu_color=args.completion_menu_color,
+            completion_menu_bg_color=args.completion_menu_bg_color,
+            completion_menu_current_color=args.completion_menu_current_color,
+            completion_menu_current_bg_color=args.completion_menu_current_bg_color,
             assistant_output_color=args.assistant_output_color,
             code_theme=args.code_theme,
             dry_run=args.dry_run,
             encoding=args.encoding,
+            line_endings=args.line_endings,
             llm_history_file=args.llm_history_file,
             editingmode=editing_mode,
+            fancy_input=args.fancy_input,
+            multiline_mode=args.multiline,
         )
 
     io = get_io(args.pretty)
@@ -422,10 +578,82 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         io = get_io(False)
         io.tool_warning("Terminal does not support pretty output (UnicodeDecodeError)")
 
+    # Process any environment variables set via --set-env
+    if args.set_env:
+        for env_setting in args.set_env:
+            try:
+                name, value = env_setting.split("=", 1)
+                os.environ[name.strip()] = value.strip()
+            except ValueError:
+                io.tool_error(f"Invalid --set-env format: {env_setting}")
+                io.tool_output("Format should be: ENV_VAR_NAME=value")
+                return 1
+
+    # Process any API keys set via --api-key
+    if args.api_key:
+        for api_setting in args.api_key:
+            try:
+                provider, key = api_setting.split("=", 1)
+                env_var = f"{provider.strip().upper()}_API_KEY"
+                os.environ[env_var] = key.strip()
+            except ValueError:
+                io.tool_error(f"Invalid --api-key format: {api_setting}")
+                io.tool_output("Format should be: provider=key")
+                return 1
+
+    if args.anthropic_api_key:
+        os.environ["ANTHROPIC_API_KEY"] = args.anthropic_api_key
+
+    if args.openai_api_key:
+        os.environ["OPENAI_API_KEY"] = args.openai_api_key
+    if args.openai_api_base:
+        os.environ["OPENAI_API_BASE"] = args.openai_api_base
+    if args.openai_api_version:
+        io.tool_warning(
+            "--openai-api-version is deprecated, use --set-env OPENAI_API_VERSION=<value>"
+        )
+        os.environ["OPENAI_API_VERSION"] = args.openai_api_version
+    if args.openai_api_type:
+        io.tool_warning("--openai-api-type is deprecated, use --set-env OPENAI_API_TYPE=<value>")
+        os.environ["OPENAI_API_TYPE"] = args.openai_api_type
+    if args.openai_organization_id:
+        io.tool_warning(
+            "--openai-organization-id is deprecated, use --set-env OPENAI_ORGANIZATION=<value>"
+        )
+        os.environ["OPENAI_ORGANIZATION"] = args.openai_organization_id
+
+    analytics = Analytics(logfile=args.analytics_log, permanently_disable=args.analytics_disable)
+    if args.analytics is not False:
+        if analytics.need_to_ask(args.analytics):
+            io.tool_output(
+                "Aider respects your privacy and never collects your code, chat messages, keys or"
+                " personal info."
+            )
+            io.tool_output(f"For more info: {urls.analytics}")
+            disable = not io.confirm_ask(
+                "Allow collection of anonymous analytics to help improve aider?"
+            )
+
+            analytics.asked_opt_in = True
+            if disable:
+                analytics.disable(permanently=True)
+                io.tool_output("Analytics have been permanently disabled.")
+
+            analytics.save_data()
+            io.tool_output()
+
+        # This is a no-op if the user has opted out
+        analytics.enable()
+
+    analytics.event("launched")
+
     if args.gui and not return_coder:
         if not check_streamlit_install(io):
+            analytics.event("exit", reason="Streamlit not installed")
             return
+        analytics.event("gui session")
         launch_gui(argv)
+        analytics.event("exit", reason="GUI session ended")
         return
 
     if args.verbose:
@@ -434,7 +662,14 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
 
     all_files = args.files + (args.file or [])
     fnames = [str(Path(fn).resolve()) for fn in all_files]
-    read_only_fnames = [str(Path(fn).resolve()) for fn in (args.read or [])]
+    read_only_fnames = []
+    for fn in args.read or []:
+        path = Path(fn).expanduser().resolve()
+        if path.is_dir():
+            read_only_fnames.extend(str(f) for f in path.rglob("*") if f.is_file())
+        else:
+            read_only_fnames.append(str(path))
+
     if len(all_files) > 1:
         good = True
         for fname in all_files:
@@ -445,6 +680,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             io.tool_output(
                 "Provide either a single directory of a git repo, or a list of one or more files."
             )
+            analytics.event("exit", reason="Invalid directory input")
             return 1
 
     git_dname = None
@@ -455,26 +691,36 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
                 fnames = []
             else:
                 io.tool_error(f"{all_files[0]} is a directory, but --no-git selected.")
+                analytics.event("exit", reason="Directory with --no-git")
                 return 1
 
     # We can't know the git repo for sure until after parsing the args.
     # If we guessed wrong, reparse because that changes things like
     # the location of the config.yml and history files.
-    if args.git and not force_git_root:
+    if args.git and not force_git_root and git is not None:
         right_repo_root = guessed_wrong_repo(io, git_root, fnames, git_dname)
         if right_repo_root:
+            analytics.event("exit", reason="Recursing with correct repo")
             return main(argv, input, output, right_repo_root, return_coder=return_coder)
 
     if args.just_check_update:
         update_available = check_version(io, just_check=True, verbose=args.verbose)
+        analytics.event("exit", reason="Just checking update")
         return 0 if not update_available else 1
 
     if args.install_main_branch:
         success = install_from_main_branch(io)
+        analytics.event("exit", reason="Installed main branch")
         return 0 if success else 1
 
     if args.upgrade:
         success = install_upgrade(io)
+        analytics.event("exit", reason="Upgrade completed")
+        return 0 if success else 1
+
+    if args.install_tree_sitter_language_pack:
+        success = install_tree_sitter_language_pack(io)
+        analytics.event("exit", reason="Install TSLP completed")
         return 0 if success else 1
 
     if args.check_update:
@@ -482,6 +728,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
 
     if args.list_models:
         models.print_matching_models(io, args.list_models)
+        analytics.event("exit", reason="Listed models")
         return 0
 
     if args.git:
@@ -497,49 +744,92 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     cmd_line = scrub_sensitive_info(args, cmd_line)
     io.tool_output(cmd_line, log_only=True)
 
-    check_and_load_imports(io, verbose=args.verbose)
+    is_first_run = is_first_run_of_new_version(io, verbose=args.verbose)
-
+    check_and_load_imports(io, is_first_run, verbose=args.verbose)
-    if args.anthropic_api_key:
-        os.environ["ANTHROPIC_API_KEY"] = args.anthropic_api_key
-
-    if args.openai_api_key:
-        os.environ["OPENAI_API_KEY"] = args.openai_api_key
-    if args.openai_api_base:
-        os.environ["OPENAI_API_BASE"] = args.openai_api_base
-    if args.openai_api_version:
-        os.environ["OPENAI_API_VERSION"] = args.openai_api_version
-    if args.openai_api_type:
-        os.environ["OPENAI_API_TYPE"] = args.openai_api_type
-    if args.openai_organization_id:
-        os.environ["OPENAI_ORGANIZATION"] = args.openai_organization_id
 
     register_models(git_root, args.model_settings_file, io, verbose=args.verbose)
     register_litellm_models(git_root, args.model_metadata_file, io, verbose=args.verbose)
 
-    if not args.model:
+    # Process any command line aliases
-        args.model = "gpt-4o-2024-08-06"
+    if args.alias:
-        if os.environ.get("ANTHROPIC_API_KEY"):
+        for alias_def in args.alias:
-            args.model = "claude-3-5-sonnet-20240620"
+            # Split on first colon only
+            parts = alias_def.split(":", 1)
+            if len(parts) != 2:
+                io.tool_error(f"Invalid alias format: {alias_def}")
+                io.tool_output("Format should be: alias:model-name")
+                analytics.event("exit", reason="Invalid alias format error")
+                return 1
+            alias, model = parts
+            models.MODEL_ALIASES[alias.strip()] = model.strip()
 
-    main_model = models.Model(args.model, weak_model=args.weak_model)
+    if not args.model:
+        # Select model based on available API keys
+        model_key_pairs = [
+            ("ANTHROPIC_API_KEY", "sonnet"),
+            ("DEEPSEEK_API_KEY", "deepseek"),
+            ("OPENROUTER_API_KEY", "openrouter/anthropic/claude-3.5-sonnet"),
+            ("OPENAI_API_KEY", "gpt-4o"),
+            ("GEMINI_API_KEY", "flash"),
+        ]
+
+        for env_key, model_name in model_key_pairs:
+            if os.environ.get(env_key):
+                args.model = model_name
+                io.tool_warning(
+                    f"Found {env_key} so using {model_name} since no --model was specified."
+                )
+                break
+        if not args.model:
+            io.tool_error("You need to specify a --model and an --api-key to use.")
+            io.offer_url(urls.models_and_keys, "Open documentation url for more info?")
+            return 1
+
+    main_model = models.Model(
+        args.model,
+        weak_model=args.weak_model,
+        editor_model=args.editor_model,
+        editor_edit_format=args.editor_edit_format,
+    )
+
+    # add --reasoning-effort cli param
+    if args.reasoning_effort is not None:
+        if not getattr(main_model, "extra_params", None):
+            main_model.extra_params = {}
+        if "extra_body" not in main_model.extra_params:
+            main_model.extra_params["extra_body"] = {}
+        main_model.extra_params["extra_body"]["reasoning_effort"] = args.reasoning_effort
+
+    if args.copy_paste and args.edit_format is None:
+        if main_model.edit_format in ("diff", "whole"):
+            main_model.edit_format = "editor-" + main_model.edit_format
 
     if args.verbose:
-        io.tool_output("Model info:")
+        io.tool_output("Model metadata:")
         io.tool_output(json.dumps(main_model.info, indent=4))
 
+        io.tool_output("Model settings:")
+        for attr in sorted(fields(ModelSettings), key=lambda x: x.name):
+            val = getattr(main_model, attr.name)
+            val = json.dumps(val, indent=4)
+            io.tool_output(f"{attr.name}: {val}")
+
     lint_cmds = parse_lint_cmds(args.lint_cmd, io)
     if lint_cmds is None:
+        analytics.event("exit", reason="Invalid lint command format")
         return 1
 
     if args.show_model_warnings:
         problem = models.sanity_check_models(io, main_model)
         if problem:
+            analytics.event("model warning", main_model=main_model)
             io.tool_output("You can skip this check with --no-show-model-warnings")
-            io.tool_output()
+
             try:
-                if not io.confirm_ask("Proceed anyway?"):
+                io.offer_url(urls.model_warnings, "Open documentation url for more info?")
-                    return 1
+                io.tool_output()
             except KeyboardInterrupt:
+                analytics.event("exit", reason="Keyboard interrupt during model warnings")
                 return 1
 
     repo = None
@@ -561,11 +851,27 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         except FileNotFoundError:
             pass
 
+    if not args.skip_sanity_check_repo:
         if not sanity_check_repo(repo, io):
+            analytics.event("exit", reason="Repository sanity check failed")
             return 1
 
+    if repo:
+        analytics.event("repo", num_files=len(repo.get_tracked_files()))
+    else:
+        analytics.event("no-repo")
+
     commands = Commands(
-        io, None, verify_ssl=args.verify_ssl, args=args, parser=parser, verbose=args.verbose
+        io,
+        None,
+        voice_language=args.voice_language,
+        voice_input_device=args.voice_input_device,
+        voice_format=args.voice_format,
+        verify_ssl=args.verify_ssl,
+        args=args,
+        parser=parser,
+        verbose=args.verbose,
+        editor=args.editor,
     )
 
     summarizer = ChatSummary(
@@ -579,10 +885,15 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     if not main_model.streaming:
         if args.stream:
             io.tool_warning(
-                "Warning: Streaming is not supported by the selected model. Disabling streaming."
+                f"Warning: Streaming is not supported by {main_model.name}. Disabling streaming."
             )
         args.stream = False
 
+    if args.map_tokens is None:
+        map_tokens = main_model.get_repo_map_tokens()
+    else:
+        map_tokens = args.map_tokens
+
     try:
         coder = Coder.create(
             main_model=main_model,
@@ -595,7 +906,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             auto_commits=args.auto_commits,
             dirty_commits=args.dirty_commits,
             dry_run=args.dry_run,
-            map_tokens=args.map_tokens,
+            map_tokens=map_tokens,
             verbose=args.verbose,
             stream=args.stream,
             use_git=args.git,
@@ -606,20 +917,50 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             test_cmd=args.test_cmd,
             commands=commands,
             summarizer=summarizer,
+            analytics=analytics,
             map_refresh=args.map_refresh,
             cache_prompts=args.cache_prompts,
             map_mul_no_files=args.map_multiplier_no_files,
             num_cache_warming_pings=args.cache_keepalive_pings,
             suggest_shell_commands=args.suggest_shell_commands,
             chat_language=args.chat_language,
+            detect_urls=args.detect_urls,
+            auto_copy_context=args.copy_paste,
         )
+    except UnknownEditFormat as err:
+        io.tool_error(str(err))
+        io.offer_url(urls.edit_formats, "Open documentation about edit formats?")
+        analytics.event("exit", reason="Unknown edit format")
+        return 1
     except ValueError as err:
         io.tool_error(str(err))
+        analytics.event("exit", reason="ValueError during coder creation")
         return 1
 
     if return_coder:
+        analytics.event("exit", reason="Returning coder object")
         return coder
 
+    ignores = []
+    if git_root:
+        ignores.append(str(Path(git_root) / ".gitignore"))
+    if args.aiderignore:
+        ignores.append(args.aiderignore)
+
+    if args.watch_files:
+        file_watcher = FileWatcher(
+            coder,
+            gitignores=ignores,
+            verbose=args.verbose,
+            analytics=analytics,
+            root=str(Path.cwd()) if args.subtree_only else None,
+        )
+        coder.file_watcher = file_watcher
+
+    if args.copy_paste:
+        analytics.event("copy-paste mode")
+        ClipboardWatcher(coder.io, verbose=args.verbose)
+
     coder.show_announcements()
 
     if args.show_prompts:
@@ -628,6 +969,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         ]
         messages = coder.format_messages().all_messages()
         utils.show_messages(messages)
+        analytics.event("exit", reason="Showed prompts")
         return
 
     if args.lint:
@@ -636,10 +978,11 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     if args.test:
         if not args.test_cmd:
             io.tool_error("No --test-cmd provided.")
+            analytics.event("exit", reason="No test command provided")
             return 1
-        test_errors = coder.commands.cmd_test(args.test_cmd)
+        coder.commands.cmd_test(args.test_cmd)
-        if test_errors:
+        if io.placeholder:
-            coder.run(test_errors)
+            coder.run(io.placeholder)
 
     if args.commit:
         if args.dry_run:
@@ -648,27 +991,44 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             coder.commands.cmd_commit()
 
     if args.lint or args.test or args.commit:
+        analytics.event("exit", reason="Completed lint/test/commit")
         return
 
     if args.show_repo_map:
         repo_map = coder.get_repo_map()
         if repo_map:
             io.tool_output(repo_map)
+        analytics.event("exit", reason="Showed repo map")
         return
 
     if args.apply:
         content = io.read_text(args.apply)
         if content is None:
+            analytics.event("exit", reason="Failed to read apply content")
             return
         coder.partial_response_content = content
+        # For testing #2879
+        # from aider.coders.base_coder import all_fences
+        # coder.fence = all_fences[1]
         coder.apply_updates()
+        analytics.event("exit", reason="Applied updates")
         return
 
-    if "VSCODE_GIT_IPC_HANDLE" in os.environ:
+    if args.apply_clipboard_edits:
-        args.pretty = False
+        args.edit_format = main_model.editor_edit_format
-        io.tool_output("VSCode terminal detected, pretty output has been disabled.")
+        args.message = "/paste"
 
-    io.tool_output('Use /help <question> for help, run "aider --help" to see cmd line args')
+    if args.show_release_notes is True:
+        io.tool_output(f"Opening release notes: {urls.release_notes}")
+        io.tool_output()
+        webbrowser.open(urls.release_notes)
+    elif args.show_release_notes is None and is_first_run:
+        io.tool_output()
+        io.offer_url(
+            urls.release_notes,
+            "Would you like to see what's new in this version?",
+            allow_never=False,
+        )
 
     if git_root and Path.cwd().resolve() != Path(git_root).resolve():
         io.tool_warning(
@@ -679,6 +1039,9 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         io.tool_output(f"Cur working dir: {Path.cwd()}")
         io.tool_output(f"Git working dir: {git_root}")
 
+    if args.load:
+        commands.cmd_load(args.load)
+
     if args.message:
         io.add_to_input_history(args.message)
         io.tool_output()
@@ -686,6 +1049,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             coder.run(with_message=args.message)
         except SwitchCoder:
             pass
+        analytics.event("exit", reason="Completed --message")
         return
 
     if args.message_file:
@@ -695,20 +1059,31 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             coder.run(with_message=message_from_file)
         except FileNotFoundError:
             io.tool_error(f"Message file not found: {args.message_file}")
+            analytics.event("exit", reason="Message file not found")
             return 1
         except IOError as e:
             io.tool_error(f"Error reading message file: {e}")
+            analytics.event("exit", reason="Message file IO error")
             return 1
+
+        analytics.event("exit", reason="Completed --message-file")
         return
 
     if args.exit:
+        analytics.event("exit", reason="Exit flag set")
         return
 
+    analytics.event("cli session", main_model=main_model, edit_format=main_model.edit_format)
+
     while True:
         try:
+            coder.ok_to_warm_cache = bool(args.cache_keepalive_pings)
             coder.run()
+            analytics.event("exit", reason="Completed main CLI coder.run")
             return
         except SwitchCoder as switch:
+            coder.ok_to_warm_cache = False
+
             kwargs = dict(io=io, from_coder=coder)
             kwargs.update(switch.kwargs)
             if "show_announcements" in kwargs:
@@ -720,10 +1095,15 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
                 coder.show_announcements()
 
 
-def check_and_load_imports(io, verbose=False):
+def is_first_run_of_new_version(io, verbose=False):
+    """Check if this is the first run of a new version/executable combination"""
     installs_file = Path.home() / ".aider" / "installs.json"
     key = (__version__, sys.executable)
 
+    # Never show notes for .dev versions
+    if ".dev" in __version__:
+        return False
+
     if verbose:
         io.tool_output(
             f"Checking imports for version {__version__} and executable {sys.executable}"
@@ -741,7 +1121,26 @@ def check_and_load_imports(io, verbose=False):
             if verbose:
                 io.tool_output("Installs file does not exist, creating new dictionary")
 
-        if str(key) not in installs:
+        is_first_run = str(key) not in installs
+
+        if is_first_run:
+            installs[str(key)] = True
+            installs_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(installs_file, "w") as f:
+                json.dump(installs, f, indent=4)
+
+        return is_first_run
+
+    except Exception as e:
+        io.tool_warning(f"Error checking version: {e}")
+        if verbose:
+            io.tool_output(f"Full exception details: {traceback.format_exc()}")
+        return True  # Safer to assume it's a first run if we hit an error
+
+
+def check_and_load_imports(io, is_first_run, verbose=False):
+    try:
+        if is_first_run:
             if verbose:
                 io.tool_output(
                     "First run for this version and executable, loading imports synchronously"
@@ -751,13 +1150,9 @@ def check_and_load_imports(io, verbose=False):
             except Exception as err:
                 io.tool_error(str(err))
                 io.tool_output("Error loading required imports. Did you install aider properly?")
-                io.tool_output("https://aider.chat/docs/install/install.html")
+                io.offer_url(urls.install_properly, "Open documentation url for more info?")
                 sys.exit(1)
 
-            installs[str(key)] = True
-            installs_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(installs_file, "w") as f:
-                json.dump(installs, f, indent=4)
             if verbose:
                 io.tool_output("Imports loaded and installs file updated")
         else:
@@ -766,8 +1161,9 @@ def check_and_load_imports(io, verbose=False):
             thread = threading.Thread(target=load_slow_imports)
             thread.daemon = True
             thread.start()
+
     except Exception as e:
-        io.tool_warning(f"Error in checking imports: {e}")
+        io.tool_warning(f"Error in loading imports: {e}")
         if verbose:
             io.tool_output(f"Full exception details: {traceback.format_exc()}")
 

aider/mdstream.py

@@ -10,10 +10,17 @@ from rich.text import Text
 
 from aider.dump import dump  # noqa: F401
 
-_text = """
+_text_prefix = """
 # Header
 
-Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
+Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
+when an unknown printer took a galley of type and scrambled it to make a type
+specimen book. It has survived not only five centuries, but also the leap into
+electronic typesetting, remaining essentially unchanged. It was popularised in
+the 1960s with the release of Letraset sheets containing Lorem Ipsum passages,
+and more recently with desktop publishing software like Aldus PageMaker
+including versions of Lorem Ipsum.
 
 
 
@@ -27,10 +34,9 @@ Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem
 
 
 ```python
-import sys
+"""
 
-def greeting():
+_text_suffix = """
-    print("Hello world!")
 ```
 
 ## Sub header too
@@ -41,81 +47,146 @@ The end.
 
 
 class MarkdownStream:
-    live = None
+    """Streaming markdown renderer that progressively displays content with a live updating window.
-    when = 0
+
-    min_delay = 0.050
+    Uses rich.console and rich.live to render markdown content with smooth scrolling
-    live_window = 6
+    and partial updates. Maintains a sliding window of visible content while streaming
+    in new markdown text.
+    """
+
+    live = None  # Rich Live display instance
+    when = 0  # Timestamp of last update
+    min_delay = 1.0 / 20  # Minimum time between updates (20fps)
+    live_window = 6  # Number of lines to keep visible at bottom during streaming
 
     def __init__(self, mdargs=None):
-        self.printed = []
+        """Initialize the markdown stream.
+
+        Args:
+            mdargs (dict, optional): Additional arguments to pass to rich Markdown renderer
+        """
+        self.printed = []  # Stores lines that have already been printed
 
         if mdargs:
             self.mdargs = mdargs
         else:
             self.mdargs = dict()
 
+        # Initialize rich Live display with empty text
         self.live = Live(Text(""), refresh_per_second=1.0 / self.min_delay)
         self.live.start()
 
+    def _render_markdown_to_lines(self, text):
+        """Render markdown text to a list of lines.
+
+        Args:
+            text (str): Markdown text to render
+
+        Returns:
+            list: List of rendered lines with line endings preserved
+        """
+        # Render the markdown to a string buffer
+        string_io = io.StringIO()
+        console = Console(file=string_io, force_terminal=True)
+        markdown = Markdown(text, **self.mdargs)
+        console.print(markdown)
+        output = string_io.getvalue()
+
+        # Split rendered output into lines
+        return output.splitlines(keepends=True)
+
     def __del__(self):
+        """Destructor to ensure Live display is properly cleaned up."""
         if self.live:
             try:
                 self.live.stop()
             except Exception:
-                pass
+                pass  # Ignore any errors during cleanup
 
     def update(self, text, final=False):
+        """Update the displayed markdown content.
+
+        Args:
+            text (str): The markdown text received so far
+            final (bool): If True, this is the final update and we should clean up
+
+        Splits the output into "stable" older lines and the "last few" lines
+        which aren't considered stable. They may shift around as new chunks
+        are appended to the markdown text.
+
+        The stable lines emit to the console above the Live window.
+        The unstable lines emit into the Live window so they can be repainted.
+
+        Markdown going to the console works better in terminal scrollback buffers.
+        The live window doesn't play nice with terminal scrollback.
+        """
         now = time.time()
+        # Throttle updates to maintain smooth rendering
         if not final and now - self.when < self.min_delay:
             return
         self.when = now
 
-        string_io = io.StringIO()
+        # Measure render time and adjust min_delay to maintain smooth rendering
-        console = Console(file=string_io, force_terminal=True)
+        start = time.time()
+        lines = self._render_markdown_to_lines(text)
+        render_time = time.time() - start
 
-        markdown = Markdown(text, **self.mdargs)
+        # Set min_delay to render time plus a small buffer
+        self.min_delay = min(max(render_time * 10, 1.0 / 20), 2)
 
-        console.print(markdown)
-        output = string_io.getvalue()
-
-        lines = output.splitlines(keepends=True)
         num_lines = len(lines)
 
+        # How many lines have "left" the live window and are now considered stable?
+        # Or if final, consider all lines to be stable.
         if not final:
             num_lines -= self.live_window
 
+        # If we have stable content to display...
         if final or num_lines > 0:
+            # How many stable lines do we need to newly show above the live window?
             num_printed = len(self.printed)
-
             show = num_lines - num_printed
 
+            # Skip if no new lines to show above live window
             if show <= 0:
                 return
 
+            # Get the new lines and display them
             show = lines[num_printed:num_lines]
             show = "".join(show)
             show = Text.from_ansi(show)
-            self.live.console.print(show)
+            self.live.console.print(show)  # to the console above the live area
 
+            # Update our record of printed lines
             self.printed = lines[:num_lines]
 
+        # Handle final update cleanup
         if final:
             self.live.update(Text(""))
             self.live.stop()
             self.live = None
-        else:
+            return
+
+        # Update the live window with remaining lines
         rest = lines[num_lines:]
         rest = "".join(rest)
-            # rest = '...\n' + rest
         rest = Text.from_ansi(rest)
         self.live.update(rest)
 
+    def find_minimal_suffix(self, text, match_lines=50):
+        """
+        Splits text into chunks on blank lines "\n\n".
+        """
+
 
 if __name__ == "__main__":
-    _text = 5 * _text
+    with open("aider/io.py", "r") as f:
+        code = f.read()
+    _text = _text_prefix + code + _text_suffix
+    _text = _text * 10
 
     pm = MarkdownStream()
-    for i in range(6, len(_text)):
+    for i in range(6, len(_text), 5):
         pm.update(_text[:i])
         time.sleep(0.01)
 

aider/prompts.py

@@ -5,15 +5,21 @@
 
 # Conventional Commits text adapted from:
 # https://www.conventionalcommits.org/en/v1.0.0/#summary
-commit_system = """You are an expert software engineer.
+commit_system = """You are an expert software engineer that generates concise, \
+one-line Git commit messages based on the provided diffs.
 Review the provided context and diffs which are about to be committed to a git repo.
 Review the diffs carefully.
-Generate a commit message for those changes.
+Generate a one-line commit message for those changes.
-The commit message MUST use the imperative tense.
 The commit message should be structured as follows: <type>: <description>
 Use these for <type>: fix, feat, build, chore, ci, docs, style, refactor, perf, test
-Reply with JUST the commit message, without quotes, comments, questions, etc!
+
-Reply with one line only!
+Ensure the commit message:
+- Starts with the appropriate prefix.
+- Is in the imperative mood (e.g., \"Add feature\" not \"Added feature\" or \"Adding feature\").
+- Does not exceed 72 characters.
+
+Reply only with the one-line commit message, without any additional text, explanations, \
+or line breaks.
 """
 
 # COMMANDS

aider/queries/tree-sitter-language-pack/javascript-tags.scm

@@ -0,0 +1,88 @@
+(
+  (comment)* @doc
+  .
+  (method_definition
+    name: (property_identifier) @name.definition.method) @definition.method
+  (#not-eq? @name.definition.method "constructor")
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.method)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (class
+      name: (_) @name.definition.class)
+    (class_declaration
+      name: (_) @name.definition.class)
+  ] @definition.class
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.class)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (function_expression
+      name: (identifier) @name.definition.function)
+    (function_declaration
+      name: (identifier) @name.definition.function)
+    (generator_function
+      name: (identifier) @name.definition.function)
+    (generator_function_declaration
+      name: (identifier) @name.definition.function)
+  ] @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name.definition.function
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @name.definition.function
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(assignment_expression
+  left: [
+    (identifier) @name.definition.function
+    (member_expression
+      property: (property_identifier) @name.definition.function)
+  ]
+  right: [(arrow_function) (function_expression)]
+) @definition.function
+
+(pair
+  key: (property_identifier) @name.definition.function
+  value: [(arrow_function) (function_expression)]) @definition.function
+
+(
+  (call_expression
+    function: (identifier) @name.reference.call) @reference.call
+  (#not-match? @name.reference.call "^(require)$")
+)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @name.reference.call)
+  arguments: (_) @reference.call)
+
+(new_expression
+  constructor: (_) @name.reference.class) @reference.class

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

@@ -0,0 +1,91 @@
+(class_definition
+  name: (identifier) @name.definition.class) @definition.class
+
+(method_signature
+  (function_signature)) @definition.method
+
+(type_alias
+  (type_identifier) @name.definition.type) @definition.type
+
+(method_signature
+  (getter_signature
+    name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (setter_signature
+    name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (function_signature
+  name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (factory_constructor_signature
+    (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (constructor_signature
+  name: (identifier) @name.definition.method)) @definition.method
+
+(method_signature
+  (operator_signature)) @definition.method
+
+(method_signature) @definition.method
+
+(mixin_declaration
+  (mixin)
+  (identifier) @name.definition.mixin) @definition.mixin
+
+(extension_declaration
+  name: (identifier) @name.definition.extension) @definition.extension
+
+(enum_declaration
+  name: (identifier) @name.definition.enum) @definition.enum
+
+(function_signature
+  name: (identifier) @name.definition.function) @definition.function
+
+(new_expression
+  (type_identifier) @name.reference.class) @reference.class
+
+(initialized_variable_definition
+  name: (identifier)
+  value: (identifier) @name.reference.class
+  value: (selector
+	"!"?
+	(argument_part
+	  (arguments
+	    (argument)*))?)?) @reference.class
+
+(assignment_expression
+  left: (assignable_expression
+		  (identifier)
+		  (unconditional_assignable_selector
+			"."
+			(identifier) @name.reference.call))) @reference.call
+
+(assignment_expression
+  left: (assignable_expression
+		  (identifier)
+		  (conditional_assignable_selector
+			"?."
+			(identifier) @name.reference.call))) @reference.call
+
+((identifier) @name
+ (selector
+    "!"?
+    (conditional_assignable_selector
+      "?." (identifier) @name.reference.call)?
+    (unconditional_assignable_selector
+      "."? (identifier) @name.reference.call)?
+    (argument_part
+      (arguments
+        (argument)*))?)*
+	(cascade_section
+	  (cascade_selector
+		(identifier)) @name.reference.call
+	  (argument_part
+		(arguments
+		  (argument)*))?)?) @reference.call
+
+

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

@@ -0,0 +1,77 @@
+;; Based on https://github.com/tree-sitter-grammars/tree-sitter-hcl/blob/main/make_grammar.js
+;; Which has Apache 2.0 License
+;; tags.scm for Terraform (tree-sitter-hcl)
+
+; === Definitions: Terraform Blocks ===
+(block 
+  (identifier) @block_type
+  (string_lit (template_literal) @resource_type)
+  (string_lit (template_literal) @name.definition.resource)
+  (body) @definition.resource
+) (#eq? @block_type "resource")
+
+(block 
+  (identifier) @block_type
+  (string_lit (template_literal) @name.definition.module)
+  (body) @definition.module
+) (#eq? @block_type "module")
+
+(block 
+  (identifier) @block_type
+  (string_lit (template_literal) @name.definition.variable)
+  (body) @definition.variable
+) (#eq? @block_type "variable")
+
+(block 
+  (identifier) @block_type
+  (string_lit (template_literal) @name.definition.output)
+  (body) @definition.output
+) (#eq? @block_type "output")
+
+(block 
+  (identifier) @block_type
+  (string_lit (template_literal) @name.definition.provider)
+  (body) @definition.provider
+) (#eq? @block_type "provider")
+
+(block 
+  (identifier) @block_type
+  (body 
+    (attribute 
+       (identifier) @name.definition.local 
+       (expression) @definition.local
+    )+
+  )
+) (#eq? @block_type "locals")
+
+; === References: Variables, Locals, Modules, Data, Resources ===
+((variable_expr) @ref_type
+  (get_attr (identifier) @name.reference.variable)
+) @reference.variable
+ (#eq? @ref_type "var")
+
+((variable_expr) @ref_type
+  (get_attr (identifier) @name.reference.local)
+) @reference.local
+ (#eq? @ref_type "local")
+
+((variable_expr) @ref_type
+  (get_attr (identifier) @name.reference.module)
+) @reference.module
+ (#eq? @ref_type "module")
+
+((variable_expr) @ref_type
+  (get_attr (identifier) @data_source_type)
+  (get_attr (identifier) @name.reference.data)
+) @reference.data
+ (#eq? @ref_type "data")
+
+((variable_expr) @resource_type
+  (get_attr (identifier) @name.reference.resource)
+) @reference.resource
+ (#not-eq? @resource_type "var")
+ (#not-eq? @resource_type "local")
+ (#not-eq? @resource_type "module")
+ (#not-eq? @resource_type "data")
+ (#not-eq? @resource_type "provider")
+ (#not-eq? @resource_type "output")

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

@@ -0,0 +1,27 @@
+; Definitions
+
+(class_declaration
+  (type_identifier) @name.definition.class) @definition.class
+
+(function_declaration
+  (simple_identifier) @name.definition.function) @definition.function
+
+(object_declaration
+  (type_identifier) @name.definition.object) @definition.object
+
+; References
+
+(call_expression
+  [
+    (simple_identifier) @name.reference.call
+    (navigation_expression
+      (navigation_suffix
+        (simple_identifier) @name.reference.call))
+  ]) @reference.call
+
+(delegation_specifier
+  [
+    (user_type) @name.reference.type
+    (constructor_invocation
+      (user_type) @name.reference.type)
+  ]) @reference.type

aider/repo.py

@@ -2,15 +2,35 @@ import os
 import time
 from pathlib import Path, PurePosixPath
 
-import git
+try:
+    import git
+
+    ANY_GIT_ERROR = [
+        git.exc.ODBError,
+        git.exc.GitError,
+        git.exc.InvalidGitRepositoryError,
+    ]
+except ImportError:
+    git = None
+    ANY_GIT_ERROR = []
+
 import pathspec
 
 from aider import prompts, utils
-from aider.sendchat import simple_send_with_retries
 
 from .dump import dump  # noqa: F401
 
-ANY_GIT_ERROR = (git.exc.ODBError, git.exc.GitError, OSError, IndexError, BufferError, TypeError)
+ANY_GIT_ERROR += [
+    OSError,
+    IndexError,
+    BufferError,
+    TypeError,
+    ValueError,
+    AttributeError,
+    AssertionError,
+    TimeoutError,
+]
+ANY_GIT_ERROR = tuple(ANY_GIT_ERROR)
 
 
 class GitRepo:
@@ -133,7 +153,7 @@ class GitRepo:
             os.environ["GIT_COMMITTER_NAME"] = committer_name
 
         if aider_edits and self.attribute_author:
-            original_auther_name_env = os.environ.get("GIT_AUTHOR_NAME")
+            original_author_name_env = os.environ.get("GIT_AUTHOR_NAME")
             os.environ["GIT_AUTHOR_NAME"] = committer_name
 
         try:
@@ -153,15 +173,15 @@ class GitRepo:
                     del os.environ["GIT_COMMITTER_NAME"]
 
             if aider_edits and self.attribute_author:
-                if original_auther_name_env is not None:
+                if original_author_name_env is not None:
-                    os.environ["GIT_AUTHOR_NAME"] = original_auther_name_env
+                    os.environ["GIT_AUTHOR_NAME"] = original_author_name_env
                 else:
                     del os.environ["GIT_AUTHOR_NAME"]
 
     def get_rel_repo_dir(self):
         try:
             return os.path.relpath(self.repo.git_dir, os.getcwd())
-        except ValueError:
+        except (ValueError, OSError):
             return self.repo.git_dir
 
     def get_commit_message(self, diffs, context):
@@ -184,9 +204,7 @@ class GitRepo:
             max_tokens = model.info.get("max_input_tokens") or 0
             if max_tokens and num_tokens > max_tokens:
                 continue
-            commit_message = simple_send_with_retries(
+            commit_message = model.simple_send_with_retries(messages)
-                model.name, messages, extra_headers=model.extra_headers
-            )
             if commit_message:
                 break
 
@@ -270,9 +288,17 @@ class GitRepo:
                 files = self.tree_files[commit]
             else:
                 try:
-                    for blob in commit.tree.traverse():
+                    iterator = commit.tree.traverse()
+                    while True:
+                        try:
+                            blob = next(iterator)
                             if blob.type == "blob":  # blob is a file
                                 files.add(blob.path)
+                        except IndexError:
+                            self.io.tool_warning(f"GitRepo: read error skipping {blob.path}")
+                            continue
+                        except StopIteration:
+                            break
                 except ANY_GIT_ERROR as err:
                     self.git_repo_error = err
                     self.io.tool_error(f"Unable to list files in git repo: {err}")
@@ -323,6 +349,15 @@ class GitRepo:
                 lines,
             )
 
+    def git_ignored_file(self, path):
+        if not self.repo:
+            return
+        try:
+            if self.repo.ignored(path):
+                return True
+        except ANY_GIT_ERROR:
+            return False
+
     def ignored_file(self, fname):
         self.refresh_aider_ignore()
 
@@ -335,8 +370,15 @@ class GitRepo:
 
     def ignored_file_raw(self, fname):
         if self.subtree_only:
+            try:
                 fname_path = Path(self.normalize_path(fname))
                 cwd_path = Path.cwd().resolve().relative_to(Path(self.root).resolve())
+            except ValueError:
+                # Issue #1524
+                # ValueError: 'C:\\dev\\squid-certbot' is not in the subpath of
+                # 'C:\\dev\\squid-certbot'
+                # Clearly, fname is not under cwd... so ignore it
+                return True
 
             if cwd_path not in fname_path.parents and fname_path != cwd_path:
                 return True

aider/repomap.py

@@ -2,6 +2,7 @@ import colorsys
 import math
 import os
 import random
+import shutil
 import sqlite3
 import sys
 import time
@@ -22,16 +23,20 @@ from aider.utils import Spinner
 
 # tree_sitter is throwing a FutureWarning
 warnings.simplefilter("ignore", category=FutureWarning)
-from tree_sitter_languages import get_language, get_parser  # noqa: E402
+from grep_ast.tsl import USING_TSL_PACK, get_language, get_parser  # noqa: E402
 
 Tag = namedtuple("Tag", "rel_fname fname line name kind".split())
 
 
-SQLITE_ERRORS = (sqlite3.OperationalError, sqlite3.DatabaseError)
+SQLITE_ERRORS = (sqlite3.OperationalError, sqlite3.DatabaseError, OSError)
+
+
+CACHE_VERSION = 3
+if USING_TSL_PACK:
+    CACHE_VERSION = 4
 
 
 class RepoMap:
-    CACHE_VERSION = 3
     TAGS_CACHE_DIR = f".aider.tags.cache.v{CACHE_VERSION}"
 
     warned_files = set()
@@ -166,13 +171,52 @@ class RepoMap:
             # Just return the full fname.
             return fname
 
+    def tags_cache_error(self, original_error=None):
+        """Handle SQLite errors by trying to recreate cache, falling back to dict if needed"""
+
+        if self.verbose and original_error:
+            self.io.tool_warning(f"Tags cache error: {str(original_error)}")
+
+        if isinstance(getattr(self, "TAGS_CACHE", None), dict):
+            return
+
+        path = Path(self.root) / self.TAGS_CACHE_DIR
+
+        # Try to recreate the cache
+        try:
+            # Delete existing cache dir
+            if path.exists():
+                shutil.rmtree(path)
+
+            # Try to create new cache
+            new_cache = Cache(path)
+
+            # Test that it works
+            test_key = "test"
+            new_cache[test_key] = "test"
+            _ = new_cache[test_key]
+            del new_cache[test_key]
+
+            # If we got here, the new cache works
+            self.TAGS_CACHE = new_cache
+            return
+
+        except SQLITE_ERRORS as e:
+            # If anything goes wrong, warn and fall back to dict
+            self.io.tool_warning(
+                f"Unable to use tags cache at {path}, falling back to memory cache"
+            )
+            if self.verbose:
+                self.io.tool_warning(f"Cache recreation error: {str(e)}")
+
+        self.TAGS_CACHE = dict()
+
     def load_tags_cache(self):
         path = Path(self.root) / self.TAGS_CACHE_DIR
         try:
             self.TAGS_CACHE = Cache(path)
-        except SQLITE_ERRORS:
+        except SQLITE_ERRORS as e:
-            self.io.tool_warning(f"Unable to use tags cache, delete {path} to resolve.")
+            self.tags_cache_error(e)
-            self.TAGS_CACHE = dict()
 
     def save_tags_cache(self):
         pass
@@ -190,8 +234,17 @@ class RepoMap:
             return []
 
         cache_key = fname
+        try:
             val = self.TAGS_CACHE.get(cache_key)  # Issue #1308
+        except SQLITE_ERRORS as e:
+            self.tags_cache_error(e)
+            val = self.TAGS_CACHE.get(cache_key)
+
         if val is not None and val.get("mtime") == file_mtime:
+            try:
+                return self.TAGS_CACHE[cache_key]["data"]
+            except SQLITE_ERRORS as e:
+                self.tags_cache_error(e)
                 return self.TAGS_CACHE[cache_key]["data"]
 
         # miss!
@@ -201,8 +254,9 @@ class RepoMap:
         try:
             self.TAGS_CACHE[cache_key] = {"mtime": file_mtime, "data": data}
             self.save_tags_cache()
-        except SQLITE_ERRORS:
+        except SQLITE_ERRORS as e:
-            pass
+            self.tags_cache_error(e)
+            self.TAGS_CACHE[cache_key] = {"mtime": file_mtime, "data": data}
 
         return data
 
@@ -232,10 +286,15 @@ class RepoMap:
         query = language.query(query_scm)
         captures = query.captures(tree.root_node)
 
-        captures = list(captures)
-
         saw = set()
-        for node, tag in captures:
+        if USING_TSL_PACK:
+            all_nodes = []
+            for tag, nodes in captures.items():
+                all_nodes += [(node, tag) for node in nodes]
+        else:
+            all_nodes = list(captures)
+
+        for node, tag in all_nodes:
             if tag.startswith("name.definition."):
                 kind = "def"
             elif tag.startswith("name.reference."):
@@ -302,7 +361,13 @@ class RepoMap:
         # https://networkx.org/documentation/stable/_modules/networkx/algorithms/link_analysis/pagerank_alg.html#pagerank
         personalize = 100 / len(fnames)
 
-        if len(fnames) - len(self.TAGS_CACHE) > 100:
+        try:
+            cache_size = len(self.TAGS_CACHE)
+        except SQLITE_ERRORS as e:
+            self.tags_cache_error(e)
+            cache_size = len(self.TAGS_CACHE)
+
+        if len(fnames) - cache_size > 100:
             self.io.tool_output(
                 "Initial repo scan can be slow in larger repos, but only happens once."
             )
@@ -312,6 +377,8 @@ class RepoMap:
             showing_bar = False
 
         for fname in fnames:
+            if self.verbose:
+                self.io.tool_output(f"Processing {fname}")
             if progress and not showing_bar:
                 progress()
 
@@ -397,6 +464,10 @@ class RepoMap:
 
         try:
             ranked = nx.pagerank(G, weight="weight", **pers_args)
+        except ZeroDivisionError:
+            # Issue #1536
+            try:
+                ranked = nx.pagerank(G, weight="weight")
             except ZeroDivisionError:
                 return []
 
@@ -415,7 +486,9 @@ class RepoMap:
                 ranked_definitions[(dst, ident)] += data["rank"]
 
         ranked_tags = []
-        ranked_definitions = sorted(ranked_definitions.items(), reverse=True, key=lambda x: x[1])
+        ranked_definitions = sorted(
+            ranked_definitions.items(), reverse=True, key=lambda x: (x[1], x[0])
+        )
 
         # dump(ranked_definitions)
 
@@ -451,11 +524,18 @@ class RepoMap:
         force_refresh=False,
     ):
         # Create a cache key
-        cache_key = (
+        cache_key = [
             tuple(sorted(chat_fnames)) if chat_fnames else None,
             tuple(sorted(other_fnames)) if other_fnames else None,
             max_map_tokens,
-        )
+        ]
+
+        if self.refresh == "auto":
+            cache_key += [
+                tuple(sorted(mentioned_fnames)) if mentioned_fnames else None,
+                tuple(sorted(mentioned_idents)) if mentioned_idents else None,
+            ]
+        cache_key = tuple(cache_key)
 
         use_cache = False
         if not force_refresh:
@@ -534,7 +614,7 @@ class RepoMap:
 
         self.tree_cache = dict()
 
-        middle = min(max_map_tokens // 25, num_tags)
+        middle = min(int(max_map_tokens // 25), num_tags)
         while lower_bound <= upper_bound:
             # dump(lower_bound, middle, upper_bound)
 
@@ -557,7 +637,7 @@ class RepoMap:
             else:
                 upper_bound = middle - 1
 
-            middle = (lower_bound + upper_bound) // 2
+            middle = int((lower_bound + upper_bound) // 2)
 
         spin.end()
         return best_tree
@@ -661,8 +741,27 @@ def get_random_color():
 
 def get_scm_fname(lang):
     # Load the tags queries
+    if USING_TSL_PACK:
+        subdir = "tree-sitter-language-pack"
         try:
-        return resources.files(__package__).joinpath("queries", f"tree-sitter-{lang}-tags.scm")
+            path = resources.files(__package__).joinpath(
+                "queries",
+                subdir,
+                f"{lang}-tags.scm",
+            )
+            if path.exists():
+                return path
+        except KeyError:
+            pass
+
+    # Fall back to tree-sitter-languages
+    subdir = "tree-sitter-languages"
+    try:
+        return resources.files(__package__).joinpath(
+            "queries",
+            subdir,
+            f"{lang}-tags.scm",
+        )
     except KeyError:
         return
 

aider/resources/__init__.py

@@ -0,0 +1,3 @@
+# This ensures that importlib_resources.files("aider.resources")
+# doesn't raise ImportError, even if there are no other files in this
+# dir.

aider/resources/model-metadata.json

@@ -0,0 +1,134 @@
+{
+    "deepseek-reasoner": {
+        "max_tokens": 8192,
+        "max_input_tokens": 64000,
+        "max_output_tokens": 8192,
+        "input_cost_per_token": 0.00000055,
+        "input_cost_per_token_cache_hit": 0.00000014,
+        "cache_read_input_token_cost": 0.00000014,
+        "cache_creation_input_token_cost": 0.0,
+        "output_cost_per_token": 0.00000219,
+        "litellm_provider": "deepseek",
+        "mode": "chat",
+        //"supports_function_calling": true, 
+        "supports_assistant_prefill": true,
+        //"supports_tool_choice": true,
+        "supports_prompt_caching": true
+    },
+    "openrouter/deepseek/deepseek-r1": {
+        "max_tokens": 8192,
+        "max_input_tokens": 64000,
+        "max_output_tokens": 8192,
+        "input_cost_per_token": 0.00000055,
+        "input_cost_per_token_cache_hit": 0.00000014,
+        "cache_read_input_token_cost": 0.00000014,
+        "cache_creation_input_token_cost": 0.0,
+        "output_cost_per_token": 0.00000219,
+        "litellm_provider": "openrouter",
+        "mode": "chat",
+        //"supports_function_calling": true, 
+        "supports_assistant_prefill": true,
+        //"supports_tool_choice": true,
+        "supports_prompt_caching": true
+    },
+    "openrouter/deepseek/deepseek-r1:free": {
+        "max_tokens": 8192,
+        "max_input_tokens": 64000,
+        "max_output_tokens": 8192,
+        "input_cost_per_token": 0.0,
+        "input_cost_per_token_cache_hit": 0.0,
+        "cache_read_input_token_cost": 0.00,
+        "cache_creation_input_token_cost": 0.0,
+        "output_cost_per_token": 0.0,
+        "litellm_provider": "openrouter",
+        "mode": "chat",
+        //"supports_function_calling": true, 
+        "supports_assistant_prefill": true,
+        //"supports_tool_choice": true,
+        "supports_prompt_caching": true
+    },
+    "fireworks_ai/accounts/fireworks/models/deepseek-r1": {
+        "max_tokens": 160000,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 20480,
+        "litellm_provider": "fireworks_ai",
+        "input_cost_per_token": 0.000008,
+        "output_cost_per_token": 0.000008,
+        "mode": "chat",
+    },
+    "fireworks_ai/accounts/fireworks/models/deepseek-v3": {
+        "max_tokens": 128000,
+        "max_input_tokens": 100000,
+        "max_output_tokens": 8192,
+        "litellm_provider": "fireworks_ai",
+        "input_cost_per_token": 0.0000009,
+        "output_cost_per_token": 0.0000009,
+        "mode": "chat",
+    },
+    "o3-mini": {
+        "max_tokens": 100000,
+        "max_input_tokens": 200000,
+        "max_output_tokens": 100000,
+        "input_cost_per_token": 0.0000011,
+        "output_cost_per_token": 0.0000044,
+        "cache_read_input_token_cost": 0.00000055,
+        "litellm_provider": "openai",
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_vision": true,
+        "supports_prompt_caching": true,
+        "supports_system_messages": true,
+        "supports_response_schema": true
+    },
+    "openrouter/openai/o3-mini": {
+        "max_tokens": 100000,
+        "max_input_tokens": 200000,
+        "max_output_tokens": 100000,
+        "input_cost_per_token": 0.0000011,
+        "output_cost_per_token": 0.0000044,
+        "cache_read_input_token_cost": 0.00000055,
+        "litellm_provider": "openrouter",
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_vision": true,
+        "supports_prompt_caching": true,
+        "supports_system_messages": true,
+        "supports_response_schema": true
+    },
+    "openrouter/openai/o3-mini-high": {
+        "max_tokens": 100000,
+        "max_input_tokens": 200000,
+        "max_output_tokens": 100000,
+        "input_cost_per_token": 0.0000011,
+        "output_cost_per_token": 0.0000044,
+        "cache_read_input_token_cost": 0.00000055,
+        "litellm_provider": "openrouter",
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_vision": true,
+        "supports_prompt_caching": true,
+        "supports_system_messages": true,
+        "supports_response_schema": true
+    },
+    "openrouter/openai/gpt-4o-mini": {
+        "max_tokens": 16384,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 16384,
+        "input_cost_per_token": 0.00000015,
+        "output_cost_per_token": 0.00000060,
+        "input_cost_per_token_batches": 0.000000075,
+        "output_cost_per_token_batches": 0.00000030,
+        "cache_read_input_token_cost": 0.000000075,
+        "litellm_provider": "openrouter",
+        "mode": "chat",
+        "supports_function_calling": true,
+        "supports_parallel_function_calling": true,
+        "supports_response_schema": true,
+        "supports_vision": true,
+        "supports_prompt_caching": true,
+        "supports_system_messages": true
+    },
+}

aider/resources/model-settings.yml

@@ -0,0 +1,678 @@
+- name: gpt-3.5-turbo
+  weak_model_name: gpt-4o-mini
+  reminder: sys
+
+- name: gpt-3.5-turbo-0125
+  weak_model_name: gpt-4o-mini
+  reminder: sys
+
+- name: gpt-3.5-turbo-1106
+  weak_model_name: gpt-4o-mini
+  reminder: sys
+
+- name: gpt-3.5-turbo-0613
+  weak_model_name: gpt-4o-mini
+  reminder: sys
+
+- name: gpt-3.5-turbo-16k-0613
+  weak_model_name: gpt-4o-mini
+  reminder: sys
+
+- name: gpt-4-turbo-2024-04-09
+  edit_format: udiff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+
+- name: gpt-4-turbo
+  edit_format: udiff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+
+- name: openai/gpt-4o
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+  editor_edit_format: editor-diff
+
+- name: openai/gpt-4o-2024-08-06
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: gpt-4o-2024-08-06
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: gpt-4o-2024-11-20
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: openai/gpt-4o-2024-11-20
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: gpt-4o
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+  editor_edit_format: editor-diff
+
+- name: gpt-4o-mini
+  weak_model_name: gpt-4o-mini
+  lazy: true
+  reminder: sys
+
+- name: openai/gpt-4o-mini
+  weak_model_name: openai/gpt-4o-mini
+  lazy: true
+  reminder: sys
+
+- name: gpt-4-0125-preview
+  edit_format: udiff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: gpt-4-1106-preview
+  edit_format: udiff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+
+- name: gpt-4-vision-preview
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  reminder: sys
+
+- name: gpt-4-0314
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: gpt-4-0613
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  reminder: sys
+
+- name: gpt-4-32k-0613
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  reminder: sys
+
+- name: claude-3-opus-20240229
+  edit_format: diff
+  weak_model_name: claude-3-5-haiku-20241022
+  use_repo_map: true
+
+- name: openrouter/anthropic/claude-3-opus
+  edit_format: diff
+  weak_model_name: openrouter/anthropic/claude-3-5-haiku
+  use_repo_map: true
+
+- name: claude-3-sonnet-20240229
+  weak_model_name: claude-3-5-haiku-20241022
+
+- name: claude-3-5-sonnet-20240620
+  edit_format: diff
+  weak_model_name: claude-3-5-haiku-20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: claude-3-5-sonnet-20240620
+  editor_edit_format: editor-diff
+
+- name: anthropic/claude-3-5-sonnet-20240620
+  edit_format: diff
+  weak_model_name: anthropic/claude-3-5-haiku-20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: anthropic/claude-3-5-sonnet-20240620
+  editor_edit_format: editor-diff
+
+- name: anthropic/claude-3-5-sonnet-20241022
+  edit_format: diff
+  weak_model_name: anthropic/claude-3-5-haiku-20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: anthropic/claude-3-5-sonnet-20241022
+  editor_edit_format: editor-diff
+
+- name: bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0
+  edit_format: diff
+  weak_model_name: bedrock/anthropic.claude-3-5-haiku-20241022-v1:0
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0
+  editor_edit_format: editor-diff
+
+- name: anthropic/claude-3-5-sonnet-latest
+  edit_format: diff
+  weak_model_name: anthropic/claude-3-5-haiku-20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: anthropic/claude-3-5-sonnet-20241022
+  editor_edit_format: editor-diff
+
+- name: claude-3-5-sonnet-20241022
+  edit_format: diff
+  weak_model_name: claude-3-5-haiku-20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: claude-3-5-sonnet-20241022
+  editor_edit_format: editor-diff
+
+- name: anthropic/claude-3-haiku-20240307
+  weak_model_name: anthropic/claude-3-haiku-20240307
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+  cache_control: true
+
+- name: anthropic/claude-3-5-haiku-20241022
+  edit_format: diff
+  weak_model_name: anthropic/claude-3-5-haiku-20241022
+  use_repo_map: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+  cache_control: true
+
+- name: bedrock/anthropic.claude-3-5-haiku-20241022-v1:0
+  edit_format: diff
+  weak_model_name: bedrock/anthropic.claude-3-5-haiku-20241022-v1:0
+  use_repo_map: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+  cache_control: true
+
+- name: claude-3-5-haiku-20241022
+  edit_format: diff
+  weak_model_name: claude-3-5-haiku-20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+  cache_control: true
+
+- name: vertex_ai/claude-3-5-haiku@20241022
+  edit_format: diff
+  weak_model_name: vertex_ai/claude-3-5-haiku@20241022
+  use_repo_map: true
+  extra_params:
+    max_tokens: 4096
+
+- name: claude-3-haiku-20240307
+  weak_model_name: claude-3-haiku-20240307
+  examples_as_sys_msg: true
+  extra_params:
+    extra_headers:
+      anthropic-beta: prompt-caching-2024-07-31,pdfs-2024-09-25
+  cache_control: true
+
+- name: openrouter/anthropic/claude-3.5-sonnet
+  edit_format: diff
+  weak_model_name: openrouter/anthropic/claude-3-5-haiku
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: openrouter/anthropic/claude-3.5-sonnet
+  editor_edit_format: editor-diff
+
+- name: openrouter/anthropic/claude-3.5-sonnet:beta
+  edit_format: diff
+  weak_model_name: openrouter/anthropic/claude-3-5-haiku:beta
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  cache_control: true
+  editor_model_name: openrouter/anthropic/claude-3.5-sonnet:beta
+  editor_edit_format: editor-diff
+
+- name: vertex_ai/claude-3-5-sonnet@20240620
+  edit_format: diff
+  weak_model_name: vertex_ai/claude-3-5-haiku@20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  editor_model_name: vertex_ai/claude-3-5-sonnet@20240620
+  editor_edit_format: editor-diff
+
+- name: vertex_ai/claude-3-5-sonnet-v2@20241022
+  edit_format: diff
+  weak_model_name: vertex_ai/claude-3-5-haiku@20241022
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  editor_model_name: vertex_ai/claude-3-5-sonnet-v2@20241022
+  editor_edit_format: editor-diff
+
+- name: vertex_ai/claude-3-opus@20240229
+  edit_format: diff
+  weak_model_name: vertex_ai/claude-3-5-haiku@20241022
+  use_repo_map: true
+
+- name: vertex_ai/claude-3-sonnet@20240229
+  weak_model_name: vertex_ai/claude-3-5-haiku@20241022
+
+- name: command-r-plus
+  weak_model_name: command-r-plus
+  use_repo_map: true
+
+- name: command-r-08-2024
+  weak_model_name: command-r-08-2024
+  use_repo_map: true
+
+- name: command-r-plus-08-2024
+  weak_model_name: command-r-plus-08-2024
+  use_repo_map: true
+
+- name: groq/llama3-70b-8192
+  edit_format: diff
+  weak_model_name: groq/llama3-8b-8192
+  examples_as_sys_msg: true
+
+- name: openrouter/meta-llama/llama-3-70b-instruct
+  edit_format: diff
+  weak_model_name: openrouter/meta-llama/llama-3-70b-instruct
+  examples_as_sys_msg: true
+
+- name: gemini/gemini-1.5-pro-002
+  edit_format: diff
+  use_repo_map: true
+
+- name: gemini/gemini-1.5-flash-002
+
+- name: gemini/gemini-1.5-pro
+  edit_format: diff-fenced
+  use_repo_map: true
+
+- name: gemini/gemini-1.5-pro-latest
+  edit_format: diff-fenced
+  use_repo_map: true
+
+- name: gemini/gemini-1.5-pro-exp-0827
+  edit_format: diff-fenced
+  use_repo_map: true
+
+- name: gemini/gemini-exp-1206
+  edit_format: diff
+  use_repo_map: true
+
+- name: gemini/gemini-exp-1114
+  edit_format: diff
+  use_repo_map: true
+
+- name: gemini/gemini-exp-1121
+  edit_format: diff
+  use_repo_map: true
+
+- name: vertex_ai/gemini-pro-experimental
+  edit_format: diff-fenced
+  use_repo_map: true
+
+- name: gemini/gemini-1.5-flash-exp-0827
+
+- name: gemini/gemini-2.0-flash-exp
+  edit_format: diff
+  use_repo_map: true
+
+- name: gemini/gemini-2.0-flash
+  edit_format: diff
+  use_repo_map: true
+
+- name: openrouter/deepseek/deepseek-r1
+  edit_format: diff
+  weak_model_name: openrouter/deepseek/deepseek-chat
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+  use_temperature: false
+  editor_model_name: openrouter/deepseek/deepseek-chat
+  editor_edit_format: editor-diff
+
+- name: openrouter/deepseek/deepseek-r1:free
+  edit_format: diff
+  weak_model_name: openrouter/deepseek/deepseek-r1:free
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+  use_temperature: false
+  editor_model_name: openrouter/deepseek/deepseek-r1:free
+  editor_edit_format: editor-diff
+
+- name: deepseek/deepseek-reasoner
+  edit_format: diff
+  weak_model_name: deepseek/deepseek-chat
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+  use_temperature: false
+  editor_model_name: deepseek/deepseek-chat
+  editor_edit_format: editor-diff
+
+- name: deepseek/deepseek-chat
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+
+- name: deepseek/deepseek-coder
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+
+- name: deepseek-chat
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+
+- name: deepseek-coder
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+
+- name: openrouter/deepseek/deepseek-coder
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: openrouter/deepseek/deepseek-chat
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+
+- name: openrouter/openai/gpt-4o
+  edit_format: diff
+  weak_model_name: openrouter/openai/gpt-4o-mini
+  use_repo_map: true
+  lazy: true
+  reminder: sys
+  examples_as_sys_msg: true
+  editor_edit_format: editor-diff
+
+- name: openai/o1-mini
+  weak_model_name: openai/gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  editor_model_name: openai/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: azure/o1-mini
+  weak_model_name: azure/gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  editor_model_name: azure/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: o1-mini
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  editor_model_name: gpt-4o
+  editor_edit_format: editor-diff
+
+- name: openai/o1-preview
+  edit_format: diff
+  weak_model_name: openai/gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  editor_model_name: openai/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: azure/o1-preview
+  edit_format: diff
+  weak_model_name: azure/gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  editor_model_name: azure/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: azure/o1
+  edit_format: diff
+  weak_model_name: azure/gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  streaming: false
+  editor_model_name: azure/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: o1-preview
+  edit_format: architect
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  editor_model_name: gpt-4o
+  editor_edit_format: editor-diff
+
+- name: openrouter/openai/o1-mini
+  weak_model_name: openrouter/openai/gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  streaming: false
+  editor_model_name: openrouter/openai/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: openrouter/openai/o1-preview
+  edit_format: diff
+  weak_model_name: openrouter/openai/gpt-4o-mini
+  use_repo_map: true
+  use_system_prompt: false
+  use_temperature: false
+  streaming: false
+  editor_model_name: openrouter/openai/gpt-4o
+  editor_edit_format: editor-diff
+
+- name: openrouter/openai/o1
+  edit_format: diff
+  weak_model_name: openrouter/openai/gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  streaming: false
+  editor_model_name: openrouter/openai/gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+- name: openai/o1
+  edit_format: diff
+  weak_model_name: openai/gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  streaming: false
+  editor_model_name: openai/gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+- name: o1
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  streaming: false
+  editor_model_name: gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+- name: openrouter/qwen/qwen-2.5-coder-32b-instruct
+  edit_format: diff
+  weak_model_name: openrouter/qwen/qwen-2.5-coder-32b-instruct
+  use_repo_map: true
+  editor_model_name: openrouter/qwen/qwen-2.5-coder-32b-instruct
+  editor_edit_format: editor-diff
+
+- name: openrouter/deepseek/deepseek-r1-distill-llama-70b
+  edit_format: diff
+  weak_model_name: openrouter/deepseek/deepseek-chat
+  use_repo_map: true
+  examples_as_sys_msg: true
+  extra_params:
+    max_tokens: 8192
+  caches_by_default: true
+  use_temperature: false
+  editor_model_name: openrouter/deepseek/deepseek-chat
+  editor_edit_format: editor-diff
+  
+- name: fireworks_ai/accounts/fireworks/models/deepseek-r1
+  edit_format: diff
+  weak_model_name: fireworks_ai/accounts/fireworks/models/deepseek-v3
+  use_repo_map: true
+  use_temperature: false
+  streaming: true
+  editor_model_name: fireworks_ai/accounts/fireworks/models/deepseek-v3
+  editor_edit_format: editor-diff
+  remove_reasoning: think
+  extra_params:
+      max_tokens: 160000
+
+- name: fireworks_ai/accounts/fireworks/models/deepseek-v3
+  edit_format: diff
+  use_repo_map: true
+  reminder: sys
+  examples_as_sys_msg: true
+  extra_params:
+      max_tokens: 128000
+
+- name: openai/o3-mini
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  editor_model_name: gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+  
+- name: o3-mini
+  edit_format: diff
+  weak_model_name: gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  editor_model_name: gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+- name: openrouter/openai/o3-mini
+  edit_format: diff
+  weak_model_name: openrouter/openai/gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  editor_model_name: openrouter/openai/gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+- name: openrouter/openai/o3-mini-high
+  edit_format: diff
+  weak_model_name: openrouter/openai/gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  editor_model_name: openrouter/openai/gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+- name: azure/o3-mini
+  edit_format: diff
+  weak_model_name: azure/gpt-4o-mini
+  use_repo_map: true
+  use_temperature: false
+  editor_model_name: azure/gpt-4o
+  editor_edit_format: editor-diff
+  system_prompt_prefix: "Formatting re-enabled. "
+
+  

aider/run_cmd.py

@@ -8,12 +8,12 @@ import pexpect
 import psutil
 
 
-def run_cmd(command, verbose=False, error_print=None):
+def run_cmd(command, verbose=False, error_print=None, cwd=None):
     try:
         if sys.stdin.isatty() and hasattr(pexpect, "spawn") and platform.system() != "Windows":
-            return run_cmd_pexpect(command, verbose)
+            return run_cmd_pexpect(command, verbose, cwd)
 
-        return run_cmd_subprocess(command, verbose)
+        return run_cmd_subprocess(command, verbose, cwd)
     except OSError as e:
         error_message = f"Error occurred while running command '{command}': {str(e)}"
         if error_print is None:
@@ -39,7 +39,7 @@ def get_windows_parent_process_name():
         return None
 
 
-def run_cmd_subprocess(command, verbose=False):
+def run_cmd_subprocess(command, verbose=False, cwd=None, encoding=sys.stdout.encoding):
     if verbose:
         print("Using run_cmd_subprocess:", command)
 
@@ -65,10 +65,11 @@ def run_cmd_subprocess(command, verbose=False):
             stderr=subprocess.STDOUT,
             text=True,
             shell=True,
-            encoding=sys.stdout.encoding,
+            encoding=encoding,
             errors="replace",
             bufsize=0,  # Set bufsize to 0 for unbuffered output
             universal_newlines=True,
+            cwd=cwd,
         )
 
         output = []
@@ -85,7 +86,7 @@ def run_cmd_subprocess(command, verbose=False):
         return 1, str(e)
 
 
-def run_cmd_pexpect(command, verbose=False):
+def run_cmd_pexpect(command, verbose=False, cwd=None):
     """
     Run a shell command interactively using pexpect, capturing all output.
 
@@ -112,12 +113,12 @@ def run_cmd_pexpect(command, verbose=False):
             # Use the shell from SHELL environment variable
             if verbose:
                 print("Running pexpect.spawn with shell:", shell)
-            child = pexpect.spawn(shell, args=["-c", command], encoding="utf-8")
+            child = pexpect.spawn(shell, args=["-i", "-c", command], encoding="utf-8", cwd=cwd)
         else:
             # Fall back to spawning the command directly
             if verbose:
                 print("Running pexpect.spawn without shell.")
-            child = pexpect.spawn(command, encoding="utf-8")
+            child = pexpect.spawn(command, encoding="utf-8", cwd=cwd)
 
         # Transfer control to the user, capturing output
         child.interact(output_filter=output_callback)

aider/scrape.py

@@ -185,7 +185,9 @@ class Scraper:
 
         headers = {"User-Agent": f"Mozilla./5.0 ({aider_user_agent})"}
         try:
-            with httpx.Client(headers=headers, verify=self.verify_ssl) as client:
+            with httpx.Client(
+                headers=headers, verify=self.verify_ssl, follow_redirects=True
+            ) as client:
                 response = client.get(url)
                 response.raise_for_status()
                 return response.text, response.headers.get("content-type", "").split(";")[0]

aider/sendchat.py

@@ -1,110 +1,61 @@
-import hashlib
-import json
-
-import backoff
-
 from aider.dump import dump  # noqa: F401
-from aider.llm import litellm
+from aider.utils import format_messages
-
-# from diskcache import Cache
 
 
-CACHE_PATH = "~/.aider.send.cache.v1"
+def sanity_check_messages(messages):
-CACHE = None
+    """Check if messages alternate between user and assistant roles.
-# CACHE = Cache(CACHE_PATH)
+    System messages can be interspersed anywhere.
+    Also verifies the last non-system message is from the user.
+    Returns True if valid, False otherwise."""
+    last_role = None
+    last_non_system_role = None
+
+    for msg in messages:
+        role = msg.get("role")
+        if role == "system":
+            continue
+
+        if last_role and role == last_role:
+            turns = format_messages(messages)
+            raise ValueError("Messages don't properly alternate user/assistant:\n\n" + turns)
+
+        last_role = role
+        last_non_system_role = role
+
+    # Ensure last non-system message is from user
+    return last_non_system_role == "user"
 
 
-def retry_exceptions():
+def ensure_alternating_roles(messages):
-    import httpx
+    """Ensure messages alternate between 'assistant' and 'user' roles.
 
-    return (
+    Inserts empty messages of the opposite role when consecutive messages
-        httpx.ConnectError,
+    of the same role are found.
-        httpx.RemoteProtocolError,
-        httpx.ReadTimeout,
-        litellm.exceptions.APIConnectionError,
-        litellm.exceptions.APIError,
-        litellm.exceptions.RateLimitError,
-        litellm.exceptions.ServiceUnavailableError,
-        litellm.exceptions.Timeout,
-        litellm.exceptions.InternalServerError,
-        litellm.llms.anthropic.chat.AnthropicError,
-    )
 
+    Args:
+        messages: List of message dictionaries with 'role' and 'content' keys.
 
-def lazy_litellm_retry_decorator(func):
+    Returns:
-    def wrapper(*args, **kwargs):
+        List of messages with alternating roles.
-        decorated_func = backoff.on_exception(
+    """
-            backoff.expo,
+    if not messages:
-            retry_exceptions(),
+        return messages
-            max_time=60,
-            on_backoff=lambda details: print(
-                f"{details.get('exception', 'Exception')}\nRetry in {details['wait']:.1f} seconds."
-            ),
-        )(func)
-        return decorated_func(*args, **kwargs)
 
-    return wrapper
+    fixed_messages = []
+    prev_role = None
 
+    for msg in messages:
+        current_role = msg.get("role")  # Get 'role', None if missing
 
-def send_completion(
+        # If current role same as previous, insert empty message
-    model_name,
+        # of the opposite role
-    messages,
+        if current_role == prev_role:
-    functions,
+            if current_role == "user":
-    stream,
+                fixed_messages.append({"role": "assistant", "content": ""})
-    temperature=0,
+            else:
-    extra_headers=None,
+                fixed_messages.append({"role": "user", "content": ""})
-    max_tokens=None,
-):
-    from aider.llm import litellm
 
-    kwargs = dict(
+        fixed_messages.append(msg)
-        model=model_name,
+        prev_role = current_role
-        messages=messages,
-        stream=stream,
-    )
-    if temperature is not None:
-        kwargs["temperature"] = temperature
 
-    if functions is not None:
+    return fixed_messages
-        function = functions[0]
-        kwargs["tools"] = [dict(type="function", function=function)]
-        kwargs["tool_choice"] = {"type": "function", "function": {"name": function["name"]}}
-    if extra_headers is not None:
-        kwargs["extra_headers"] = extra_headers
-    if max_tokens is not None:
-        kwargs["max_tokens"] = max_tokens
-
-    key = json.dumps(kwargs, sort_keys=True).encode()
-
-    # Generate SHA1 hash of kwargs and append it to chat_completion_call_hashes
-    hash_object = hashlib.sha1(key)
-
-    if not stream and CACHE is not None and key in CACHE:
-        return hash_object, CACHE[key]
-
-    # del kwargs['stream']
-
-    res = litellm.completion(**kwargs)
-
-    if not stream and CACHE is not None:
-        CACHE[key] = res
-
-    return hash_object, res
-
-
-@lazy_litellm_retry_decorator
-def simple_send_with_retries(model_name, messages, extra_headers=None):
-    try:
-        kwargs = {
-            "model_name": model_name,
-            "messages": messages,
-            "functions": None,
-            "stream": False,
-        }
-        if extra_headers is not None:
-            kwargs["extra_headers"] = extra_headers
-
-        _hash, response = send_completion(**kwargs)
-        return response.choices[0].message.content
-    except (AttributeError, litellm.exceptions.BadRequestError):
-        return

aider/special.py

@@ -41,6 +41,7 @@ ROOT_IMPORTANT_FILES = [
     "composer.lock",
     "pom.xml",
     "build.gradle",
+    "build.gradle.kts",
     "build.sbt",
     "go.mod",
     "go.sum",

aider/urls.py

@@ -8,4 +8,10 @@ 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/paul-gauthier/aider/issues/new"
+github_issues = "https://github.com/Aider-AI/aider/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"
+release_notes = "https://aider.chat/HISTORY.html#release-notes"
+edit_formats = "https://aider.chat/docs/more/edit-formats.html"
+models_and_keys = "https://aider.chat/docs/troubleshooting/models-and-keys.html"

aider/utils.py

@@ -2,18 +2,15 @@ import itertools
 import os
 import platform
 import shlex
-import shutil
 import subprocess
 import sys
 import tempfile
 import time
 from pathlib import Path
 
-import git
-
 from aider.dump import dump  # noqa: F401
 
-IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp"}
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp", ".pdf"}
 
 
 class IgnorantTemporaryDirectory:
@@ -74,6 +71,8 @@ class GitTemporaryDirectory(ChdirTemporaryDirectory):
 
 
 def make_repo(path=None):
+    import git
+
     if not path:
         path = "."
     repo = git.Repo.init(path)
@@ -113,7 +112,7 @@ def format_messages(messages, title=None):
         output.append(f"{title.upper()} {'*' * 50}")
 
     for msg in messages:
-        output.append("")
+        output.append("-------")
         role = msg["role"].upper()
         content = msg.get("content")
         if isinstance(content, list):  # Handle list content (e.g., image messages)
@@ -194,28 +193,15 @@ def split_chat_history_markdown(text, include_tool=False):
     return messages
 
 
-# Copied from pip, MIT license
-# https://github.com/pypa/pip/blob/b989e6ef04810bbd4033a3683020bd4ddcbdb627/src/pip/_internal/utils/entrypoints.py#L73
-def get_best_invocation_for_this_python() -> str:
-    """Try to figure out the best way to invoke the current Python."""
-    exe = sys.executable
-    exe_name = os.path.basename(exe)
-
-    # Try to use the basename, if it's the first executable.
-    found_executable = shutil.which(exe_name)
-    if found_executable and os.path.samefile(found_executable, exe):
-        return exe_name
-
-    # Use the full executable name, because we couldn't find something simpler.
-    return exe
-
-
 def get_pip_install(args):
     cmd = [
-        get_best_invocation_for_this_python(),
+        sys.executable,
         "-m",
         "pip",
         "install",
+        "--upgrade",
+        "--upgrade-strategy",
+        "only-if-needed",
     ]
     cmd += args
     return cmd
@@ -265,15 +251,34 @@ def run_install(cmd):
 
 
 class Spinner:
-    spinner_chars = itertools.cycle(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"])
+    unicode_spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    ascii_spinner = ["|", "/", "-", "\\"]
 
     def __init__(self, text):
         self.text = text
         self.start_time = time.time()
         self.last_update = 0
         self.visible = False
+        self.is_tty = sys.stdout.isatty()
+        self.tested = False
+
+    def test_charset(self):
+        if self.tested:
+            return
+        self.tested = True
+        # Try unicode first, fall back to ascii if needed
+        try:
+            # Test if we can print unicode characters
+            print(self.unicode_spinner[0], end="", flush=True)
+            print("\r", end="", flush=True)
+            self.spinner_chars = itertools.cycle(self.unicode_spinner)
+        except UnicodeEncodeError:
+            self.spinner_chars = itertools.cycle(self.ascii_spinner)
 
     def step(self):
+        if not self.is_tty:
+            return
+
         current_time = time.time()
         if not self.visible and current_time - self.start_time >= 0.5:
             self.visible = True
@@ -286,19 +291,23 @@ class Spinner:
         if not self.visible:
             return
 
+        self.test_charset()
         print(f"\r{self.text} {next(self.spinner_chars)}\r{self.text} ", end="", flush=True)
 
     def end(self):
-        if self.visible:
+        if self.visible and self.is_tty:
             print("\r" + " " * (len(self.text) + 3))
 
 
 def find_common_root(abs_fnames):
+    try:
         if len(abs_fnames) == 1:
             return safe_abs_path(os.path.dirname(list(abs_fnames)[0]))
         elif abs_fnames:
             return safe_abs_path(os.path.commonpath(list(abs_fnames)))
-    else:
+    except OSError:
+        pass
+
     return safe_abs_path(os.getcwd())
 
 
@@ -346,7 +355,7 @@ def check_pip_install_extra(io, module, prompt, pip_install_cmd, self_update=Fal
     success, output = run_install(cmd)
     if success:
         if not module:
-            return
+            return True
         try:
             __import__(module)
             return True
@@ -375,3 +384,15 @@ def printable_shell_command(cmd_list):
         return subprocess.list2cmdline(cmd_list)
     else:
         return shlex.join(cmd_list)
+
+
+def main():
+    spinner = Spinner("Running spinner...")
+    for _ in range(40):  # 40 steps * 0.25 seconds = 10 seconds
+        time.sleep(0.25)
+        spinner.step()
+    spinner.end()
+
+
+if __name__ == "__main__":
+    main()

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?",
-        ["--upgrade", "git+https://github.com/paul-gauthier/aider.git"],
+        ["git+https://github.com/Aider-AI/aider.git"],
         self_update=True,
     )
 
@@ -50,7 +50,7 @@ def install_upgrade(io, latest_version=None):
         io,
         None,
         new_ver_text,
-        ["--upgrade", "aider-chat"],
+        ["aider-chat"],
         self_update=True,
     )
 

aider/voice.py

@@ -3,18 +3,28 @@ import os
 import queue
 import tempfile
 import time
+import warnings
+
+from prompt_toolkit.shortcuts import prompt
 
 from aider.llm import litellm
 
+from .dump import dump  # noqa: F401
+
+warnings.filterwarnings(
+    "ignore", message="Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work"
+)
+warnings.filterwarnings("ignore", category=SyntaxWarning)
+
+
+from pydub import AudioSegment  # noqa
+from pydub.exceptions import CouldntDecodeError, CouldntEncodeError  # noqa
+
 try:
     import soundfile as sf
 except (OSError, ModuleNotFoundError):
     sf = None
 
-from prompt_toolkit.shortcuts import prompt
-
-from .dump import dump  # noqa: F401
-
 
 class SoundDeviceError(Exception):
     pass
@@ -27,7 +37,7 @@ class Voice:
 
     threshold = 0.15
 
-    def __init__(self):
+    def __init__(self, audio_format="wav", device_name=None):
         if sf is None:
             raise SoundDeviceError
         try:
@@ -35,8 +45,34 @@ class Voice:
             import sounddevice as sd
 
             self.sd = sd
+
+            devices = sd.query_devices()
+
+            if device_name:
+                # Find the device with matching name
+                device_id = None
+                for i, device in enumerate(devices):
+                    if device_name in device["name"]:
+                        device_id = i
+                        break
+                if device_id is None:
+                    available_inputs = [d["name"] for d in devices if d["max_input_channels"] > 0]
+                    raise ValueError(
+                        f"Device '{device_name}' not found. Available input devices:"
+                        f" {available_inputs}"
+                    )
+
+                print(f"Using input device: {device_name} (ID: {device_id})")
+
+                self.device_id = device_id
+            else:
+                self.device_id = None
+
         except (OSError, ModuleNotFoundError):
             raise SoundDeviceError
+        if audio_format not in ["wav", "mp3", "webm"]:
+            raise ValueError(f"Unsupported audio format: {audio_format}")
+        self.audio_format = audio_format
 
     def callback(self, indata, frames, time, status):
         """This is called (from a separate thread) for each audio block."""
@@ -80,10 +116,10 @@ class Voice:
     def raw_record_and_transcribe(self, history, language):
         self.q = queue.Queue()
 
-        filename = tempfile.mktemp(suffix=".wav")
+        temp_wav = tempfile.mktemp(suffix=".wav")
 
         try:
-            sample_rate = int(self.sd.query_devices(None, "input")["default_samplerate"])
+            sample_rate = int(self.sd.query_devices(self.device_id, "input")["default_samplerate"])
         except (TypeError, ValueError):
             sample_rate = 16000  # fallback to 16kHz if unable to query device
         except self.sd.PortAudioError:
@@ -94,15 +130,40 @@ class Voice:
         self.start_time = time.time()
 
         try:
-            with self.sd.InputStream(samplerate=sample_rate, channels=1, callback=self.callback):
+            with self.sd.InputStream(
+                samplerate=sample_rate, channels=1, callback=self.callback, device=self.device_id
+            ):
                 prompt(self.get_prompt, refresh_interval=0.1)
         except self.sd.PortAudioError as err:
             raise SoundDeviceError(f"Error accessing audio input device: {err}")
 
-        with sf.SoundFile(filename, mode="x", samplerate=sample_rate, channels=1) as file:
+        with sf.SoundFile(temp_wav, mode="x", samplerate=sample_rate, channels=1) as file:
             while not self.q.empty():
                 file.write(self.q.get())
 
+        use_audio_format = self.audio_format
+
+        # Check file size and offer to convert to mp3 if too large
+        file_size = os.path.getsize(temp_wav)
+        if file_size > 24.9 * 1024 * 1024 and self.audio_format == "wav":
+            print("\nWarning: {temp_wav} is too large, switching to mp3 format.")
+            use_audio_format = "mp3"
+
+        filename = temp_wav
+        if use_audio_format != "wav":
+            try:
+                new_filename = tempfile.mktemp(suffix=f".{use_audio_format}")
+                audio = AudioSegment.from_wav(temp_wav)
+                audio.export(new_filename, format=use_audio_format)
+                os.remove(temp_wav)
+                filename = new_filename
+            except (CouldntDecodeError, CouldntEncodeError) as e:
+                print(f"Error converting audio: {e}")
+            except (OSError, FileNotFoundError) as e:
+                print(f"File system error during conversion: {e}")
+            except Exception as e:
+                print(f"Unexpected error during audio conversion: {e}")
+
         with open(filename, "rb") as fh:
             try:
                 transcript = litellm.transcription(
@@ -112,6 +173,9 @@ class Voice:
                 print(f"Unable to transcribe {filename}: {err}")
                 return
 
+        if filename != temp_wav:
+            os.remove(filename)
+
         text = transcript.text
         return text
 

aider/watch.py

@@ -0,0 +1,307 @@
+import re
+import threading
+from pathlib import Path
+from typing import Optional
+
+from grep_ast import TreeContext
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+from watchfiles import watch
+
+from aider.dump import dump  # noqa
+from aider.watch_prompts import watch_ask_prompt, watch_code_prompt
+
+
+def load_gitignores(gitignore_paths: list[Path]) -> Optional[PathSpec]:
+    """Load and parse multiple .gitignore files into a single PathSpec"""
+    if not gitignore_paths:
+        return None
+
+    patterns = [
+        ".aider*",
+        ".git",
+        # Common editor backup/temp files
+        "*~",  # Emacs/vim backup
+        "*.bak",  # Generic backup
+        "*.swp",  # Vim swap
+        "*.swo",  # Vim swap
+        "\\#*\\#",  # Emacs auto-save
+        ".#*",  # Emacs lock files
+        "*.tmp",  # Generic temp files
+        "*.temp",  # Generic temp files
+        "*.orig",  # Merge conflict originals
+        "*.pyc",  # Python bytecode
+        "__pycache__/",  # Python cache dir
+        ".DS_Store",  # macOS metadata
+        "Thumbs.db",  # Windows thumbnail cache
+        # IDE files
+        ".idea/",  # JetBrains IDEs
+        ".vscode/",  # VS Code
+        "*.sublime-*",  # Sublime Text
+        ".project",  # Eclipse
+        ".settings/",  # Eclipse
+        "*.code-workspace",  # VS Code workspace
+        # Environment files
+        ".env",  # Environment variables
+        ".venv/",  # Python virtual environments
+        "node_modules/",  # Node.js dependencies
+        "vendor/",  # Various dependencies
+        # Logs and caches
+        "*.log",  # Log files
+        ".cache/",  # Cache directories
+        ".pytest_cache/",  # Python test cache
+        "coverage/",  # Code coverage reports
+    ]  # Always ignore
+    for path in gitignore_paths:
+        if path.exists():
+            with open(path) as f:
+                patterns.extend(f.readlines())
+
+    return PathSpec.from_lines(GitWildMatchPattern, patterns) if patterns else None
+
+
+class FileWatcher:
+    """Watches source files for changes and AI comments"""
+
+    # Compiled regex pattern for AI comments
+    ai_comment_pattern = re.compile(r"(?:#|//|--) *(ai\b.*|ai\b.*|.*\bai[?!]?) *$", re.IGNORECASE)
+
+    def __init__(self, coder, gitignores=None, verbose=False, analytics=None, root=None):
+        self.coder = coder
+        self.io = coder.io
+        self.root = Path(root) if root else Path(coder.root)
+        self.verbose = verbose
+        self.analytics = analytics
+        self.stop_event = None
+        self.watcher_thread = None
+        self.changed_files = set()
+        self.gitignores = gitignores
+
+        self.gitignore_spec = load_gitignores(
+            [Path(g) for g in self.gitignores] if self.gitignores else []
+        )
+
+        coder.io.file_watcher = self
+
+    def filter_func(self, change_type, path):
+        """Filter function for the file watcher"""
+        path_obj = Path(path)
+        path_abs = path_obj.absolute()
+
+        if not path_abs.is_relative_to(self.root.absolute()):
+            return False
+
+        rel_path = path_abs.relative_to(self.root)
+        if self.verbose:
+            dump(rel_path)
+
+        if self.gitignore_spec and self.gitignore_spec.match_file(
+            rel_path.as_posix() + ("/" if path_abs.is_dir() else "")
+        ):
+            return False
+
+        if self.verbose:
+            dump("ok", rel_path)
+
+        # Check if file contains AI markers
+        try:
+            comments, _, _ = self.get_ai_comments(str(path_abs))
+            return bool(comments)
+        except Exception:
+            return
+
+    def get_roots_to_watch(self):
+        """Determine which root paths to watch based on gitignore rules"""
+        if self.gitignore_spec:
+            roots = [
+                str(path)
+                for path in self.root.iterdir()
+                if not self.gitignore_spec.match_file(
+                    path.relative_to(self.root).as_posix() + ("/" if path.is_dir() else "")
+                )
+            ]
+            # Fallback to watching root if all top-level items are filtered out
+            return roots if roots else [str(self.root)]
+        return [str(self.root)]
+
+    def handle_changes(self, changes):
+        """Process the detected changes and update state"""
+        if not changes:
+            return False
+
+        changed_files = {str(Path(change[1])) for change in changes}
+        self.changed_files.update(changed_files)
+        self.io.interrupt_input()
+        return True
+
+    def watch_files(self):
+        """Watch for file changes and process them"""
+        try:
+            roots_to_watch = self.get_roots_to_watch()
+
+            for changes in watch(
+                *roots_to_watch, watch_filter=self.filter_func, stop_event=self.stop_event
+            ):
+                if self.handle_changes(changes):
+                    return
+
+        except Exception as e:
+            if self.verbose:
+                dump(f"File watcher error: {e}")
+            raise e
+
+    def start(self):
+        """Start watching for file changes"""
+        self.stop_event = threading.Event()
+        self.changed_files = set()
+
+        self.watcher_thread = threading.Thread(target=self.watch_files, daemon=True)
+        self.watcher_thread.start()
+
+    def stop(self):
+        """Stop watching for file changes"""
+        if self.stop_event:
+            self.stop_event.set()
+        if self.watcher_thread:
+            self.watcher_thread.join()
+            self.watcher_thread = None
+            self.stop_event = None
+
+    def process_changes(self):
+        """Get any detected file changes"""
+
+        has_action = None
+        added = False
+        for fname in self.changed_files:
+            _, _, action = self.get_ai_comments(fname)
+            if action in ("!", "?"):
+                has_action = action
+
+            if fname in self.coder.abs_fnames:
+                continue
+            if self.analytics:
+                self.analytics.event("ai-comments file-add")
+            self.coder.abs_fnames.add(fname)
+            rel_fname = self.coder.get_rel_fname(fname)
+            if not added:
+                self.io.tool_output()
+                added = True
+            self.io.tool_output(f"Added {rel_fname} to the chat")
+
+        if not has_action:
+            if added:
+                self.io.tool_output(
+                    "End your comment with AI! to request changes or AI? to ask questions"
+                )
+            return ""
+
+        if self.analytics:
+            self.analytics.event("ai-comments execute")
+        self.io.tool_output("Processing your request...")
+
+        if has_action == "!":
+            res = watch_code_prompt
+        elif has_action == "?":
+            res = watch_ask_prompt
+
+        # Refresh all AI comments from tracked files
+        for fname in self.coder.abs_fnames:
+            line_nums, comments, _action = self.get_ai_comments(fname)
+            if not line_nums:
+                continue
+
+            code = self.io.read_text(fname)
+            if not code:
+                continue
+
+            rel_fname = self.coder.get_rel_fname(fname)
+            res += f"\n{rel_fname}:\n"
+
+            # Convert comment line numbers to line indices (0-based)
+            lois = [ln - 1 for ln, _ in zip(line_nums, comments) if ln > 0]
+
+            try:
+                context = TreeContext(
+                    rel_fname,
+                    code,
+                    color=False,
+                    line_number=False,
+                    child_context=False,
+                    last_line=False,
+                    margin=0,
+                    mark_lois=True,
+                    loi_pad=3,
+                    show_top_of_file_parent_scope=False,
+                )
+                context.lines_of_interest = set()
+                context.add_lines_of_interest(lois)
+                context.add_context()
+                res += context.format()
+            except ValueError:
+                for ln, comment in zip(line_nums, comments):
+                    res += f"  Line {ln}: {comment}\n"
+
+        return res
+
+    def get_ai_comments(self, filepath):
+        """Extract AI comment line numbers, comments and action status from a file"""
+        line_nums = []
+        comments = []
+        has_action = None  # None, "!" or "?"
+        content = self.io.read_text(filepath, silent=True)
+        if not content:
+            return None, None, None
+
+        for i, line in enumerate(content.splitlines(), 1):
+            if match := self.ai_comment_pattern.search(line):
+                comment = match.group(0).strip()
+                if comment:
+                    line_nums.append(i)
+                    comments.append(comment)
+                    comment = comment.lower()
+                    comment = comment.lstrip("/#-")
+                    comment = comment.strip()
+                    if comment.startswith("ai!") or comment.endswith("ai!"):
+                        has_action = "!"
+                    elif comment.startswith("ai?") or comment.endswith("ai?"):
+                        has_action = "?"
+        if not line_nums:
+            return None, None, None
+        return line_nums, comments, has_action
+
+
+def main():
+    """Example usage of the file watcher"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Watch source files for changes")
+    parser.add_argument("directory", help="Directory to watch")
+    parser.add_argument(
+        "--gitignore",
+        action="append",
+        help="Path to .gitignore file (can be specified multiple times)",
+    )
+    args = parser.parse_args()
+
+    directory = args.directory
+    print(f"Watching source files in {directory}...")
+
+    # Example ignore function that ignores files with "test" in the name
+    def ignore_test_files(path):
+        return "test" in path.name.lower()
+
+    watcher = FileWatcher(directory, gitignores=args.gitignore)
+    try:
+        watcher.start()
+        while True:
+            if changes := watcher.get_changes():
+                for file in sorted(changes.keys()):
+                    print(file)
+                watcher.changed_files = None
+    except KeyboardInterrupt:
+        print("\nStopped watching files")
+        watcher.stop()
+
+
+if __name__ == "__main__":
+    main()

aider/watch_prompts.py

@@ -0,0 +1,12 @@
+watch_code_prompt = """
+I've written your instructions in comments in the code and marked them with "ai"
+You can see the "AI" comments shown below (marked with █).
+Find them in the code files I've shared with you, and follow their instructions.
+
+After completing those instructions, also be sure to remove all the "AI" comments from the code too.
+"""
+
+watch_ask_prompt = """/ask
+Find the "AI" comments below (marked with █) in the code files I've shared with you.
+They contain my questions that I need you to answer and other instructions for you.
+"""

aider/website/HISTORY.md

@@ -1,20 +1,382 @@
 ---
 title: Release history
-parent: More info
+nav_order: 925
-nav_order: 999
 highlight_image: /assets/blame.jpg
 description: Release notes and stats on aider writing its own code.
 ---
 
+# Release history
+
 {% include blame.md %}
 
+The above 
+[stats are based on the git commit history](/docs/faq.html#how-are-the-aider-wrote-xx-of-code-stats-computed)
+of the aider repo.
+
+## Release notes
+
 <!--[[[cog
 # This page is a copy of HISTORY.md, adding the front matter above.
 text = open("HISTORY.md").read()
+text = text.replace("# Release history", "")
 cog.out(text)
 ]]]-->
 
-# Release history
+
+### Aider v0.74.3
+
+- Downgrade streamlit dependency to avoid threading bug.
+- Added support for tree-sitter language pack.
+- Added openrouter/o3-mini-high model configuration.
+- Added build.gradle.kts to special files for Kotlin project support, by Lucas Shadler.
+
+### Aider v0.74.2
+
+- Prevent more than one cache warming thread from becoming active.
+- Fixed continuation prompt ". " for multiline input.
+- Added HCL (Terraform) syntax support, by Warren Krewenki.
+
+### Aider v0.74.1
+
+- Have o1 & o3-mini generate markdown by sending the magic "Formatting re-enabled." string.
+- Bugfix for multi-line inputs, which should not include the ". " continuation prompt.
+
+### Aider v0.74.0
+
+- Dynamically changes the Ollama context window to hold the current chat.
+- Better support for o3-mini, DeepSeek V3 & R1, o1-mini, o1 especially via third-party API providers.
+- Remove `<think>` tags from R1 responses for commit messages (and other weak model uses).
+- Can now specify `use_temperature: <float>` in model settings, not just true/false.
+- The full docker container now includes `boto3` for Bedrock.
+- Docker containers now set `HOME=/app` which is the normal project mount-point, to persist `~/.aider`.
+- Bugfix to prevent creating incorrect filenames like `python`, `php`, etc.
+- Bugfix for `--timeout`
+- Bugfix so that `/model` now correctly reports that the weak model is not changed.
+- Bugfix so that multi-line mode persists through ^C at confirmation prompts.
+- Watch files now fully ignores top-level directories named in ignore files, to reduce the chance of hitting OS watch limits. Helpful to ignore giant subtrees like `node_modules`.
+- Fast startup with more providers and when model metadata provided in local files.
+- Improved .gitignore handling:
+  - Honor ignores already in effect regardless of how they've been configured.
+  - Check for .env only when the file exists.
+- Yes/No prompts now accept All/Skip as alias for Y/N even when not processing a group of confirmations.
+- Aider wrote 77% of the code in this release.
+
+### Aider v0.73.0
+
+- Full support for o3-mini: `aider --model o3-mini`
+- New `--reasoning-effort` argument: low, medium, high.
+- Improved handling of context window size limits, with better messaging and Ollama-specific guidance.
+- Added support for removing model-specific reasoning tags from responses with `remove_reasoning: tagname` model setting.
+- Auto-create parent directories when creating new files, by xqyz.
+- Support for R1 free on OpenRouter: `--model openrouter/deepseek/deepseek-r1:free`
+- Aider wrote 69% of the code in this release.
+
+### Aider v0.72.3
+
+- Enforce user/assistant turn order to avoid R1 errors, by miradnanali.
+- Case-insensitive model name matching while preserving original case.
+
+### Aider v0.72.2
+- Harden against user/assistant turn order problems which cause R1 errors.
+
+### Aider v0.72.1
+- Fix model metadata for `openrouter/deepseek/deepseek-r1`
+
+### Aider v0.72.0
+- Support for DeepSeek R1.
+  - Use shortcut: `--model r1`
+  - Also via OpenRouter: `--model openrouter/deepseek/deepseek-r1`
+- Added Kotlin syntax support to repo map, by Paul Walker.
+- Added `--line-endings` for file writing, by Titusz Pan.
+- Added examples_as_sys_msg=True for GPT-4o models, improves benchmark scores.
+- Bumped all dependencies, to pick up litellm support for o1 system messages.
+- Bugfix for turn taking when reflecting lint/test errors.
+- Aider wrote 52% of the code in this release.
+
+### Aider v0.71.1
+
+- Fix permissions issue in Docker images.
+- Added read-only file announcements.
+- Bugfix: ASCII fallback for unicode errors.
+- Bugfix: integer indices for list slicing in repomap calculations.
+
+### Aider v0.71.0
+
+- Prompts to help DeepSeek work better when alternating between `/ask` and `/code`.
+- Streaming pretty LLM responses is smoother and faster for long replies.
+- Streaming automatically turns of for model that don't support it
+  - Can now switch to/from `/model o1` and a streaming model
+- Pretty output remains enabled even when editing files with triple-backtick fences
+- Bare `/ask`, `/code` and `/architect` commands now switch the chat mode.
+- Increased default size of the repomap.
+- Increased max chat history tokens limit from 4k to 8k.
+- Turn off fancy input and watch files if terminal is dumb.
+- Added support for custom voice format and input device settings.
+- Disabled Streamlit email prompt, by apaz-cli.
+- Docker container runs as non-root user.
+- Fixed lint command handling of nested spaced strings, by Aaron Weisberg.
+- Added token count feedback when adding command output to chat.
+- Improved error handling for large audio files with automatic format conversion.
+- Improved handling of git repo index errors, by Krazer.
+- Improved unicode handling in console output with ASCII fallback.
+- Added AssertionError, AttributeError to git error handling.
+- Aider wrote 60% of the code in this release.
+
+### Aider v0.70.0
+
+- Full support for o1 models.
+- Watch files now honors `--subtree-only`, and only watches that subtree.
+- Improved prompting for watch files, to work more reliably with more models.
+- New install methods via uv, including one-liners.
+- Support for openrouter/deepseek/deepseek-chat model.
+- Better error handling when interactive commands are attempted via `/load` or `--load`.
+- Display read-only files with abs path if its shorter than rel path.
+- Ask 10% of users to opt-in to analytics.
+- Bugfix for auto-suggest.
+- Gracefully handle unicode errors in git path names.
+- Aider wrote 74% of the code in this release.
+
+### Aider v0.69.1
+
+- Fix for gemini model names in model metadata.
+- Show hints about AI! and AI? when user makes AI comments.
+- Support for running without git installed.
+- Improved environment variable setup messages on Windows.
+
+### Aider v0.69.0
+
+- [Watch files](https://aider.chat/docs/usage/watch.html) improvements:
+  - Use `# ... AI?` comments to trigger aider and ask questions about your code.
+  - Now watches *all* files, not just certain source files.
+  - Use `# AI comments`, `// AI comments`, or `-- AI comments` to give aider instructions in any text file.
+- Full support for Gemini Flash 2.0 Exp:
+  - `aider --model flash` or `aider --model gemini/gemini-2.0-flash-exp`
+- [New `--multiline` flag and `/multiline-mode` command](https://aider.chat/docs/usage/commands.html#entering-multi-line-chat-messages) makes ENTER a soft newline and META-ENTER send the message, by @miradnanali.
+- `/copy-context <instructions>` now takes optional "instructions" when [copying code context to the clipboard](https://aider.chat/docs/usage/copypaste.html#copy-aiders-code-context-to-your-clipboard-paste-into-the-web-ui).
+- Improved clipboard error handling with helpful requirements install info.
+- Ask 5% of users if they want to opt-in to analytics.
+- `/voice` now lets you edit the transcribed text before sending.
+- Disabled auto-complete in Y/N prompts.
+- Aider wrote 68% of the code in this release.
+
+### Aider v0.68.0
+
+- [Aider works with LLM web chat UIs](https://aider.chat/docs/usage/copypaste.html).
+  - New `--copy-paste` mode.
+  - New `/copy-context` command.
+- [Set API keys and other environment variables for all providers from command line or yaml conf file](https://aider.chat/docs/config/aider_conf.html#storing-llm-keys).
+  - New `--api-key provider=key` setting.
+  - New `--set-env VAR=value` setting.
+- Added bash and zsh support to `--watch-files`.
+- Better error messages when missing dependencies for Gemini and Bedrock models.
+- Control-D now properly exits the program.
+- Don't count token costs when API provider returns a hard error.
+- Bugfix so watch files works with files that don't have tree-sitter support.
+- Bugfix so o1 models can be used as weak model.
+- Updated shell command prompt.
+- Added docstrings for all Coders.
+- Reorganized command line arguments with improved help messages and grouping.
+- Use the exact `sys.python` for self-upgrades.
+- Added experimental Gemini models.
+- Aider wrote 71% of the code in this release.
+
+### Aider v0.67.0
+
+- [Use aider in your IDE or editor](https://aider.chat/docs/usage/watch.html).
+  - Run `aider --watch-files` and it will watch for instructions you add to your source files.
+  - One-liner `# ...` or `// ...` comments that start or end with "AI" are instructions to aider.
+  - When aider sees "AI!" it reads and follows all the instructions in AI comments.
+- Support for new Amazon Bedrock Nova models.
+- When `/run` or `/test` have non-zero exit codes, pre-fill "Fix that" into the next message prompt.
+- `/diff` now invokes `git diff` to use your preferred diff tool.
+- Added Ctrl-Z support for process suspension.
+- Spinner now falls back to ASCII art if fancy symbols throw unicode errors.
+- `--read` now expands `~` home dirs.
+- Enabled exception capture in analytics.
+- [Aider wrote 61% of the code in this release.](https://aider.chat/HISTORY.html)
+
+### Aider v0.66.0
+
+- PDF support for Sonnet and Gemini models.
+- Added `--voice-input-device` to select audio input device for voice recording, by @preynal.
+- Added `--timeout` option to configure API call timeouts.
+- Set cwd to repo root when running shell commands.
+- Added Ctrl-Up/Down keyboard shortcuts for per-message history navigation.
+- Improved error handling for failed .gitignore file operations.
+- Improved error handling for input history file permissions.
+- Improved error handling for analytics file access.
+- Removed spurious warning about disabling pretty in VSCode.
+- Removed broken support for Dart.
+- Bugfix when scraping URLs found in chat messages.
+- Better handling of __version__ import errors.
+- Improved `/drop` command to support substring matching for non-glob patterns.
+- Aider wrote 82% of the code in this release.
+
+### Aider v0.65.1
+
+- Bugfix to `--alias`.
+
+### Aider v0.65.0
+
+- Added `--alias` config to define [custom model aliases](https://aider.chat/docs/config/model-aliases.html).
+- Added `--[no-]detect-urls` flag to disable detecting and offering to scrape URLs found in the chat.
+- Ollama models now default to an 8k context window.
+- Added [RepoMap support for Dart language](https://aider.chat/docs/languages.html) by @malkoG.
+- Ask 2.5% of users if they want to opt-in to [analytics](https://aider.chat/docs/more/analytics.html).
+- Skip suggesting files that share names with files already in chat.
+- `/editor` returns and prefill the file content into the prompt, so you can use `/editor` to compose messages that start with `/commands`, etc.
+- Enhanced error handling for analytics.
+- Improved handling of UnknownEditFormat exceptions with helpful documentation links.
+- Bumped dependencies to pick up grep-ast 0.4.0 for Dart language support.
+- Aider wrote 81% of the code in this release.
+
+### Aider v0.64.1
+
+- Disable streaming for o1 on OpenRouter.
+
+### Aider v0.64.0
+
+- Added [`/editor` command](https://aider.chat/docs/usage/commands.html) to open system editor for writing prompts, by @thehunmonkgroup.
+- Full support for `gpt-4o-2024-11-20`.
+- Stream o1 models by default.
+- `/run` and suggested shell commands are less mysterious and now confirm that they "Added XX lines of output to the chat."
+- Ask 1% of users if they want to opt-in to [analytics](https://aider.chat/docs/more/analytics.html).
+- Added support for [optional multiline input tags](https://aider.chat/docs/usage/commands.html#entering-multi-line-chat-messages) with matching closing tags.
+- Improved [model settings configuration](https://aider.chat/docs/config/adv-model-settings.html#global-extra-params) with support for global `extra_params` for `litellm.completion()`.
+- Architect mode now asks to add files suggested by the LLM.
+- Fixed bug in fuzzy model name matching.
+- Added Timeout exception to handle API provider timeouts.
+- Added `--show-release-notes` to control release notes display on first run of new version.
+- Save empty dict to cache file on model metadata download failure, to delay retry.
+- Improved error handling and code formatting.
+- Aider wrote 74% of the code in this release.
+
+###  Aider v0.63.2
+
+- Fixed bug in fuzzy model name matching when litellm provider info is missing.
+- Modified model metadata file loading to allow override of resource file.
+- Allow recursive loading of dirs using `--read`.
+- Updated dependency versions to pick up litellm fix for ollama models.
+- Added exponential backoff retry when writing files to handle editor file locks.
+- Updated Qwen 2.5 Coder 32B model configuration.
+
+### Aider v0.63.1
+
+- Fixed bug in git ignored file handling.
+- Improved error handling for git operations.
+
+### Aider v0.63.0
+
+- Support for Qwen 2.5 Coder 32B.
+- `/web` command just adds the page to the chat, without triggering an LLM response.
+- Improved prompting for the user's preferred chat language.
+- Improved handling of LiteLLM exceptions.
+- Bugfix for double-counting tokens when reporting cache stats.
+- Bugfix for the LLM creating new files.
+- Other small bug fixes.
+- Aider wrote 55% of the code in this release.
+
+### Aider v0.62.0
+
+- Full support for Claude 3.5 Haiku
+  - Scored 75% on [aider's code editing leaderboard](https://aider.chat/docs/leaderboards/).
+  - Almost as good as Sonnet at much lower cost.
+  - Launch with `--haiku` to use it.
+- Easily apply file edits from ChatGPT, Claude or other web apps
+  - Chat with ChatGPT or Claude via their web app. 
+  - Give it your source files and ask for the changes you want.
+  - Use the web app's "copy response" button to copy the entire reply from the LLM.
+  - Run `aider --apply-clipboard-edits file-to-edit.js`.
+  - Aider will edit your file with the LLM's changes.
+- Bugfix for creating new files.
+- Aider wrote 84% of the code in this release.  
+
+### Aider v0.61.0
+
+- Load and save aider slash-commands to files:
+  - `/save <fname>` command will make a file of `/add` and `/read-only` commands that recreate the current file context in the chat.
+  - `/load <fname>` will replay the commands in the file.
+  - You can use `/load` to run any arbitrary set of slash-commands, not just `/add` and `/read-only`.
+  - Use `--load <fname>` to run a list of commands on launch, before the interactive chat begins.
+- Anonymous, opt-in [analytics](https://aider.chat/docs/more/analytics.html) with no personal data sharing.
+- Aider follows litellm's `supports_vision` attribute to enable image support for models.
+- Bugfix for when diff mode flexibly handles the model using the wrong filename.
+- Displays filenames in sorted order for `/add` and `/read-only`.
+- New `--no-fancy-input` switch disables prompt toolkit input, now still available with `--no-pretty`.
+- Override browser config with `--no-browser` or `--no-gui`.
+- Offer to open documentation URLs when errors occur.
+- Properly support all o1 models, regardless of provider.
+- Improved layout of filenames above input prompt.
+- Better handle corrupted repomap tags cache.
+- Improved handling of API errors, especially when accessing the weak model.
+- Aider wrote 68% of the code in this release.
+
+### Aider v0.60.1
+
+- Enable image support for Sonnet 10/22.
+- Display filenames in sorted order.
+
+### Aider v0.60.0
+
+- Full support for Sonnet 10/22, the new SOTA model on aider's code editing benchmark.
+  - Aider uses Sonnet 10/22 by default.
+- Improved formatting of added and read-only files above chat prompt, by @jbellis.
+- Improved support for o1 models by more flexibly parsing their nonconforming code edit replies.
+- Corrected diff edit format prompt that only the first match is replaced.
+- Stronger whole edit format prompt asking for clean file names.
+- Now offers to add `.env` to the `.gitignore` file.
+- Ships with a small model metadata json file to handle models not yet updated in litellm.
+- Model settings for o1 models on azure.
+- Bugfix to properly include URLs in `/help` RAG results.
+- Aider wrote 49% of the code in this release.
+
+### Aider v0.59.1
+
+- Check for obsolete `yes: true` in yaml config, show helpful error.
+- Model settings for openrouter/anthropic/claude-3.5-sonnet:beta
+
+### Aider v0.59.0
+
+- Improvements to `/read-only`:
+  - Now supports shell-style auto-complete of the full file system.
+  - Still auto-completes the full paths of the repo files like `/add`.
+  - Now supports globs like `src/**/*.py`
+- Renamed `--yes` to `--yes-always`.
+  - Now uses `AIDER_YES_ALWAYS` env var and `yes-always:` yaml key.
+  - Existing YAML and .env files will need to be updated.
+  - Can still abbreviate to `--yes` on the command line.
+- Config file now uses standard YAML list syntax with `  - list entries`, one per line.  
+- `/settings` now includes the same announcement lines that would print at launch.
+- Sanity checks the `--editor-model` on launch now, same as main and weak models.
+- Added `--skip-sanity-check-repo` switch to speedup launch in large repos.
+- Bugfix so architect mode handles Control-C properly.
+- Repo-map is deterministic now, with improved caching logic.
+- Improved commit message prompt.
+- Aider wrote 77% of the code in this release.
+
+### Aider v0.58.1
+
+- Fixed bug where cache warming pings caused subsequent user messages to trigger a tight loop of LLM requests.
+
+### Aider v0.58.0
+
+- [Use a pair of Architect/Editor models for improved coding](https://aider.chat/2024/09/26/architect.html)
+  - Use a strong reasoning model like o1-preview as your Architect.
+  - Use a cheaper, faster model like gpt-4o as your Editor.
+- New `--o1-preview` and `--o1-mini` shortcuts.
+- Support for new Gemini 002 models.
+- Better support for Qwen 2.5 models.
+- Many confirmation questions can be skipped for the rest of the session with "(D)on't ask again" response.
+- Autocomplete for `/read-only` supports the entire filesystem.
+- New settings for completion menu colors.
+- New `/copy` command to copy the last LLM response to the clipboard.
+- Renamed `/clipboard` to `/paste`.
+- Will now follow HTTP redirects when scraping urls.
+- New `--voice-format` switch to send voice audio as wav/mp3/webm, by @mbailey.
+- ModelSettings takes `extra_params` dict to specify any extras to pass to `litellm.completion()`.
+- Support for cursor shapes when in vim mode.
+- Numerous bug fixes.
+- Aider wrote 53% of the code in this release.
 
 ### Aider v0.57.1
 
@@ -680,7 +1042,7 @@ cog.out(text)
 ### Aider v0.14.0
 
 - [Support for Claude2 and other LLMs via OpenRouter](https://aider.chat/docs/faq.html#accessing-other-llms-with-openrouter) by @joshuavial
-- Documentation for [running the aider benchmarking suite](https://github.com/paul-gauthier/aider/tree/main/benchmark)
+- Documentation for [running the aider benchmarking suite](https://github.com/Aider-AI/aider/tree/main/benchmark)
 - Aider now requires Python >= 3.9
 
 

aider/website/_config.yml

@@ -1,6 +1,12 @@
 theme: just-the-docs
 url: "https://aider.chat"
 
+# Analytics configuration
+analytics:
+  enabled: false  # Single switch to control analytics and cookie consent
+  posthog_key: 'phc_99T7muzafUMMZX15H8XePbMSreEUzahHbtWjy3l5Qbv'
+  posthog_host: 'https://us.i.posthog.com'
+
 plugins:
   - jekyll-redirect-from
   - jekyll-sitemap
@@ -24,7 +30,7 @@ exclude:
 
 aux_links:
   "GitHub":
-    - "https://github.com/paul-gauthier/aider"
+    - "https://github.com/Aider-AI/aider"
   "Discord":
     - "https://discord.gg/Tv2uQnR88V"
   "Blog":
@@ -32,11 +38,11 @@ aux_links:
 
 nav_external_links:
   - title: "GitHub"
-    url: "https://github.com/paul-gauthier/aider"
+    url: "https://github.com/Aider-AI/aider"
   - title: "Discord"
     url: "https://discord.gg/Tv2uQnR88V"
 
-repository: paul-gauthier/aider
+repository: Aider-AI/aider
 
 callouts:
   tip:

aider/website/_data/architect.yml

@@ -0,0 +1,492 @@
+- dirname: 2024-09-25-21-17-19--architect-sonnet-sonnet-diff
+  test_cases: 133
+  model: claude-3.5-sonnet
+  editor_model: claude-3.5-sonnet
+  editor_edit_format: diff
+  edit_format: architect
+  commit_hash: c18d6a8-dirty
+  pass_rate_1: 62.4
+  pass_rate_2: 80.5
+  percent_cases_well_formed: 100.0
+  error_outputs: 3
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 183
+  lazy_comments: 6
+  syntax_errors: 9
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model openrouter/anthropic/claude-3.5-sonnet
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 25.1
+  total_cost: 4.9502
+  
+- dirname: 2024-07-04-14-32-08--claude-3.5-sonnet-diff-continue
+  test_cases: 133
+  model: claude-3.5-sonnet
+  edit_format: diff
+  commit_hash: 35f21b5
+  pass_rate_1: 57.1
+  pass_rate_2: 77.4
+  percent_cases_well_formed: 99.2
+  error_outputs: 23
+  released: 2024-06-20
+  num_malformed_responses: 4
+  num_with_malformed_responses: 1
+  user_asks: 2
+  lazy_comments: 0
+  syntax_errors: 1
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --sonnet
+  date: 2024-07-04
+  versions: 0.42.1-dev
+  seconds_per_case: 17.6
+  total_cost: 3.6346
+    
+- dirname: 2024-09-25-21-25-01--architect-o1mini-4o-jr-diff
+  test_cases: 133
+  model: o1-mini
+  editor_model: gpt-4o
+  editor_edit_format: diff
+  edit_format: architect
+  commit_hash: 3f682ed-dirty, 25e833b
+  pass_rate_1: 51.1
+  pass_rate_2: 70.7
+  percent_cases_well_formed: 100.0
+  error_outputs: 12
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 214
+  lazy_comments: 6
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model o1-mini
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 23.7
+  total_cost: 9.3158
+
+- dirname: 2024-09-26-15-05-58--architect-o1mini-deep-jr-whole
+  test_cases: 133
+  model: o1-mini
+  edit_format: architect
+  commit_hash: 1676653-dirty
+  editor_model: deepseek
+  editor_edit_format: whole
+  pass_rate_1: 51.9
+  pass_rate_2: 71.4
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 199
+  lazy_comments: 11
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model o1-mini
+  date: 2024-09-26
+  versions: 0.57.2.dev
+  seconds_per_case: 48.2
+  total_cost: 5.6069
+                                                
+- dirname: 2024-09-25-21-33-40--architect-4o-4o-jr-diff
+  test_cases: 133
+  model: gpt-4o
+  editor_model: gpt-4o
+  editor_edit_format: diff
+  edit_format: architect
+  commit_hash: 9f3cd92
+  pass_rate_1: 56.4
+  pass_rate_2: 75.2
+  percent_cases_well_formed: 100.0
+  error_outputs: 13
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 207
+  lazy_comments: 8
+  syntax_errors: 1
+  indentation_errors: 1
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model gpt-4o
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 18.2
+  total_cost: 6.0918
+  
+- dirname: 2024-09-21-16-45-11--o1-preview-flex-sr-markers
+  test_cases: 133
+  model: o1-preview
+  edit_format: diff
+  commit_hash: 5493654-dirty
+  pass_rate_1: 57.9
+  pass_rate_2: 79.7
+  percent_cases_well_formed: 93.2
+  error_outputs: 11
+  num_malformed_responses: 11
+  num_with_malformed_responses: 9
+  user_asks: 3
+  lazy_comments: 0
+  syntax_errors: 10
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model o1-preview
+  date: 2024-09-21
+  versions: 0.56.1.dev
+  seconds_per_case: 80.9
+  total_cost: 63.9190
+  
+- dirname: 2024-09-25-21-39-05--architect-o1preview-4o-jr-diff
+  test_cases: 133
+  model: o1-preview
+  editor_model: gpt-4o
+  editor_edit_format: diff
+  edit_format: architect
+  commit_hash: 9f3cd92
+  pass_rate_1: 63.2
+  pass_rate_2: 80.5
+  percent_cases_well_formed: 100.0
+  error_outputs: 23
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 191
+  lazy_comments: 2
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 4
+  command: aider --model o1-preview
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 42.3
+  total_cost: 39.3766
+  
+- dirname: 2024-09-25-21-52-42--architect-o1preview-sonnet-jr-diff
+  test_cases: 133
+  model: o1-preview
+  editor_model: claude-3.5-sonnet
+  editor_edit_format: diff
+  edit_format: architect
+  commit_hash: 9f3cd92
+  editor_model: claude-3-5-sonnet
+  pass_rate_1: 60.9
+  pass_rate_2: 82.7
+  percent_cases_well_formed: 100.0
+  error_outputs: 1
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 180
+  lazy_comments: 3
+  syntax_errors: 9
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model o1-preview
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 44.9
+  total_cost: 37.6192
+  
+- dirname: 2024-09-21-16-40-56--o1-mini-flex-sr-markers
+  test_cases: 36
+  model: o1-mini
+  edit_format: diff
+  commit_hash: 5493654
+  pass_rate_1: 50.0
+  pass_rate_2: 61.1
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 3
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 1
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --model o1-mini
+  date: 2024-09-21
+  versions: 0.56.1.dev
+  seconds_per_case: 26.7
+  total_cost: 2.4226
+                                            
+- dirname: 2024-09-25-23-12-14--architect-o1mini-deep-jr-diff
+  test_cases: 133
+  model: o1-mini
+  edit_format: architect
+  commit_hash: 9f3cd92-dirty
+  editor_model: deepseek
+  editor_edit_format: diff
+  pass_rate_1: 48.9
+  pass_rate_2: 69.2
+  percent_cases_well_formed: 100.0
+  error_outputs: 1
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 202
+  lazy_comments: 12
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model o1-mini
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 52.2
+  total_cost: 5.7927
+  
+- dirname: 2024-09-25-23-18-16--architect-o1preview-deep-jr-diff
+  test_cases: 133
+  model: o1-preview
+  edit_format: architect
+  commit_hash: 9f3cd92-dirty
+  editor_model: deepseek
+  editor_edit_format: diff
+  pass_rate_1: 64.7
+  pass_rate_2: 80.5
+  percent_cases_well_formed: 100.0
+  error_outputs: 5
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 180
+  lazy_comments: 2
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model o1-preview
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 73.2
+  total_cost: 35.7887
+  
+- dirname: 2024-09-25-23-30-36--architect-o1preview-deep-jr-whole
+  test_cases: 133
+  model: o1-preview
+  edit_format: architect
+  commit_hash: 9f3cd92-dirty
+  editor_model: deepseek
+  editor_edit_format: whole
+  pass_rate_1: 63.9
+  pass_rate_2: 85.0
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 181
+  lazy_comments: 12
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model o1-preview
+  date: 2024-09-25
+  versions: 0.57.2.dev
+  seconds_per_case: 67.4
+  total_cost: 35.3152
+
+- dirname: 2024-09-26-15-15-17--architect-sonnet-deep-jr-whole
+  test_cases: 133
+  model: claude-3.5-sonnet
+  edit_format: architect
+  commit_hash: bc1559f-dirty
+  editor_model: deepseek
+  editor_edit_format: whole
+  pass_rate_1: 61.7
+  pass_rate_2: 78.9
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 184
+  lazy_comments: 5
+  syntax_errors: 9
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model openrouter/anthropic/claude-3.5-sonnet
+  date: 2024-09-26
+  versions: 0.57.2.dev
+  seconds_per_case: 37.2
+  total_cost: 2.1510
+
+- dirname: 2024-09-26-15-33-28--costs-gpt4o-diff
+  test_cases: 133
+  model: gpt-4o
+  edit_format: diff
+  commit_hash: 89aa385-dirty
+  pass_rate_1: 55.6
+  pass_rate_2: 71.4
+  percent_cases_well_formed: 97.7
+  error_outputs: 5
+  num_malformed_responses: 5
+  num_with_malformed_responses: 3
+  user_asks: 10
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 1
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --model gpt-4o
+  date: 2024-09-26
+  versions: 0.57.2.dev
+  seconds_per_case: 9.7
+  total_cost: 3.8088
+
+- dirname: 2024-09-26-15-41-08--architect-4o-deep-jr-whole
+  test_cases: 133
+  model: gpt-4o
+  edit_format: architect
+  commit_hash: 89aa385-dirty
+  editor_model: deepseek
+  editor_edit_format: whole
+  pass_rate_1: 60.9
+  pass_rate_2: 73.7
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 187
+  lazy_comments: 12
+  syntax_errors: 5
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model gpt-4o
+  date: 2024-09-26
+  versions: 0.57.2.dev
+  seconds_per_case: 38.0
+  total_cost: 2.4737
+
+- dirname: 2024-09-26-15-54-08--architect-4o-deep-jr-diff
+  test_cases: 133
+  model: gpt-4o
+  edit_format: architect
+  commit_hash: 89aa385-dirty
+  editor_model: deepseek
+  editor_edit_format: diff
+  pass_rate_1: 57.1
+  pass_rate_2: 74.4
+  percent_cases_well_formed: 100.0
+  error_outputs: 4
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 192
+  lazy_comments: 6
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model gpt-4o
+  date: 2024-09-26
+  versions: 0.57.2.dev
+  seconds_per_case: 44.0
+  total_cost: 2.5498
+
+- dirname: 2024-09-26-16-06-39--architect-sonnet-deep-jr-diff
+  test_cases: 133
+  model: claude-3.5-sonnet
+  edit_format: architect
+  commit_hash: 89aa385-dirty
+  editor_model: deepseek
+  editor_edit_format: diff
+  pass_rate_1: 61.7
+  pass_rate_2: 78.9
+  percent_cases_well_formed: 100.0
+  error_outputs: 2
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 184
+  lazy_comments: 2
+  syntax_errors: 9
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model openrouter/anthropic/claude-3.5-sonnet
+  date: 2024-09-26
+  versions: 0.57.2.dev
+  seconds_per_case: 43.2
+  total_cost: 2.1488
+
+- dirname: 2024-09-27-18-15-32--architect-4omini-4omini
+  test_cases: 133
+  model: gpt-4o-mini
+  edit_format: architect
+  commit_hash: 0bd8058-dirty
+  editor_model: gpt-4o-mini
+  editor_edit_format: whole
+  pass_rate_1: 43.6
+  pass_rate_2: 60.2
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 208
+  lazy_comments: 2
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model gpt-4o-mini
+  date: 2024-09-27
+  versions: 0.57.2.dev
+  seconds_per_case: 21.0
+  total_cost: 0.1527
+
+- dirname: 2024-07-18-18-57-46--gpt-4o-mini-whole
+  test_cases: 133
+  model: gpt-4o-mini
+  edit_format: whole
+  commit_hash: d31eef3-dirty
+  pass_rate_1: 40.6
+  pass_rate_2: 55.6
+  released: 2024-07-18
+  percent_cases_well_formed: 100.0
+  error_outputs: 1
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 1
+  lazy_comments: 0
+  syntax_errors: 1
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model gpt-4o-mini
+  date: 2024-07-18
+  versions: 0.44.1-dev
+  seconds_per_case: 7.8
+  total_cost: 0.0916
+
+- dirname: 2024-09-29-22-35-36--architect-o1preview-o1mini-whole
+  test_cases: 133
+  model: o1-preview
+  edit_format: architect
+  commit_hash: 53ca83b
+  editor_model: o1-mini
+  editor_edit_format: whole
+  pass_rate_1: 65.4
+  pass_rate_2: 85.0
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 179
+  lazy_comments: 4
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model o1-preview
+  date: 2024-09-29
+  versions: 0.58.1.dev
+  seconds_per_case: 39.7
+  total_cost: 36.2078

aider/website/_data/deepseek-down.yml

@@ -0,0 +1,130 @@
+- dirname: 2024-12-25-13-31-51--deepseekv3preview-diff2
+  test_cases: 225
+  model: DeepSeek
+  edit_format: diff
+  commit_hash: 0a23c4a-dirty
+  pass_rate_1: 22.7
+  pass_rate_2: 48.4
+  pass_num_1: 51
+  pass_num_2: 109
+  percent_cases_well_formed: 98.7
+  error_outputs: 7
+  num_malformed_responses: 7
+  num_with_malformed_responses: 3
+  user_asks: 19
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model deepseek/deepseek-chat
+  date: 2024-12-25
+  versions: 0.69.2.dev
+  seconds_per_case: 34.8
+  total_cost: 0.3369
+
+
+- dirname: 2025-01-28-17-47-49--v3-fireworks
+  test_cases: 225
+  model: Fireworks
+  edit_format: diff
+  commit_hash: 0336a98-dirty
+  pass_rate_1: 22.2
+  pass_rate_2: 48.4
+  pass_num_1: 50
+  pass_num_2: 109
+  percent_cases_well_formed: 96.9
+  error_outputs: 18
+  num_malformed_responses: 16
+  num_with_malformed_responses: 7
+  user_asks: 14
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 2
+  test_timeouts: 9
+  total_tests: 225
+  command: aider --model fireworks_ai/accounts/fireworks/models/deepseek-v3
+  date: 2025-01-28
+  versions: 0.72.4.dev
+  seconds_per_case: 115.9
+  total_cost: 2.1177
+
+- dirname: 2025-01-28-19-25-32--or-v3-deepinfra-diff
+  test_cases: 222
+  model: "OpenRouter: DeepInfra"
+  edit_format: diff
+  commit_hash: bfc5745, 77d2bc5-dirty
+  pass_rate_1: 23.9
+  pass_rate_2: 48.0
+  pass_num_1: 53
+  pass_num_2: 108
+  percent_cases_well_formed: 99.5
+  error_outputs: 18
+  num_malformed_responses: 1
+  num_with_malformed_responses: 1
+  user_asks: 17
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 2
+  test_timeouts: 4
+  total_tests: 225
+  command: aider --model openrouter/deepseek/deepseek-chat
+  date: 2025-01-28
+  versions: 0.72.4.dev
+  seconds_per_case: 187.0
+  total_cost: 0.2733
+
+- dirname: 2025-01-28-21-07-23--or-v3-novita-diff
+  test_cases: 225
+  model: "OpenRouter: Novita"
+  edit_format: diff
+  commit_hash: 66025a0
+  pass_rate_1: 20.4
+  pass_rate_2: 42.7
+  pass_num_1: 46
+  pass_num_2: 96
+  percent_cases_well_formed: 84.0
+  error_outputs: 265
+  num_malformed_responses: 67
+  num_with_malformed_responses: 36
+  user_asks: 5
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model openrouter/deepseek/deepseek-chat
+  date: 2025-01-28
+  versions: 0.72.4.dev
+  seconds_per_case: 472.5
+  total_cost: 0.0000
+
+- dirname: 2025-01-29-00-36-49--v3-hyperolic-diff
+  test_cases: 224
+  model: Hyperbolic
+  edit_format: diff
+  commit_hash: 298f713
+  pass_rate_1: 20.5
+  pass_rate_2: 48.4
+  pass_num_1: 46
+  pass_num_2: 109
+  percent_cases_well_formed: 97.3
+  error_outputs: 29
+  num_malformed_responses: 6
+  num_with_malformed_responses: 6
+  user_asks: 7
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 7
+  total_tests: 225
+  command: OPENAI_API_BASE=https://api.hyperbolic.xyz/v1/ aider --model openai/deepseek-ai/DeepSeek-V3
+  date: 2025-01-29
+  versions: 0.72.4.dev
+  seconds_per_case: 365.4
+  total_cost: 0.0000

aider/website/_data/o1_polyglot_leaderboard.yml

@@ -0,0 +1,259 @@
+- dirname: 2024-12-21-18-41-18--polyglot-gpt-4o-mini
+  test_cases: 225
+  model: gpt-4o-mini-2024-07-18
+  edit_format: whole
+  commit_hash: a755079-dirty
+  pass_rate_1: 0.9
+  pass_rate_2: 3.6
+  pass_num_1: 2
+  pass_num_2: 8
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 36
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  total_tests: 225
+  command: aider --model gpt-4o-mini-2024-07-18
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 17.3
+  total_cost: 0.3236
+
+- dirname: 2024-12-21-18-44-28--polyglot-sonnet
+  test_cases: 225
+  model: claude-3-5-sonnet-20241022
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 18.7
+  pass_rate_2: 45.3
+  pass_num_1: 42
+  pass_num_2: 102
+  percent_cases_well_formed: 100.0
+  error_outputs: 1
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 14
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 12
+  total_tests: 225
+  command: aider --model claude-3-5-sonnet-20241022
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 30.8
+  total_cost: 13.4847
+
+- dirname: 2024-12-21-18-52-34--polyglot-gpt-4o-diff
+  test_cases: 225
+  model: gpt-4o-2024-11-20
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 4.9
+  pass_rate_2: 15.1
+  pass_num_1: 11
+  pass_num_2: 34
+  percent_cases_well_formed: 96.0
+  error_outputs: 12
+  num_malformed_responses: 11
+  num_with_malformed_responses: 9
+  user_asks: 34
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 19
+  total_tests: 225
+  command: aider --model gpt-4o-2024-11-20
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 22.2
+  total_cost: 7.1835
+
+- dirname: 2024-12-21-19-23-03--polyglot-o1-hard-diff
+  test_cases: 224
+  model: o1-2024-12-17 (high)
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 23.7
+  pass_rate_2: 61.7
+  pass_num_1: 53
+  pass_num_2: 139
+  percent_cases_well_formed: 91.5
+  error_outputs: 25
+  num_malformed_responses: 24
+  num_with_malformed_responses: 19
+  user_asks: 16
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  total_tests: 225
+  command: aider --model openrouter/openai/o1
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 133.2
+  total_cost: 0.0000
+
+- dirname: 2024-12-21-20-56-21--polyglot-deepseek-diff
+  test_cases: 225
+  model: DeepSeek Chat V2.5
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 5.3
+  pass_rate_2: 17.8
+  pass_num_1: 12
+  pass_num_2: 40
+  percent_cases_well_formed: 92.9
+  error_outputs: 42
+  num_malformed_responses: 37
+  num_with_malformed_responses: 16
+  user_asks: 23
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 5
+  test_timeouts: 5
+  total_tests: 225
+  command: aider --model deepseek/deepseek-chat
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 184.0
+  total_cost: 0.5101
+
+- dirname: 2024-12-21-21-46-27--polyglot-haiku-diff
+  test_cases: 225
+  model: claude-3-5-haiku-20241022
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 7.1
+  pass_rate_2: 28.0
+  pass_num_1: 16
+  pass_num_2: 63
+  percent_cases_well_formed: 91.1
+  error_outputs: 31
+  num_malformed_responses: 30
+  num_with_malformed_responses: 20
+  user_asks: 13
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 9
+  total_tests: 225
+  command: aider --model claude-3-5-haiku-20241022
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 31.8
+  total_cost: 6.0583
+
+- dirname: 2024-12-22-13-22-32--polyglot-qwen-diff
+  test_cases: 225
+  model: Qwen2.5-Coder-32B-Instruct
+  edit_format: diff
+  commit_hash: 6d7e8be-dirty
+  pass_rate_1: 4.4
+  pass_rate_2: 8.0
+  pass_num_1: 10
+  pass_num_2: 18
+  percent_cases_well_formed: 71.6
+  error_outputs: 158
+  num_malformed_responses: 148
+  num_with_malformed_responses: 64
+  user_asks: 132
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 2
+  total_tests: 225
+  command: "aider --model openai/Qwen/Qwen2.5-Coder-32B-Instruct # via hyperbolic"
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 84.4
+  total_cost: 0.0000
+
+- dirname: 2024-12-22-21-26-35--polyglot-o1mini-whole
+  test_cases: 225
+  model: o1-mini-2024-09-12
+  edit_format: whole
+  commit_hash: 37df899
+  pass_rate_1: 5.8
+  pass_rate_2: 32.9
+  pass_num_1: 13
+  pass_num_2: 74
+  percent_cases_well_formed: 96.9
+  error_outputs: 8
+  num_malformed_responses: 8
+  num_with_malformed_responses: 7
+  user_asks: 27
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  total_tests: 225
+  command: aider --model o1-mini
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 34.7
+  total_cost: 18.5770
+
+- dirname: 2024-12-22-18-43-25--gemini-exp-1206-polyglot-whole-2
+  test_cases: 225
+  model: gemini-exp-1206
+  edit_format: whole
+  commit_hash: b1bc2f8
+  pass_rate_1: 19.6
+  pass_rate_2: 38.2
+  pass_num_1: 44
+  pass_num_2: 86
+  percent_cases_well_formed: 98.2
+  error_outputs: 8
+  num_malformed_responses: 8
+  num_with_malformed_responses: 4
+  user_asks: 32
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 9
+  total_tests: 225
+  command: aider --model gemini/gemini-exp-1206
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 45.5
+  total_cost: 0.0000
+  
+- dirname: 2024-12-22-20-08-13--gemini-2.0-flash-exp-polyglot-whole
+  test_cases: 225
+  model: gemini-2.0-flash-exp
+  edit_format: whole
+  commit_hash: b1bc2f8
+  pass_rate_1: 11.6
+  pass_rate_2: 22.2
+  pass_num_1: 26
+  pass_num_2: 50
+  percent_cases_well_formed: 100.0
+  error_outputs: 1
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 9
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model gemini/gemini-2.0-flash-exp
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 12.2
+  total_cost: 0.0000

aider/website/_data/polyglot_leaderboard.yml

@@ -0,0 +1,572 @@
+- dirname: 2024-12-21-18-41-18--polyglot-gpt-4o-mini
+  test_cases: 225
+  model: gpt-4o-mini-2024-07-18
+  edit_format: whole
+  commit_hash: a755079-dirty
+  pass_rate_1: 0.9
+  pass_rate_2: 3.6
+  pass_num_1: 2
+  pass_num_2: 8
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 36
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  total_tests: 225
+  command: aider --model gpt-4o-mini-2024-07-18
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 17.3
+  total_cost: 0.3236
+
+- dirname: 2025-01-17-19-44-33--sonnet-baseline-jan-17
+  test_cases: 225
+  model: claude-3-5-sonnet-20241022
+  edit_format: diff
+  commit_hash: 6451d59
+  pass_rate_1: 22.2
+  pass_rate_2: 51.6
+  pass_num_1: 50
+  pass_num_2: 116
+  percent_cases_well_formed: 99.6
+  error_outputs: 2
+  num_malformed_responses: 1
+  num_with_malformed_responses: 1
+  user_asks: 11
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model claude-3-5-sonnet-20241022
+  date: 2025-01-17
+  versions: 0.71.2.dev
+  seconds_per_case: 21.4
+  total_cost: 14.4063
+  
+- dirname: 2024-12-30-20-57-12--gpt-4o-2024-11-20-ex-as-sys
+  test_cases: 225
+  model: gpt-4o-2024-11-20
+  edit_format: diff
+  commit_hash: 09ee197-dirty
+  pass_rate_1: 4.9
+  pass_rate_2: 18.2
+  pass_num_1: 11
+  pass_num_2: 41
+  percent_cases_well_formed: 95.1
+  error_outputs: 12
+  num_malformed_responses: 12
+  num_with_malformed_responses: 11
+  user_asks: 53
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 12
+  total_tests: 225
+  command: aider --model gpt-4o-2024-11-20
+  date: 2024-12-30
+  versions: 0.70.1.dev
+  seconds_per_case: 12.1
+  total_cost: 6.7351
+  
+- dirname: 2024-12-30-20-44-54--gpt4o-ex-as-sys-clean-prompt
+  test_cases: 225
+  model: gpt-4o-2024-08-06
+  edit_format: diff
+  commit_hash: 09ee197-dirty
+  pass_rate_1: 4.9
+  pass_rate_2: 23.1
+  pass_num_1: 11
+  pass_num_2: 52
+  percent_cases_well_formed: 94.2
+  error_outputs: 21
+  num_malformed_responses: 21
+  num_with_malformed_responses: 13
+  user_asks: 65
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  total_tests: 225
+  command: aider --model gpt-4o-2024-08-06
+  date: 2024-12-30
+  versions: 0.70.1.dev
+  seconds_per_case: 16.0
+  total_cost: 7.0286
+  
+- dirname: 2024-12-21-19-23-03--polyglot-o1-hard-diff
+  test_cases: 224
+  model: o1-2024-12-17 (high)
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 23.7
+  pass_rate_2: 61.7
+  pass_num_1: 53
+  pass_num_2: 139
+  percent_cases_well_formed: 91.5
+  error_outputs: 25
+  num_malformed_responses: 24
+  num_with_malformed_responses: 19
+  user_asks: 16
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  total_tests: 225
+  command: aider --model openrouter/openai/o1
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 133.2
+  total_cost: 186.4958
+
+- dirname: 2024-12-21-20-56-21--polyglot-deepseek-diff
+  test_cases: 225
+  model: DeepSeek Chat V2.5
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 5.3
+  pass_rate_2: 17.8
+  pass_num_1: 12
+  pass_num_2: 40
+  percent_cases_well_formed: 92.9
+  error_outputs: 42
+  num_malformed_responses: 37
+  num_with_malformed_responses: 16
+  user_asks: 23
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 5
+  test_timeouts: 5
+  total_tests: 225
+  command: aider --model deepseek/deepseek-chat
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 184.0
+  total_cost: 0.5101
+
+- dirname: 2024-12-21-21-46-27--polyglot-haiku-diff
+  test_cases: 225
+  model: claude-3-5-haiku-20241022
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 7.1
+  pass_rate_2: 28.0
+  pass_num_1: 16
+  pass_num_2: 63
+  percent_cases_well_formed: 91.1
+  error_outputs: 31
+  num_malformed_responses: 30
+  num_with_malformed_responses: 20
+  user_asks: 13
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 9
+  total_tests: 225
+  command: aider --model claude-3-5-haiku-20241022
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 31.8
+  total_cost: 6.0583
+
+- dirname: 2024-12-22-13-22-32--polyglot-qwen-diff
+  test_cases: 225
+  model: Qwen2.5-Coder-32B-Instruct
+  edit_format: diff
+  commit_hash: 6d7e8be-dirty
+  pass_rate_1: 4.4
+  pass_rate_2: 8.0
+  pass_num_1: 10
+  pass_num_2: 18
+  percent_cases_well_formed: 71.6
+  error_outputs: 158
+  num_malformed_responses: 148
+  num_with_malformed_responses: 64
+  user_asks: 132
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 2
+  total_tests: 225
+  command: "aider --model openai/Qwen/Qwen2.5-Coder-32B-Instruct # via hyperbolic"
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 84.4
+  total_cost: 0.0000
+
+- dirname: 2024-12-22-21-26-35--polyglot-o1mini-whole
+  test_cases: 225
+  model: o1-mini-2024-09-12
+  edit_format: whole
+  commit_hash: 37df899
+  pass_rate_1: 5.8
+  pass_rate_2: 32.9
+  pass_num_1: 13
+  pass_num_2: 74
+  percent_cases_well_formed: 96.9
+  error_outputs: 8
+  num_malformed_responses: 8
+  num_with_malformed_responses: 7
+  user_asks: 27
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  total_tests: 225
+  command: aider --model o1-mini
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 34.7
+  total_cost: 18.5770
+
+- dirname: 2024-12-22-18-43-25--gemini-exp-1206-polyglot-whole-2
+  test_cases: 225
+  model: gemini-exp-1206
+  edit_format: whole
+  commit_hash: b1bc2f8
+  pass_rate_1: 19.6
+  pass_rate_2: 38.2
+  pass_num_1: 44
+  pass_num_2: 86
+  percent_cases_well_formed: 98.2
+  error_outputs: 8
+  num_malformed_responses: 8
+  num_with_malformed_responses: 4
+  user_asks: 32
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 9
+  total_tests: 225
+  command: aider --model gemini/gemini-exp-1206
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 45.5
+  total_cost: 0.0000
+  
+- dirname: 2024-12-22-20-08-13--gemini-2.0-flash-exp-polyglot-whole
+  test_cases: 225
+  model: gemini-2.0-flash-exp
+  edit_format: whole
+  commit_hash: b1bc2f8
+  pass_rate_1: 11.6
+  pass_rate_2: 22.2
+  pass_num_1: 26
+  pass_num_2: 50
+  percent_cases_well_formed: 100.0
+  error_outputs: 1
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 9
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model gemini/gemini-2.0-flash-exp
+  date: 2024-12-22
+  versions: 0.69.2.dev
+  seconds_per_case: 12.2
+  total_cost: 0.0000
+  
+- dirname: 2024-12-23-01-11-56--yi-test
+  test_cases: 225
+  model: yi-lightning
+  edit_format: whole
+  commit_hash: 2b1625e
+  pass_rate_1: 5.8
+  pass_rate_2: 12.9
+  pass_num_1: 13
+  pass_num_2: 29
+  percent_cases_well_formed: 92.9
+  error_outputs: 87
+  num_malformed_responses: 72
+  num_with_malformed_responses: 16
+  user_asks: 107
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 6
+  total_tests: 225
+  command: aider --model openai/yi-lightning
+  date: 2024-12-23
+  versions: 0.69.2.dev
+  seconds_per_case: 146.7
+  total_cost: 0.0000
+
+- dirname: 2024-12-25-13-31-51--deepseekv3preview-diff2
+  test_cases: 225
+  model: DeepSeek Chat V3
+  edit_format: diff
+  commit_hash: 0a23c4a-dirty
+  pass_rate_1: 22.7
+  pass_rate_2: 48.4
+  pass_num_1: 51
+  pass_num_2: 109
+  percent_cases_well_formed: 98.7
+  error_outputs: 7
+  num_malformed_responses: 7
+  num_with_malformed_responses: 3
+  user_asks: 19
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model deepseek/deepseek-chat
+  date: 2024-12-25
+  versions: 0.69.2.dev
+  seconds_per_case: 34.8
+  total_cost: 0.3369
+
+- dirname: 2024-12-26-00-55-20--Qwen2.5-Coder-32B-Instruct
+  test_cases: 225
+  model: Qwen2.5-Coder-32B-Instruct
+  edit_format: whole
+  commit_hash: b51768b0
+  pass_rate_1: 4.9
+  pass_rate_2: 16.4
+  pass_num_1: 11
+  pass_num_2: 37
+  percent_cases_well_formed: 99.6
+  error_outputs: 1
+  num_malformed_responses: 1
+  num_with_malformed_responses: 1
+  user_asks: 33
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 6
+  total_tests: 225
+  command: aider --model openai/Qwen2.5-Coder-32B-Instruct
+  date: 2024-12-26
+  versions: 0.69.2.dev
+  seconds_per_case: 42.0
+  total_cost: 0.0000
+
+- dirname: 2025-01-13-18-17-25--codestral-whole2
+  test_cases: 225
+  model: Codestral 25.01
+  edit_format: whole
+  commit_hash: 0cba898-dirty
+  pass_rate_1: 4.0
+  pass_rate_2: 11.1
+  pass_num_1: 9
+  pass_num_2: 25
+  percent_cases_well_formed: 100.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 47
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 4
+  total_tests: 225
+  command: aider --model mistral/codestral-latest
+  date: 2025-01-13
+  versions: 0.71.2.dev
+  seconds_per_case: 9.3
+  total_cost: 1.9834
+
+- dirname: 2025-01-20-19-11-38--ds-turns-upd-cur-msgs-fix-with-summarizer
+  test_cases: 225
+  model: DeepSeek R1
+  edit_format: diff
+  commit_hash: 5650697-dirty
+  pass_rate_1: 26.7
+  pass_rate_2: 56.9
+  pass_num_1: 60
+  pass_num_2: 128
+  percent_cases_well_formed: 96.9
+  error_outputs: 8
+  num_malformed_responses: 7
+  num_with_malformed_responses: 7
+  user_asks: 15
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 5
+  total_tests: 225
+  command: aider --model deepseek/deepseek-reasoner
+  date: 2025-01-20
+  versions: 0.71.2.dev
+  seconds_per_case: 113.7
+  total_cost: 5.4193
+
+- dirname: 2025-01-23-19-14-48--r1-architect-sonnet
+  test_cases: 225
+  model: DeepSeek R1 + claude-3-5-sonnet-20241022
+  edit_format: architect
+  commit_hash: 05a77c7
+  editor_model: claude-3-5-sonnet-20241022
+  editor_edit_format: editor-diff
+  pass_rate_1: 27.1
+  pass_rate_2: 64.0
+  pass_num_1: 61
+  pass_num_2: 144
+  percent_cases_well_formed: 100.0
+  error_outputs: 2
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 392
+  lazy_comments: 6
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 5
+  total_tests: 225
+  command: aider --architect --model r1 --editor-model sonnet
+  date: 2025-01-23
+  versions: 0.72.3.dev
+  seconds_per_case: 251.6
+  total_cost: 13.2933
+
+- dirname: 2025-01-28-16-00-03--qwen-max-2025-01-25-polyglot-diff
+  test_cases: 225
+  model: qwen-max-2025-01-25
+  edit_format: diff
+  commit_hash: ae7d459
+  pass_rate_1: 9.3
+  pass_rate_2: 21.8
+  pass_num_1: 21
+  pass_num_2: 49
+  percent_cases_well_formed: 90.2
+  error_outputs: 46
+  num_malformed_responses: 44
+  num_with_malformed_responses: 22
+  user_asks: 23
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 9
+  total_tests: 225
+  command: OPENAI_API_BASE=https://dashscope-intl.aliyuncs.com/compatible-mode/v1 aider --model openai/qwen-max-2025-01-25
+  date: 2025-01-28
+  versions: 0.72.4.dev
+  seconds_per_case: 39.5
+
+- dirname: 2025-01-31-20-27-46--o3-mini-diff2
+  test_cases: 225
+  model: o3-mini (medium)
+  edit_format: diff
+  commit_hash: 2fb517b-dirty
+  pass_rate_1: 19.1
+  pass_rate_2: 53.8
+  pass_num_1: 43
+  pass_num_2: 121
+  percent_cases_well_formed: 95.1
+  error_outputs: 28
+  num_malformed_responses: 28
+  num_with_malformed_responses: 11
+  user_asks: 17
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  total_tests: 225
+  command: aider --model o3-mini
+  date: 2025-01-31
+  versions: 0.72.4.dev
+  seconds_per_case: 47.2
+  total_cost: 8.8599
+
+- dirname: 2025-01-31-20-42-47--o3-mini-diff-high
+  test_cases: 224
+  model: o3-mini (high)
+  edit_format: diff
+  commit_hash: b0d58d1-dirty
+  pass_rate_1: 21.0
+  pass_rate_2: 60.4
+  pass_num_1: 47
+  pass_num_2: 136
+  percent_cases_well_formed: 93.3
+  error_outputs: 26
+  num_malformed_responses: 24
+  num_with_malformed_responses: 15
+  user_asks: 19
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 7
+  total_tests: 225
+  command: aider --model o3-mini --reasoning-effort high
+  date: 2025-01-31
+  versions: 0.72.4.dev
+  seconds_per_case: 124.6
+  total_cost: 18.1584
+
+- dirname: 2025-01-21-22-51-49--gemini-2.0-flash-thinking-exp-01-21-polyglot-diff
+  test_cases: 225
+  model: gemini-2.0-flash-thinking-exp-01-21
+  edit_format: diff
+  commit_hash: 843720a
+  pass_rate_1: 5.8
+  pass_rate_2: 18.2
+  pass_num_1: 13
+  pass_num_2: 41
+  percent_cases_well_formed: 77.8
+  error_outputs: 182
+  num_malformed_responses: 180
+  num_with_malformed_responses: 50
+  user_asks: 26
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 2
+  test_timeouts: 7
+  total_tests: 225
+  command: aider --model gemini/gemini-2.0-flash-thinking-exp-01-21
+  date: 2025-01-21
+  versions: 0.72.2.dev
+  seconds_per_case: 24.2
+  total_cost: 0.0000
+
+- dirname: 2025-02-15-19-51-22--chatgpt4o-feb15-diff
+  test_cases: 223
+  model: chatgpt-4o-latest (2025-02-15)
+  edit_format: diff
+  commit_hash: 108ce18-dirty
+  pass_rate_1: 9.0
+  pass_rate_2: 27.1
+  pass_num_1: 20
+  pass_num_2: 61
+  percent_cases_well_formed: 93.3
+  error_outputs: 66
+  num_malformed_responses: 21
+  num_with_malformed_responses: 15
+  user_asks: 57
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  total_tests: 225
+  command: aider --model chatgpt-4o-latest
+  date: 2025-02-15
+  versions: 0.74.3.dev
+  seconds_per_case: 12.4
+  total_cost: 14.3703

aider/website/_data/quant.yml

@@ -0,0 +1,322 @@
+- dirname: 2024-11-09-11-09-15--Qwen2.5-Coder-32B-Instruct
+  test_cases: 133
+  model: "HuggingFace via GLHF: BF16"
+  released: 2024-11-12
+  edit_format: diff
+  commit_hash: ec9982a
+  pass_rate_1: 59.4
+  pass_rate_2: 71.4
+  percent_cases_well_formed: 94.7
+  error_outputs: 17
+  num_malformed_responses: 17
+  num_with_malformed_responses: 7
+  user_asks: 1
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model openai/hf:Qwen/Qwen2.5-Coder-32B-Instruct --openai-api-base https://glhf.chat/api/openai/v1
+  date: 2024-11-09
+  versions: 0.59.2.dev
+  seconds_per_case: 22.5
+  total_cost: 0.0000
+
+- dirname: 2024-11-22-18-56-13--ollama-qwen2.5-coder:32b-instruct-fp16
+  test_cases: 132
+  model: "Ollama: fp16"
+  edit_format: diff
+  commit_hash: f06452c-dirty, 6a0a97c-dirty, 4e9ae16-dirty, 5506d0f-dirty
+  pass_rate_1: 58.3
+  pass_rate_2: 71.4
+  percent_cases_well_formed: 90.2
+  error_outputs: 27
+  num_malformed_responses: 26
+  num_with_malformed_responses: 13
+  user_asks: 2
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --model ollama/qwen2.5-coder:32b-instruct-fp16
+  date: 2024-11-22
+  versions: 0.64.2.dev
+  seconds_per_case: 119.6
+  total_cost: 0.0000
+  
+- dirname: 2024-11-22-14-53-26--hyperbolic-qwen25coder32binstruct
+  test_cases: 133
+  model: "Hyperbolic: BF16"
+  edit_format: diff
+  commit_hash: f9ef161, 17aef7b-dirty
+  pass_rate_1: 57.9
+  pass_rate_2: 69.2
+  percent_cases_well_formed: 91.7
+  error_outputs: 30
+  num_malformed_responses: 29
+  num_with_malformed_responses: 11
+  user_asks: 9
+  lazy_comments: 0
+  syntax_errors: 4
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  command: aider --model openai/Qwen/Qwen2.5-Coder-32B-Instruct --openai-api-base https://api.hyperbolic.xyz/v1/
+  date: 2024-11-22
+  versions: 0.64.2.dev
+  seconds_per_case: 33.2
+  total_cost: 0.0000
+  
+- dirname: 2024-11-22-17-53-35--qwen25-coder-32b-Instruct-4bit
+  test_cases: 133
+  model: "mlx-community: 4bit"
+  edit_format: diff
+  commit_hash: a16dcab-dirty
+  pass_rate_1: 60.2
+  pass_rate_2: 72.2
+  percent_cases_well_formed: 88.7
+  error_outputs: 31
+  num_malformed_responses: 30
+  num_with_malformed_responses: 15
+  user_asks: 6
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 0
+  command: aider --model openai/mlx-community/Qwen2.5-Coder-32B-Instruct-4bit
+  date: 2024-11-23
+  versions: 0.64.2.dev
+  seconds_per_case: 53.4
+  total_cost: 0.0000
+
+- dirname: 2024-11-23-15-07-20--qwen25-coder-32b-Instruct-8bit
+  test_cases: 133
+  model: "mlx-community: 8bit"
+  edit_format: diff
+  commit_hash: a16dcab-dirty
+  pass_rate_1: 59.4
+  pass_rate_2: 72.2
+  percent_cases_well_formed: 92.5
+  error_outputs: 20
+  num_malformed_responses: 15
+  num_with_malformed_responses: 10
+  user_asks: 7
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 5
+  test_timeouts: 2
+  command: aider --model openai/mlx-community/Qwen2.5-Coder-32B-Instruct-8bit
+  date: 2024-11-23
+  versions: 0.64.2.dev
+  seconds_per_case: 98.4
+  total_cost: 0.0000
+
+- dirname: 2024-11-24-22-18-18--or-all-or-fixed-blank-messages2
+  test_cases: 133
+  model: "OpenRouter: multiple"
+  edit_format: diff
+  commit_hash: 0c59d32
+  pass_rate_1: 57.1
+  pass_rate_2: 67.7
+  percent_cases_well_formed: 95.5
+  error_outputs: 56
+  num_malformed_responses: 10
+  num_with_malformed_responses: 6
+  user_asks: 14
+  lazy_comments: 0
+  syntax_errors: 6
+  indentation_errors: 0
+  exhausted_context_windows: 3
+  test_timeouts: 1
+  command: aider --model openrouter/qwen/qwen-2.5-coder-32b-instruct
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 21.2
+  total_cost: 0.1420
+  
+- dirname: 2024-11-23-21-08-53--ollama-qwen2.5-coder:32b-instruct-q4_K_M-8kctx
+  test_cases: 133
+  model: "Ollama: q4_K_M"
+  edit_format: diff
+  commit_hash: baa1335-dirty, e63df83-dirty, ff8c1aa-dirty
+  pass_rate_1: 54.9
+  pass_rate_2: 66.9
+  percent_cases_well_formed: 94.0
+  error_outputs: 21
+  num_malformed_responses: 21
+  num_with_malformed_responses: 8
+  user_asks: 5
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model ollama/qwen2.5-coder:32b-instruct-q4_K_M
+  date: 2024-11-23
+  versions: 0.64.2.dev
+  seconds_per_case: 35.7
+  total_cost: 0.0000
+
+- dirname: 2024-11-24-02-23-32--deepinfra-qwen-diff
+  test_cases: 133
+  model: "Deepinfra: BF16"
+  edit_format: diff
+  commit_hash: bb78e2f
+  pass_rate_1: 58.6
+  pass_rate_2: 72.2
+  percent_cases_well_formed: 94.7
+  error_outputs: 15
+  num_malformed_responses: 13
+  num_with_malformed_responses: 7
+  user_asks: 3
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 2
+  test_timeouts: 3
+  command: aider --model deepinfra/Qwen/Qwen2.5-Coder-32B-Instruct
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 17.5
+  total_cost: 0.0000
+
+- dirname: 2024-11-24-04-12-58--fireworks-qwen-diff
+  test_cases: 133
+  model: "Fireworks: unknown"
+  edit_format: diff
+  commit_hash: 757eac0
+  pass_rate_1: 57.9
+  pass_rate_2: 72.2
+  percent_cases_well_formed: 94.0
+  error_outputs: 23
+  num_malformed_responses: 19
+  num_with_malformed_responses: 8
+  user_asks: 8
+  lazy_comments: 0
+  syntax_errors: 6
+  indentation_errors: 0
+  exhausted_context_windows: 4
+  test_timeouts: 1
+  command: aider --model fireworks_ai/accounts/fireworks/models/qwen2p5-coder-32b-instruct
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 10.4
+  total_cost: 0.5759
+
+- dirname: 2024-11-24-02-04-59--ollama-qwen2.5-coder:32b-instruct-q2_K-8kctx
+  test_cases: 133
+  model: "Ollama: q2_K"
+  edit_format: diff
+  commit_hash: 757eac0, bb78e2f, 8d0ba40-dirty, 1d09e96
+  pass_rate_1: 48.9
+  pass_rate_2: 61.7
+  percent_cases_well_formed: 91.7
+  error_outputs: 32
+  num_malformed_responses: 32
+  num_with_malformed_responses: 11
+  user_asks: 8
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model ollama/qwen2.5-coder:32b-instruct-q2_K
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 97.8
+  total_cost: 0.0000
+
+- dirname: 2024-11-24-14-56-49--qwen25-32b-or-fireworks
+  test_cases: 133
+  model: "Fireworks via OpenRouter: unknown"
+  edit_format: diff
+  commit_hash: c2f184f
+  pass_rate_1: 55.6
+  pass_rate_2: 67.7
+  percent_cases_well_formed: 94.0
+  error_outputs: 39
+  num_malformed_responses: 24
+  num_with_malformed_responses: 8
+  user_asks: 13
+  lazy_comments: 0
+  syntax_errors: 1
+  indentation_errors: 1
+  exhausted_context_windows: 7
+  test_timeouts: 4
+  command: aider --model openrouter/qwen/qwen-2.5-coder-32b-instruct
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 16.1
+  total_cost: 0.1391
+
+- dirname: 2024-11-24-22-03-19--or-hyperbolic-or-fixed-blank-messages2
+  test_cases: 133
+  model: "Hyperbolic via OpenRouter: BF16"
+  edit_format: diff
+  commit_hash: 0c59d32
+  pass_rate_1: 55.6
+  pass_rate_2: 68.4
+  percent_cases_well_formed: 89.5
+  error_outputs: 28
+  num_malformed_responses: 24
+  num_with_malformed_responses: 14
+  user_asks: 29
+  lazy_comments: 0
+  syntax_errors: 1
+  indentation_errors: 0
+  exhausted_context_windows: 4
+  test_timeouts: 1
+  command: aider --model openrouter/qwen/qwen-2.5-coder-32b-instruct
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 41.5
+  total_cost: 0.1402
+  
+- dirname: 2024-11-24-15-00-50--qwen25-32b-or-deepinfra
+  test_cases: 133
+  model: "Deepinfra via OpenRouter: BF16"
+  edit_format: diff
+  commit_hash: c2f184f
+  pass_rate_1: 57.1
+  pass_rate_2: 69.9
+  percent_cases_well_formed: 89.5
+  error_outputs: 35
+  num_malformed_responses: 31
+  num_with_malformed_responses: 14
+  user_asks: 11
+  lazy_comments: 0
+  syntax_errors: 1
+  indentation_errors: 1
+  exhausted_context_windows: 4
+  test_timeouts: 1
+  command: aider --model openrouter/qwen/qwen-2.5-coder-32b-instruct
+  date: 2024-11-24
+  versions: 0.64.2.dev
+  seconds_per_case: 28.5
+  total_cost: 0.1390
+
+- dirname: 2024-11-26-03-15-06--ollama-qwen2.5-coder:32b-instruct-fp16-2kctx
+  test_cases: 132
+  model: "Ollama: fp16, 2k ctx"
+  edit_format: diff
+  commit_hash: 68be6c5-dirty, 554d274, 2ff3a23, 2ff3a23-dirty, 61759f9, dd48b74, 3ebd47d-dirty
+  pass_rate_1: 43.2
+  pass_rate_2: 51.9
+  percent_cases_well_formed: 46.2
+  error_outputs: 171
+  num_malformed_responses: 165
+  num_with_malformed_responses: 71
+  user_asks: 97
+  lazy_comments: 2
+  syntax_errors: 4
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: "aider --model ollama/qwen2.5-coder:32b-instruct-fp16 # num_ctx: 2048"
+  date: 2024-11-26
+  versions: 0.64.2.dev,0.65.1.dev
+  seconds_per_case: 188.6
+  total_cost: 0.0000

aider/website/_data/qwq.yml

@@ -0,0 +1,170 @@
+
+- dirname: 2024-11-28-21-38-50--architect-qwq-haiku-whole
+  test_cases: 133
+  model: QwQ + Haiku
+  edit_format: architect
+  commit_hash: e4a1d6f
+  editor_model: claude-3-5-haiku-20241022
+  editor_edit_format: editor-whole
+  pass_rate_1: 54.1
+  pass_rate_2: 71.4
+  percent_cases_well_formed: 100.0
+  error_outputs: 4
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 196
+  lazy_comments: 4
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --model openrouter/qwen/qwq-32b-preview --editor-model claude-3-5-haiku-20241022 --edit-format editor-whole
+  date: 2024-11-28
+  versions: 0.65.2.dev
+  seconds_per_case: 154.7
+  total_cost: 1.4196
+
+- dirname: 2024-11-28-19-24-35--architect-qwq-deepseek-whole
+  test_cases: 133
+  model: QwQ + DeepSeek V2.5
+  edit_format: architect
+  commit_hash: e4a1d6f
+  editor_model: deepseek/deepseek-chat
+  editor_edit_format: editor-whole
+  pass_rate_1: 55.6
+  pass_rate_2: 67.7
+  percent_cases_well_formed: 100.0
+  error_outputs: 3
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 193
+  lazy_comments: 2
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --model openrouter/qwen/qwq-32b-preview --editor-model deepseek/deepseek-chat --edit-format editor-whole
+  date: 2024-11-28
+  versions: 0.65.2.dev
+  seconds_per_case: 170.3
+  total_cost: 0.1558
+
+
+- dirname: 2024-11-09-11-09-15--Qwen2.5-Coder-32B-Instruct
+  test_cases: 133
+  model: Qwen2.5 Coder 32B-I
+  released: 2024-11-12
+  edit_format: diff
+  commit_hash: ec9982a
+  pass_rate_1: 59.4
+  pass_rate_2: 71.4
+  percent_cases_well_formed: 94.7
+  error_outputs: 17
+  num_malformed_responses: 17
+  num_with_malformed_responses: 7
+  user_asks: 1
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 3
+  command: aider --model openai/hf:Qwen/Qwen2.5-Coder-32B-Instruct --openai-api-base https://glhf.chat/api/openai/v1 (via GLHF)
+  date: 2024-11-09
+  versions: 0.59.2.dev
+  seconds_per_case: 22.5
+  total_cost: 0.0000
+
+- dirname: 2024-12-04-00-10-39--architect-qwq-qwen
+  test_cases: 132
+  model: QwQ + Qwen2.5 Coder 32B-I
+  edit_format: architect
+  commit_hash: 51c02da
+  editor_model: openrouter/qwen/qwen-2.5-coder-32b-instruct
+  editor_edit_format: editor-whole
+  pass_rate_1: 58.3
+  pass_rate_2: 73.6
+  percent_cases_well_formed: 100.0
+  error_outputs: 3
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 186
+  lazy_comments: 5
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --model openrouter/qwen/qwq-32b-preview --editor-model openrouter/qwen/qwen-2.5-coder-32b-instruct --editor-edit-format editor-whole
+  date: 2024-12-04
+  versions: 0.66.1.dev
+  seconds_per_case: 144.1
+  total_cost: 0.1444
+
+- dirname: 2024-12-04-00-42-05--qwq-alone-whole
+  test_cases: 133
+  model: QwQ
+  edit_format: whole
+  commit_hash: 19004c0
+  pass_rate_1: 33.1
+  pass_rate_2: 42.1
+  percent_cases_well_formed: 91.0
+  error_outputs: 28
+  num_malformed_responses: 12
+  num_with_malformed_responses: 12
+  user_asks: 119
+  lazy_comments: 2
+  syntax_errors: 22
+  indentation_errors: 9
+  exhausted_context_windows: 2
+  test_timeouts: 1
+  command: aider --model openrouter/qwen/qwq-32b-preview
+  date: 2024-12-04
+  versions: 0.66.1.dev
+  seconds_per_case: 414.3
+  total_cost: 0.0000
+
+- dirname: 2024-09-12-19-57-35--o1-mini-whole
+  test_cases: 133
+  model: o1-mini
+  edit_format: whole
+  commit_hash: 36fa773-dirty, 291b456
+  pass_rate_1: 49.6
+  pass_rate_2: 70.7
+  percent_cases_well_formed: 90.0
+  error_outputs: 0
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 17
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model o1-mini
+  date: 2024-09-12
+  versions: 0.56.1.dev
+  seconds_per_case: 103.0
+  total_cost: 5.3725
+
+- dirname: 2024-09-21-16-45-11--o1-preview-flex-sr-markers
+  test_cases: 133
+  model: o1-preview
+  _released: 2024-09-12
+  edit_format: diff
+  commit_hash: 5493654-dirty
+  pass_rate_1: 57.9
+  pass_rate_2: 79.7
+  percent_cases_well_formed: 93.2
+  error_outputs: 11
+  num_malformed_responses: 11
+  num_with_malformed_responses: 9
+  user_asks: 3
+  lazy_comments: 0
+  syntax_errors: 10
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 1
+  command: aider --model o1-preview
+  date: 2024-09-21
+  versions: 0.56.1.dev
+  seconds_per_case: 80.9
+  total_cost: 63.9190

aider/website/_data/r1_architect.yml

@@ -0,0 +1,138 @@
+
+
+
+- dirname: 2025-01-23-19-14-48--r1-architect-sonnet
+  test_cases: 225
+  model: R1+Sonnet
+  edit_format: architect
+  commit_hash: 05a77c7
+  editor_model: claude-3-5-sonnet-20241022
+  editor_edit_format: editor-diff
+  pass_rate_1: 27.1
+  pass_rate_2: 64.0
+  pass_num_1: 61
+  pass_num_2: 144
+  percent_cases_well_formed: 100.0
+  error_outputs: 2
+  num_malformed_responses: 0
+  num_with_malformed_responses: 0
+  user_asks: 392
+  lazy_comments: 6
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 5
+  total_tests: 225
+  command: aider --architect --model r1 --editor-model sonnet
+  date: 2025-01-23
+  versions: 0.72.3.dev
+  seconds_per_case: 251.6
+  total_cost: 13.2933
+
+- dirname: 2025-01-20-19-11-38--ds-turns-upd-cur-msgs-fix-with-summarizer
+  test_cases: 225
+  model: R1
+  edit_format: diff
+  commit_hash: 5650697-dirty
+  pass_rate_1: 26.7
+  pass_rate_2: 56.9
+  pass_num_1: 60
+  pass_num_2: 128
+  percent_cases_well_formed: 96.9
+  error_outputs: 8
+  num_malformed_responses: 7
+  num_with_malformed_responses: 7
+  user_asks: 15
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 5
+  total_tests: 225
+  command: aider --model r1
+  date: 2025-01-20
+  versions: 0.71.2.dev
+  seconds_per_case: 113.7
+  total_cost: 5.4193
+
+
+- dirname: 2024-12-21-19-23-03--polyglot-o1-hard-diff
+  test_cases: 224
+  model: o1
+  edit_format: diff
+  commit_hash: a755079-dirty
+  pass_rate_1: 23.7
+  pass_rate_2: 61.7
+  pass_num_1: 53
+  pass_num_2: 139
+  percent_cases_well_formed: 91.5
+  error_outputs: 25
+  num_malformed_responses: 24
+  num_with_malformed_responses: 19
+  user_asks: 16
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 2
+  total_tests: 225
+  command: aider --model o1
+  date: 2024-12-21
+  versions: 0.69.2.dev
+  seconds_per_case: 133.2
+  total_cost: 186.4958
+
+
+- dirname: 2024-12-25-13-31-51--deepseekv3preview-diff2
+  test_cases: 225
+  model: DeepSeek V3
+  edit_format: diff
+  commit_hash: 0a23c4a-dirty
+  pass_rate_1: 22.7
+  pass_rate_2: 48.4
+  pass_num_1: 51
+  pass_num_2: 109
+  percent_cases_well_formed: 98.7
+  error_outputs: 7
+  num_malformed_responses: 7
+  num_with_malformed_responses: 3
+  user_asks: 19
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model deepseek
+  date: 2024-12-25
+  versions: 0.69.2.dev
+  seconds_per_case: 34.8
+  total_cost: 0.3369
+
+
+
+- dirname: 2025-01-17-19-44-33--sonnet-baseline-jan-17
+  test_cases: 225
+  model: Sonnet
+  edit_format: diff
+  commit_hash: 6451d59
+  pass_rate_1: 22.2
+  pass_rate_2: 51.6
+  pass_num_1: 50
+  pass_num_2: 116
+  percent_cases_well_formed: 99.6
+  error_outputs: 2
+  num_malformed_responses: 1
+  num_with_malformed_responses: 1
+  user_asks: 11
+  lazy_comments: 0
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 1
+  test_timeouts: 8
+  total_tests: 225
+  command: aider --model sonnet
+  date: 2025-01-17
+  versions: 0.71.2.dev
+  seconds_per_case: 21.4
+  total_cost: 14.4063

aider/website/_data/refactor_leaderboard.yml

@@ -145,7 +145,7 @@
 
 - dirname: 2024-07-01-18-30-33--refac-claude-3.5-sonnet-diff-not-lazy
   test_cases: 89
-  model: claude-3.5-sonnet (diff)
+  model: claude-3.5-sonnet-20240620
   edit_format: diff
   commit_hash: 7396e38-dirty
   pass_rate_1: 64.0
@@ -230,3 +230,69 @@
   versions: 0.55.1.dev
   seconds_per_case: 225.4
   total_cost: 1.0338
+
+- dirname: 2024-10-22-19-57-27--refac-openrouter-sonnet-1022
+  test_cases: 89
+  model: claude-3-5-sonnet-20241022
+  edit_format: diff
+  commit_hash: 4a3e6ef
+  pass_rate_1: 92.1
+  percent_cases_well_formed: 91.0
+  error_outputs: 13
+  num_malformed_responses: 12
+  num_with_malformed_responses: 8
+  user_asks: 14
+  lazy_comments: 2
+  syntax_errors: 0
+  indentation_errors: 0
+  exhausted_context_windows: 0
+  test_timeouts: 0
+  command: aider --sonnet
+  date: 2024-10-22
+  versions: 0.60.1.dev
+  seconds_per_case: 32.5
+  total_cost: 8.4644
+
+- dirname: 2024-10-22-20-03-10--refac-o1mini
+  test_cases: 89
+  model: o1-mini
+  edit_format: diff
+  commit_hash: 4a3e6ef-dirty
+  pass_rate_1: 44.9
+  percent_cases_well_formed: 29.2
+  error_outputs: 151
+  num_malformed_responses: 150
+  num_with_malformed_responses: 63
+  user_asks: 28
+  lazy_comments: 2
+  syntax_errors: 5
+  indentation_errors: 4
+  exhausted_context_windows: 1
+  test_timeouts: 0
+  command: aider --model o1-mini
+  date: 2024-10-22
+  versions: 0.60.1.dev
+  seconds_per_case: 115.3
+  total_cost: 29.0492
+
+- dirname: 2024-10-22-20-26-36--refac-o1preview
+  test_cases: 89
+  model: o1-preview
+  edit_format: diff
+  commit_hash: 4a3e6ef-dirty
+  pass_rate_1: 75.3
+  percent_cases_well_formed: 57.3
+  error_outputs: 75
+  num_malformed_responses: 74
+  num_with_malformed_responses: 38
+  user_asks: 19
+  lazy_comments: 2
+  syntax_errors: 2
+  indentation_errors: 3
+  exhausted_context_windows: 1
+  test_timeouts: 0
+  command: aider --model o1-preview
+  date: 2024-10-22
+  versions: 0.60.1.dev
+  seconds_per_case: 231.7
+  total_cost: 120.9850

aider/website/_includes/blame.md

@@ -1,5 +1,18 @@
-<canvas id="blameChart" width="800" height="360" style="margin-top: 20px"></canvas>
+<div class="chart-container">
-<canvas id="linesChart" width="800" height="360" style="margin-top: 20px"></canvas>
+    <canvas id="blameChart" style="margin-top: 20px"></canvas>
+</div>
+<div class="chart-container">
+    <canvas id="linesChart" style="margin-top: 20px"></canvas>
+</div>
+
+<style>
+.chart-container {
+    position: relative;
+    width: 100%;
+    height: 300px;
+}
+</style>
+
 <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/moment"></script>
 <script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-moment"></script>
@@ -24,10 +37,17 @@ document.addEventListener('DOMContentLoaded', function () {
     var linesData = {
         labels: labels,
         datasets: [{
-            label: 'Aider\'s lines of new code',
+            label: 'Aider',
             data: [{% for row in site.data.blame %}{ x: '{{ row.end_tag }}', y: {{ row.aider_total }} },{% endfor %}],
-            backgroundColor: 'rgba(255, 99, 132, 0.8)',
+            backgroundColor: 'rgba(54, 162, 235, 0.8)',
-            borderColor: 'rgba(255, 99, 132, 1)',
+            borderColor: 'rgba(54, 162, 235, 1)',
+            borderWidth: 1
+        },
+        {
+            label: 'Human',
+            data: [{% for row in site.data.blame %}{ x: '{{ row.end_tag }}', y: {{ row.total_lines | minus: row.aider_total }} },{% endfor %}],
+            backgroundColor: 'rgba(200, 200, 200, 0.8)',
+            borderColor: 'rgba(200, 200, 200, 1)',
             borderWidth: 1
         }]
     };
@@ -36,6 +56,7 @@ document.addEventListener('DOMContentLoaded', function () {
         type: 'bar',
         data: blameData,
         options: {
+            maintainAspectRatio: false,
             scales: {
                 x: {
                     type: 'category',
@@ -85,9 +106,11 @@ document.addEventListener('DOMContentLoaded', function () {
         type: 'bar',
         data: linesData,
         options: {
+            maintainAspectRatio: false,
             scales: {
                 x: {
                     type: 'category',
+                    stacked: true,
                     title: {
                         display: true,
                         text: 'Version'
@@ -98,6 +121,7 @@ document.addEventListener('DOMContentLoaded', function () {
                     }
                 },
                 y: {
+                    stacked: true,
                     title: {
                         display: true,
                         text: 'Lines of new code'
@@ -107,12 +131,14 @@ document.addEventListener('DOMContentLoaded', function () {
             },
             plugins: {
                 legend: {
-                    display: false
+                    display: true,
+                    position: 'chartArea',
+                    reverse: true
                 },
                 tooltip: {
                     callbacks: {
                         label: function(context) {
-                            var label = 'New lines of code by aider';
+                            var label = context.dataset.label;
                             var value = context.parsed.y || 0;
                             return `${label}: ${value}`;
                         }
@@ -120,7 +146,7 @@ document.addEventListener('DOMContentLoaded', function () {
                 },
                 title: {
                     display: true,
-                    text: 'Lines of new code written by aider, by release',
+                    text: 'Lines of new code, by release',
                     font: {
                         size: 16
                     }

aider/website/_includes/env-keys-tip.md

@@ -1,6 +0,0 @@
-{: .tip }
-All API keys can be stored in a
-[.env file](/docs/config/dotenv.html).
-Only OpenAI and Anthropic keys can be stored in the
-[YAML config file](/docs/config/aider_conf.html).
-