set version to 0.82.4.dev

fix: add suffix "md" when opening editor in InputOutput class

.github/workflows/check_pypi_version.yml

@@ -0,0 +1,86 @@
+name: Check PyPI Version
+
+# Check to be sure `pip install aider-chat` installs the most recently published version.
+# If dependencies get yanked, it may render the latest version uninstallable.
+# See https://github.com/Aider-AI/aider/issues/3699 for example.
+
+on:
+  schedule:
+    # Run once a day at midnight UTC
+    - cron: '0 0 * * *'
+  workflow_dispatch: # Allows manual triggering
+
+jobs:
+  check_version:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install aider-chat
+        run: pip install aider-chat
+
+      - name: Get installed aider version
+        id: installed_version
+        run: |
+          set -x # Enable debugging output
+          aider_version_output=$(aider --version)
+          if [ $? -ne 0 ]; then
+            echo "Error: 'aider --version' command failed."
+            exit 1
+          fi
+          echo "Raw aider --version output: $aider_version_output"
+
+          # Extract version number (format X.Y.Z)
+          version_num=$(echo "$aider_version_output" | grep -oP '\d+\.\d+\.\d+')
+
+          # Check if grep found anything
+          if [ -z "$version_num" ]; then
+            echo "Error: Could not extract version number using grep -oP '\d+\.\d+\.\d+' from output: $aider_version_output"
+            exit 1
+          fi
+
+          echo "Extracted version number: $version_num"
+          echo "version=$version_num" >> $GITHUB_OUTPUT
+
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Fetch all history for all tags
+
+      - name: Get latest tag
+        id: latest_tag
+        run: |
+          set -x # Enable debugging output
+          # Fetch all tags from remote just in case
+          git fetch --tags origin main
+          # Get the latest tag that strictly matches vX.Y.Z (no suffixes like .dev)
+          # List all tags, sort by version descending, filter for exact pattern, take the first one
+          latest_tag=$(git tag --sort=-v:refname | grep -P '^v\d+\.\d+\.\d+$' | head -n 1)
+
+          if [ -z "$latest_tag" ]; then
+            echo "Error: Could not find any tags matching the pattern '^v\d+\.\d+\.\d+$'"
+            exit 1
+          fi
+
+          echo "Latest non-dev tag: $latest_tag"
+          # Remove 'v' prefix for comparison
+          tag_num=${latest_tag#v}
+          echo "Extracted tag number: $tag_num"
+          echo "tag=$tag_num" >> $GITHUB_OUTPUT
+
+      - name: Compare versions
+        run: |
+          echo "Installed version: ${{ steps.installed_version.outputs.version }}"
+          echo "Latest tag version: ${{ steps.latest_tag.outputs.tag }}"
+          if [ "${{ steps.installed_version.outputs.version }}" != "${{ steps.latest_tag.outputs.tag }}" ]; then
+            echo "Error: Installed aider version (${{ steps.installed_version.outputs.version }}) does not match the latest tag (${{ steps.latest_tag.outputs.tag }})."
+            exit 1
+          fi
+          echo "Versions match."

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

@@ -4,34 +4,46 @@ on:
   push:
     paths-ignore:
       - 'aider/website/**'
-      - README.md
-      - HISTORY.md
+      - 'README.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: Build Docker standard image
+    - name: Login to DockerHub
+      if: ${{ github.event_name != 'pull_request' }}
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+    - name: Build Docker images (PR)
+      if: ${{ github.event_name == 'pull_request' }}
       uses: docker/build-push-action@v5
       with:
         context: .
@@ -40,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: .
@@ -48,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@v1
+        uses: actions/upload-pages-artifact@v3
         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
-      - HISTORY.md
+      - 'README.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
-      - HISTORY.md
+      - 'README.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
         

.github/workflows/windows_check_pypi_version.yml

@@ -0,0 +1,90 @@
+name: Windows Check PyPI Version
+
+# Check to be sure `pip install aider-chat` installs the most recently published version on Windows.
+# If dependencies get yanked, it may render the latest version uninstallable.
+# See https://github.com/Aider-AI/aider/issues/3699 for example.
+
+on:
+  schedule:
+    # Run once a day at 1 AM UTC (offset from Ubuntu check)
+    - cron: '0 1 * * *'
+  workflow_dispatch: # Allows manual triggering
+
+jobs:
+  check_version:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+    defaults:
+      run:
+        shell: pwsh # Use PowerShell for all run steps
+
+    steps:
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install aider-chat
+        run: pip install aider-chat
+
+      - name: Get installed aider version
+        id: installed_version
+        run: |
+          Write-Host "Running 'aider --version'..."
+          $aider_version_output = aider --version
+          if ($LASTEXITCODE -ne 0) {
+            Write-Error "Error: 'aider --version' command failed."
+            exit 1
+          }
+          Write-Host "Raw aider --version output: $aider_version_output"
+
+          # Extract version number (format X.Y.Z) using PowerShell regex
+          $match = [regex]::Match($aider_version_output, '\d+\.\d+\.\d+')
+
+          if (-not $match.Success) {
+            Write-Error "Error: Could not extract version number using regex '\d+\.\d+\.\d+' from output: $aider_version_output"
+            exit 1
+          }
+          $version_num = $match.Value
+
+          Write-Host "Extracted version number: $version_num"
+          echo "version=$version_num" >> $env:GITHUB_OUTPUT
+
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Fetch all history for all tags
+
+      - name: Get latest tag
+        id: latest_tag
+        run: |
+          Write-Host "Fetching tags..."
+          # Fetch all tags from remote just in case
+          git fetch --tags origin main
+          Write-Host "Getting latest non-dev tag..."
+          # Get the latest tag that strictly matches vX.Y.Z (no suffixes like .dev)
+          # List all tags, sort by version descending, filter for exact pattern, take the first one
+          $latest_tag = (git tag --sort=-v:refname | Select-String -Pattern '^v\d+\.\d+\.\d+$' | Select-Object -First 1).Line
+
+          if (-not $latest_tag) {
+            Write-Error "Error: Could not find any tags matching the pattern '^v\d+\.\d+\.\d+$'"
+            exit 1
+          }
+
+          Write-Host "Latest non-dev tag: $latest_tag"
+          # Remove 'v' prefix for comparison
+          $tag_num = $latest_tag.Substring(1)
+          Write-Host "Extracted tag number: $tag_num"
+          echo "tag=$tag_num" >> $env:GITHUB_OUTPUT
+
+      - name: Compare versions
+        run: |
+          Write-Host "Installed version: ${{ steps.installed_version.outputs.version }}"
+          Write-Host "Latest tag version: ${{ steps.latest_tag.outputs.tag }}"
+          if ("${{ steps.installed_version.outputs.version }}" -ne "${{ steps.latest_tag.outputs.tag }}") {
+            Write-Error "Error: Installed aider version (${{ steps.installed_version.outputs.version }}) does not match the latest tag (${{ steps.latest_tag.outputs.tag }})."
+            exit 1
+          }
+          Write-Host "Versions match."

.gitignore

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

.pre-commit-config.yaml

@@ -18,5 +18,6 @@ repos:
     rev: v2.2.6
     hooks:
       - id: codespell
+        args: ["--skip", "aider/website/docs/languages.md"]
         additional_dependencies:
           - tomli

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
-will be licensed under the Apache License 2.0. Additionally, you
-understand and agree that contributions may be subject to a different
-license, should the project maintainers decide to change the licensing
-terms.
-
+Before contributing a PR, please review our
+[Individual Contributor License Agreement](https://aider.chat/docs/legal/contributor-agreement.html).
+All contributors will be asked to complete the agreement as part of the PR process.
 
 ## 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
@@ -190,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 aider/tests/test_coder.py::TestCoder::test_specific_case
+pytest tests/basic/test_coder.py
+pytest tests/basic/test_coder.py::TestCoder::test_specific_case
 ```
 
 #### Continuous Integration

HISTORY.md

@@ -1,6 +1,568 @@
-
 # Release history
 
+### main branch
+
+- Add support for `gemini-2.5-flash-preview-04-17` models.
+- Improved robustness of edit block parsing when filenames start with backticks or fences.
+- Add new `udiff-simple` edit format, for Gemini 2.5 Pro.
+- Update default weak/editor models for Gemini 2.5 Pro models to use `gemini-2.5-flash-preview-04-17`.
+- Instruct models to reply in the user's detected system language.
+- Fix parsing of diffs for newly created files (`--- /dev/null`).
+- Add markdown syntax highlighting support when editing multi-line commit messages via `/commit`, by Kay Gosho.
+- Set Gemini 2.5 Pro models to use the `overeager` prompt setting by default.
+- Add common file types (`.svg`, `.pdf`) and IDE directories (`.idea/`, `.vscode/`, etc.) to the default list of ignored files for AI comment scanning (`--watch`).
+- Skip scanning files larger than 1MB for AI comments (`--watch`).
+- Aider wrote 67% of the code in this release.
+
+### Aider v0.82.2
+
+- Fix editing shell files with diff-fenced, by zjy1412.
+- Improve robustness of patch application by allowing multiple update/delete actions for the same file within a single response.
+- Update prompts to instruct LLMs to consolidate all edits for a given file into a single block within the patch.
+
+### Aider v0.82.1
+
+- Added support for `o3` and `o4-mini` including provider-specific versions for OpenAI, OpenRouter, and Azure.
+- Added support for Azure specific `gpt-4.1` and `gpt-4.1-mini` models.
+- Disabled streaming for `o3` models since you need identity verification to stream.
+- Fixed handling of file paths in unified diffs, especially those generated by git.
+
+### Aider v0.82.0
+
+- Support for GPT 4.1, mini and nano.
+- Added new `patch` edit format for OpenAI's GPT-4.1 model.
+- Improved support for using architect mode with Gemini 2.5 Pro.
+- Added new `editor-diff`, `editor-whole`, and `editor-diff-fenced` edit formats.
+- Bugfix for automatically selecting the best edit format to use in architect mode.
+- Added support for `grok-3-fast-beta` and `grok-3-mini-fast-beta` models.
+- Aider wrote 92% of the code in this release.
+
+### Aider v0.81.3
+
+- Commit messages generated by aider are no longer forced to be entirely lowercase, by Peter Hadlaw.
+- Updated default settings for Grok models.
+
+### Aider v0.81.2
+
+- Add support for `xai/grok-3-beta`, `xai/grok-3-mini-beta`, `openrouter/x-ai/grok-3-beta`, `openrouter/x-ai/grok-3-mini-beta`, and `openrouter/openrouter/optimus-alpha` models.
+- Add alias "grok3" for `xai/grok-3-beta`.
+- Add alias "optimus" for `openrouter/openrouter/optimus-alpha`.
+- Fix URL extraction from error messages.
+- Allow adding files by full path even if a file with the same basename is already in the chat.
+- Fix quoting of values containing '#' in the sample `aider.conf.yml`.
+- Add support for Fireworks AI model 'deepseek-v3-0324', by Felix Lisczyk.
+- Commit messages generated by aider are now lowercase, by Anton Ödman.
+
+### Aider v0.81.1
+
+- Added support for the `gemini/gemini-2.5-pro-preview-03-25` model.
+- Updated the `gemini` alias to point to `gemini/gemini-2.5-pro-preview-03-25`.
+- Added the `gemini-exp` alias for `gemini/gemini-2.5-pro-exp-03-25`.
+
+### Aider v0.81.0
+
+- Added support for the `openrouter/openrouter/quasar-alpha` model.
+  - Run with `aider --model quasar`
+- Offer OpenRouter OAuth authentication if an OpenRouter model is specified but the API key is missing.
+- Prevent retrying API calls when the provider reports insufficient credits.
+- Improve URL detection to exclude trailing double quotes.
+- Aider wrote 86% of the code in this release.
+
+### Aider v0.80.4
+
+- Bumped deps to pickup litellm change to properly display the root cause of OpenRouter "choices" errors.
+
+### Aider v0.80.3
+
+- Improve error message for OpenRouter API connection issues to mention potential rate limiting or upstream provider issues.
+- Configure weak models (`gemini/gemini-2.0-flash` and `openrouter/google/gemini-2.0-flash-exp:free`) for Gemini 2.5 Pro models.
+- Add model metadata for `openrouter/google/gemini-2.0-flash-exp:free`.
+
+### Aider v0.80.2
+
+- Bumped deps.
+
+### Aider v0.80.1
+
+- Updated deps for yanked fsspec and aiohttp packages #3699
+- Removed redundant dependency check during OpenRouter OAuth flow, by Claudia Pellegrino.
+
+### Aider v0.80.0
+
+- OpenRouter OAuth integration:
+  - Offer to OAuth against OpenRouter if no model and keys are provided.
+  - Select OpenRouter default model based on free/paid tier status if `OPENROUTER_API_KEY` is set and no model is specified.
+- Prioritize `gemini/gemini-2.5-pro-exp-03-25` if `GEMINI_API_KEY` is set, and `vertex_ai/gemini-2.5-pro-exp-03-25` if `VERTEXAI_PROJECT` is set, when no model is specified.
+- Validate user-configured color settings on startup and warn/disable invalid ones.
+- Warn at startup if `--stream` and `--cache-prompts` are used together, as cost estimates may be inaccurate.
+- Boost repomap ranking for files whose path components match identifiers mentioned in the chat.
+- Change web scraping timeout from an error to a warning, allowing scraping to continue with potentially incomplete content.
+- Left-align markdown headings in the terminal output, by Peter Schilling.
+- Update edit format to the new model's default when switching models with `/model`, if the user was using the old model's default format.
+- Add `Ctrl-X Ctrl-E` keybinding to edit the current input buffer in an external editor, by Matteo Landi.
+- Fix linting errors for filepaths containing shell metacharacters, by Mir Adnan ALI.
+- Add the `openrouter/deepseek-chat-v3-0324:free` model.
+- Add repomap support for the Scala language, by Vasil Markoukin.
+- Fixed bug in `/run` that was preventing auto-testing.
+- Fix bug preventing `UnboundLocalError` during git tree traversal.
+- Handle `GitCommandNotFound` error if git is not installed or not in PATH.
+- Handle `FileNotFoundError` if the current working directory is deleted while aider is running.
+- Fix completion menu current item color styling, by Andrey Ivanov.
+- Aider wrote 87% of the code in this release.
+
+### Aider v0.79.2
+
+- Added 'gemini' alias for gemini-2.5-pro model.
+- Updated Gemini 2.5 Pro max output tokens to 64k.
+- Added support for Lisp-style semicolon comments in file watcher, by Matteo Landi.
+- Added OpenRouter API error detection and retries.
+- Added openrouter/deepseek-chat-v3-0324 model.
+- Aider wrote 93% of the code in this release.
+
+### Aider v0.79.1
+
+- Improved model listing to include all models in fuzzy matching, including those provided by aider (not litellm).
+
+### Aider v0.79.0
+
+- Added support for Gemini 2.5 Pro models.
+- Added support for DeepSeek V3 0324 model.
+- Added a new `/context` command that automatically identifies which files need to be edited for a given request.
+- Added `/edit` as an alias for the `/editor` command.
+- Added "overeager" mode for Claude 3.7 Sonnet models to try and keep it working within the requested scope.
+- Aider wrote 65% of the code in this release.
+
+### Aider v0.78.0
+
+- Added support for thinking tokens for OpenRouter Sonnet 3.7.
+- Added commands to switch between model types: `/editor-model` for Editor Model, and `/weak-model` for Weak Model, by csala.
+- Added model setting validation to ignore `--reasoning-effort` and `--thinking-tokens` if the model doesn't support them.
+- Added `--check-model-accepts-settings` flag (default: true) to force unsupported model settings.
+- Annotated which models support reasoning_effort and thinking_tokens settings in the model settings data.
+- Improved code block rendering in markdown output with better padding using NoInsetMarkdown.
+- Added `--git-commit-verify` flag (default: False) to control whether git commit hooks are bypassed.
+- Fixed autocompletion for `/ask`, `/code`, and `/architect` commands, by shladnik.
+- Added vi-like behavior when pressing enter in multiline-mode while in vi normal/navigation-mode, by Marco Mayer.
+- Added AWS_PROFILE support for Bedrock models, allowing use of AWS profiles instead of explicit credentials, by lentil32.
+- Enhanced `--aiderignore` argument to resolve both absolute and relative paths, by mopemope.
+- Improved platform information handling to gracefully handle retrieval errors.
+- Aider wrote 92% of the code in this release.
+
+### Aider v0.77.1
+
+- Bumped dependencies to pickup litellm fix for Ollama.
+- Added support for `openrouter/google/gemma-3-27b-it` model.
+- Updated exclude patterns for help documentation.
+
+### Aider v0.77.0
+
+- Big upgrade in [programming languages supported](https://aider.chat/docs/languages.html) by adopting [tree-sitter-language-pack](https://github.com/Goldziher/tree-sitter-language-pack/).
+  - 130 new languages with linter support.
+  - 20 new languages with repo-map support.
+- Added `/think-tokens` command to set thinking token budget with support for human-readable formats (8k, 10.5k, 0.5M).
+- Added `/reasoning-effort` command to control model reasoning level.
+- The `/think-tokens` and `/reasoning-effort` commands display current settings when called without arguments.
+- Display of thinking token budget and reasoning effort in model information.
+- Changed `--thinking-tokens` argument to accept string values with human-readable formats.
+- Added `--auto-accept-architect` flag (default: true) to automatically accept changes from architect coder format without confirmation.
+- Added support for `cohere_chat/command-a-03-2025` and `gemini/gemma-3-27b-it`
+- The bare `/drop` command now preserves original read-only files provided via args.read.
+- Fixed a bug where default model would be set by deprecated `--shortcut` switches even when already specified in the command line.
+- Improved AutoCompleter to require 3 characters for autocompletion to reduce noise.
+- Aider wrote 72% of the code in this release.
+
+### Aider v0.76.2
+
+- Fixed handling of JSONDecodeError when loading model cache file.
+- Fixed handling of GitCommandError when retrieving git user configuration.
+- Aider wrote 75% of the code in this release.
+
+### Aider v0.76.1
+
+- Added ignore_permission_denied option to file watcher to prevent errors when accessing restricted files, by Yutaka Matsubara.
+- Aider wrote 0% of the code in this release.
+
+### Aider v0.76.0
+
+- Improved support for thinking/reasoningmodels:
+  - Added `--thinking-tokens` CLI option to control token budget for models that support thinking.
+  - Display thinking/reasoning content from LLMs which return it.
+  - Enhanced handling of reasoning tags to better clean up model responses.
+  - Added deprecation warning for `remove_reasoning` setting, now replaced by `reasoning_tag`.
+- Aider will notify you when it's completed the last request and needs your input:
+  - Added [notifications when LLM responses are ready](https://aider.chat/docs/usage/notifications.html) with `--notifications` flag.
+  - Specify desktop notification command with `--notifications-command`.
+- Added support for QWQ 32B.
+- Switch to `tree-sitter-language-pack` for tree sitter support.
+- Improved error handling for EOF (Ctrl+D) in user input prompts.
+- Added helper function to ensure hex color values have a # prefix.
+- Fixed handling of Git errors when reading staged files.
+- Improved SSL verification control for model information requests.
+- Improved empty LLM response handling with clearer warning messages.
+- Fixed Git identity retrieval to respect global configuration, by Akira Komamura.
+- Offer to install dependencies for Bedrock and Vertex AI models.
+- Deprecated model shortcut args (like --4o, --opus) in favor of the --model flag.
+- Aider wrote 85% of the code in this release.
+
+### Aider v0.75.3
+
+- Support for V3 free on OpenRouter: `--model openrouter/deepseek/deepseek-chat:free`.
+
+### Aider v0.75.2
+
+- Added support for Claude 3.7 Sonnet models on OpenRouter, Bedrock and Vertex AI.
+- Updated default model to Claude 3.7 Sonnet on OpenRouter.
+- Added support for GPT-4.5-preview model.
+- Added support for Claude 3.7 Sonnet:beta on OpenRouter.
+- Fixed weak_model_name patterns to match main model name patterns for some models.
+
+### Aider v0.75.1
+
+- Added support for `openrouter/anthropic/claude-3.7-sonnet`
+
+### Aider v0.75.0
+
+- Basic support for Claude 3.7 Sonnet
+  - Use `--model sonnet` to use the new 3.7
+  - Thinking support coming soon.
+- Bugfix to `/editor` command.
+- Aider wrote 46% of the code in this release.
+
+### 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)
@@ -685,7 +1247,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

@@ -1,136 +1,177 @@
+<p align="center">
+    <a href="https://aider.chat/"><img src="https://aider.chat/assets/logo.svg" alt="Aider Logo" width="300"></a>
+</p>
 
-<!-- Edit README.md, not index.md -->
+<h1 align="center">
+AI Pair Programming in Your Terminal
+</h1>
 
-# Aider is AI pair programming in your terminal
 
-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.
-Aider works best with GPT-4o & Claude 3.5 Sonnet and can 
-[connect to almost any LLM](https://aider.chat/docs/llms.html).
+<p align="center">
+Aider lets you pair program with LLMs to start a new project or build on your existing codebase. 
+</p>
 
-<!-- SCREENCAST START -->
 <p align="center">
   <img
     src="https://aider.chat/assets/screencast.svg"
     alt="aider screencast"
   >
 </p>
-<!-- SCREENCAST END -->
-
-<!-- VIDEO START
-<p align="center">
-  <video style="max-width: 100%; height: auto;" autoplay loop muted playsinline>
-    <source src="/assets/shell-cmds-small.mp4" type="video/mp4">
-    Your browser does not support the video tag.
-  </video>
-</p>
-VIDEO END -->
 
 <p align="center">
-  <a href="https://discord.gg/Tv2uQnR88V">
-    <img src="https://img.shields.io/badge/Join-Discord-blue.svg"/>
-  </a>
-  <a href="https://aider.chat/docs/install.html">
-    <img src="https://img.shields.io/badge/Read-Docs-green.svg"/>
-  </a>
-</p>
-
-## Getting started
 <!--[[[cog
-# We can't "include" here.
-# Because this page is rendered by GitHub as the repo README
-cog.out(open("aider/website/_includes/get-started.md").read())
+from scripts.homepage import get_badges_md
+text = get_badges_md()
+cog.out(text)
 ]]]-->
-
-You can get started quickly like this:
-
-```
-python -m pip install -U aider-chat
-
-# Change directory into a git repo
-cd /to/your/git/repo
-
-# Work with Claude 3.5 Sonnet on your repo
-export ANTHROPIC_API_KEY=your-key-goes-here
-aider
-
-# Work with GPT-4o on your repo
-export OPENAI_API_KEY=your-key-goes-here
-aider 
-```
-<!--[[[end]]]-->
-
-See the
-[installation instructions](https://aider.chat/docs/install.html)
-and other
-[documentation](https://aider.chat/docs/usage.html)
-for more details.
+  <a href="https://github.com/Aider-AI/aider/stargazers"><img alt="GitHub Stars" title="Total number of GitHub stars the Aider project has received"
+src="https://img.shields.io/github/stars/Aider-AI/aider?style=flat-square&logo=github&color=f1c40f&labelColor=555555"/></a>
+  <a href="https://pypi.org/project/aider-chat/"><img alt="PyPI Downloads" title="Total number of installations via pip from PyPI"
+src="https://img.shields.io/badge/📦%20Installs-2.1M-2ecc71?style=flat-square&labelColor=555555"/></a>
+  <img alt="Tokens per week" title="Number of tokens processed weekly by Aider users"
+src="https://img.shields.io/badge/📈%20Tokens%2Fweek-15B-3498db?style=flat-square&labelColor=555555"/>
+  <a href="https://openrouter.ai/#options-menu"><img alt="OpenRouter Ranking" title="Aider's ranking among applications on the OpenRouter platform"
+src="https://img.shields.io/badge/🏆%20OpenRouter-Top%2020-9b59b6?style=flat-square&labelColor=555555"/></a>
+  <a href="https://aider.chat/HISTORY.html"><img alt="Singularity" title="Percentage of the new code in Aider's last release written by Aider itself"
+src="https://img.shields.io/badge/🔄%20Singularity-92%25-e74c3c?style=flat-square&labelColor=555555"/></a>
+<!--[[[end]]]-->  
+</p>
 
 ## Features
 
-- Run aider with the files you want to edit: `aider <file1> <file2> ...`
-- Ask for changes:
-  - Add new features or test cases.
-  - Describe a bug.
-  - Paste in an error message or 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.
-- 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,
-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).
+### [Cloud and local LLMs](https://aider.chat/docs/llms.html)
 
+<a href="https://aider.chat/docs/llms.html"><img src="https://aider.chat/assets/icons/brain.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Aider works best with Claude 3.7 Sonnet, DeepSeek R1 & Chat V3, OpenAI o1, o3-mini & GPT-4o, but can connect to almost any LLM, including local models.
 
-## Top tier performance
+<br>
 
-[Aider has one of the top scores on SWE Bench](https://aider.chat/2024/06/02/main-swe-bench.html).
-SWE Bench is a challenging software engineering benchmark where aider
-solved *real* GitHub issues from popular open source
-projects like django, scikitlearn, matplotlib, etc.
+### [Maps your codebase](https://aider.chat/docs/repomap.html)
 
-## More info
+<a href="https://aider.chat/docs/repomap.html"><img src="https://aider.chat/assets/icons/map-outline.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Aider makes a map of your entire codebase, which helps it work well in larger projects.
 
-- [Documentation](https://aider.chat/)
-- [Installation](https://aider.chat/docs/install.html)
-- [Usage](https://aider.chat/docs/usage.html)
-- [Tutorial videos](https://aider.chat/docs/usage/tutorials.html)
+<br>
+
+### [100+ code languages](https://aider.chat/docs/languages.html)
+
+<a href="https://aider.chat/docs/languages.html"><img src="https://aider.chat/assets/icons/code-tags.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Aider works with most popular programming languages: python, javascript, rust, ruby, go, cpp, php, html, css, and dozens more.
+
+<br>
+
+### [Git integration](https://aider.chat/docs/git.html)
+
+<a href="https://aider.chat/docs/git.html"><img src="https://aider.chat/assets/icons/source-branch.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Aider automatically commits changes with sensible commit messages. Use familiar git tools to easily diff, manage and undo AI changes.
+
+<br>
+
+### [Use in your IDE](https://aider.chat/docs/usage/watch.html)
+
+<a href="https://aider.chat/docs/usage/watch.html"><img src="https://aider.chat/assets/icons/monitor.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Use aider from within your favorite IDE or editor. Ask for changes by adding comments to your code and aider will get to work.
+
+<br>
+
+### [Images & web pages](https://aider.chat/docs/usage/images-urls.html)
+
+<a href="https://aider.chat/docs/usage/images-urls.html"><img src="https://aider.chat/assets/icons/image-multiple.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Add images and web pages to the chat to provide visual context, screenshots, reference docs, etc.
+
+<br>
+
+### [Voice-to-code](https://aider.chat/docs/usage/voice.html)
+
+<a href="https://aider.chat/docs/usage/voice.html"><img src="https://aider.chat/assets/icons/microphone.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Speak with aider about your code! Request new features, test cases or bug fixes using your voice and let aider implement the changes.
+
+<br>
+
+### [Linting & testing](https://aider.chat/docs/usage/lint-test.html)
+
+<a href="https://aider.chat/docs/usage/lint-test.html"><img src="https://aider.chat/assets/icons/check-all.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Automatically lint and test your code every time aider makes changes. Aider can fix problems detected by your linters and test suites.
+
+<br>
+
+### [Copy/paste to web chat](https://aider.chat/docs/usage/copypaste.html)
+
+<a href="https://aider.chat/docs/usage/copypaste.html"><img src="https://aider.chat/assets/icons/content-copy.svg" width="32" height="32" align="left" valign="middle" style="margin-right:10px"></a>
+Work with any LLM via its web chat interface. Aider streamlines copy/pasting code context and edits back and forth with a browser.
+
+## Getting Started
+
+```bash
+python -m pip install aider-install
+aider-install
+
+# Change directory into your codebase
+cd /to/your/project
+
+# DeepSeek
+aider --model deepseek --api-key deepseek=<key>
+
+# Claude 3.7 Sonnet
+aider --model sonnet --api-key anthropic=<key>
+
+# o3-mini
+aider --model o3-mini --api-key openai=<key>
+```
+
+See the [installation instructions](https://aider.chat/docs/install.html) and [usage documentation](https://aider.chat/docs/usage.html) for more details.
+
+## More Information
+
+### Documentation
+- [Installation Guide](https://aider.chat/docs/install.html)
+- [Usage Guide](https://aider.chat/docs/usage.html)
+- [Tutorial Videos](https://aider.chat/docs/usage/tutorials.html)
 - [Connecting to LLMs](https://aider.chat/docs/llms.html)
-- [Configuration](https://aider.chat/docs/config.html)
+- [Configuration Options](https://aider.chat/docs/config.html)
 - [Troubleshooting](https://aider.chat/docs/troubleshooting.html)
+- [FAQ](https://aider.chat/docs/faq.html)
+
+### Community & Resources
 - [LLM Leaderboards](https://aider.chat/docs/leaderboards/)
-- [GitHub](https://github.com/paul-gauthier/aider)
-- [Discord](https://discord.gg/Tv2uQnR88V)
+- [GitHub Repository](https://github.com/Aider-AI/aider)
+- [Discord Community](https://discord.gg/Tv2uQnR88V)
 - [Blog](https://aider.chat/blog/)
 
+## Kind Words From Users
 
-## Kind words from users
+- *"My life has changed... There's finally an AI coding tool that's good enough to keep up with me... Aider... It's going to rock your world."* — [Eric S. Raymond](https://x.com/esrtweet/status/1910809356381413593)
+- *"The best free open source AI coding assistant."* — [IndyDevDan](https://youtu.be/YALpX8oOn78)
+- *"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/Aider-AI/aider/issues/124)
+- *"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/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/Aider-AI/aider/issues/112#issuecomment-1637429008)
+- *"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)
+- *"After wasting $100 on tokens trying to find something better, I'm back to Aider. It blows everything else out of the water hands down, there's no competition whatsoever."* — [SystemSculpt](https://discord.com/channels/1131200896827654144/1131200896827654149/1178736602797846548)
+- *"Aider is amazing, coupled with Sonnet 3.5 it's quite mind blowing."* — [Josh Dingus](https://discord.com/channels/1131200896827654144/1133060684540813372/1262374225298198548)
+- *"Hands down, this is the best AI coding assistant tool so far."* — [IndyDevDan](https://www.youtube.com/watch?v=MPYFPvxfGZs)
+- *"[Aider] changed my daily coding workflows. It's mind-blowing how a single Python application can change your life."* — [maledorak](https://discord.com/channels/1131200896827654144/1131200896827654149/1258453375620747264)
+- *"Best agent for actual dev work in existing codebases."* — [Nick Dobos](https://twitter.com/NickADobos/status/1690408967963652097?s=20)
+- *"One of my favorite pieces of software. Blazing trails on new paradigms!"* — [Chris Wall](https://x.com/chris65536/status/1905053299251798432)
+- *"Aider has been revolutionary for me and my work."* — [Starry Hope](https://x.com/starryhopeblog/status/1904985812137132056)
+- *"Try aider! One of the best ways to vibe code."* — [Chris Wall](https://x.com/Chris65536/status/1905053418961391929)
+- *"Aider is hands down the best. And it's free and opensource."* — [AriyaSavakaLurker](https://www.reddit.com/r/ChatGPTCoding/comments/1ik16y6/whats_your_take_on_aider/mbip39n/)
+- *"Aider is also my best friend."* — [jzn21](https://www.reddit.com/r/ChatGPTCoding/comments/1heuvuo/aider_vs_cline_vs_windsurf_vs_cursor/m27dcnb/)
+- *"Try Aider, it's worth it."* — [jorgejhms](https://www.reddit.com/r/ChatGPTCoding/comments/1heuvuo/aider_vs_cline_vs_windsurf_vs_cursor/m27cp99/)
+- *"I like aider :)"* — [Chenwei Cui](https://x.com/ccui42/status/1904965344999145698)
+- *"Aider is the precision tool of LLM code gen... Minimal, thoughtful and capable of surgical changes to your codebase all while keeping the developer in control."* — [Reilly Sweetland](https://x.com/rsweetland/status/1904963807237259586)
+- *"Cannot believe aider vibe coded a 650 LOC feature across service and cli today in 1 shot."* - [autopoietist](https://discord.com/channels/1131200896827654144/1131200896827654149/1355675042259796101)
+- *"Oh no the secret is out! Yes, Aider is the best coding tool around. I highly, highly recommend it to anyone."* — [Joshua D Vander Hook](https://x.com/jodavaho/status/1911154899057795218)
+- *"thanks to aider, i have started and finished three personal projects within the last two days"* — [joseph stalzyn](https://x.com/anitaheeder/status/1908338609645904160)
+- *"Been using aider as my daily driver for over a year ... I absolutely love the tool, like beyond words."* — [koleok](https://discord.com/channels/1131200896827654144/1273248471394291754/1356727448372252783)
+- *"aider is really cool"* — [kache (@yacineMTB)](https://x.com/yacineMTB/status/1911224442430124387)
 
-- *The best free open source AI coding assistant.* -- [IndyDevDan](https://youtu.be/YALpX8oOn78)
-- *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)
-- *What an amazing tool. It's incredible.* -- [valyagolev](https://github.com/paul-gauthier/aider/issues/6#issue-1722897858)
-- *Aider is such an astounding thing!* -- [cgrothaus](https://github.com/paul-gauthier/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)
-- *Amazing project, definitely the best AI coding assistant I've used.* -- [joshuavial](https://github.com/paul-gauthier/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)
-- *After wasting $100 on tokens trying to find something better, I'm back to Aider. It blows everything else out of the water hands down, there's no competition whatsoever.* -- [SystemSculpt](https://discord.com/channels/1131200896827654144/1131200896827654149/1178736602797846548)
-- *Aider is amazing, coupled with Sonnet 3.5 it’s quite mind blowing.* -- [Josh Dingus](https://discord.com/channels/1131200896827654144/1133060684540813372/1262374225298198548)
-- *Hands down, this is the best AI coding assistant tool so far.* -- [IndyDevDan](https://www.youtube.com/watch?v=MPYFPvxfGZs)
-- *[Aider] changed my daily coding workflows. It's mind-blowing how a single Python application can change your life.* -- [maledorak](https://discord.com/channels/1131200896827654144/1131200896827654149/1258453375620747264)
-- *Best agent for actual dev work in existing codebases.* -- [Nick Dobos](https://twitter.com/NickADobos/status/1690408967963652097?s=20)

aider/__init__.py

@@ -1,6 +1,20 @@
+from packaging import version
+
+__version__ = "0.82.4.dev"
+safe_version = __version__
+
 try:
-    from aider.__version__ import __version__
+    from aider._version import __version__
 except Exception:
-    __version__ = "0.58.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

@@ -3,6 +3,7 @@
 import argparse
 import os
 import sys
+from pathlib import Path
 
 import configargparse
 
@@ -12,10 +13,20 @@ from aider.args_formatter import (
     MarkdownHelpFormatter,
     YamlHelpFormatter,
 )
+from aider.deprecated import add_deprecated_model_args
 
 from .dump import dump  # noqa: F401
 
 
+def resolve_aiderignore_path(path_str, git_root=None):
+    path = Path(path_str)
+    if path.is_absolute():
+        return str(path)
+    elif git_root:
+        return str(Path(git_root) / path)
+    return str(path)
+
+
 def default_env_file(git_root):
     return os.path.join(git_root, ".env") if git_root else ".env"
 
@@ -25,153 +36,74 @@ 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",
         default=None,
         help="Specify the model to use for the main chat",
     )
-    opus_model = "claude-3-opus-20240229"
-    group.add_argument(
-        "--opus",
-        action="store_const",
-        dest="model",
-        const=opus_model,
-        help=f"Use {opus_model} model for the main chat",
-    )
-    sonnet_model = "claude-3-5-sonnet-20240620"
-    group.add_argument(
-        "--sonnet",
-        action="store_const",
-        dest="model",
-        const=sonnet_model,
-        help=f"Use {sonnet_model} model for the main chat",
-    )
-    gpt_4_model = "gpt-4-0613"
-    group.add_argument(
-        "--4",
-        "-4",
-        action="store_const",
-        dest="model",
-        const=gpt_4_model,
-        help=f"Use {gpt_4_model} model for the main chat",
-    )
-    gpt_4o_model = "gpt-4o-2024-08-06"
-    group.add_argument(
-        "--4o",
-        action="store_const",
-        dest="model",
-        const=gpt_4o_model,
-        help=f"Use {gpt_4o_model} model for the main chat",
-    )
-    gpt_4o_mini_model = "gpt-4o-mini"
-    group.add_argument(
-        "--mini",
-        action="store_const",
-        dest="model",
-        const=gpt_4o_mini_model,
-        help=f"Use {gpt_4o_mini_model} model for the main chat",
-    )
-    gpt_4_turbo_model = "gpt-4-1106-preview"
-    group.add_argument(
-        "--4-turbo",
-        action="store_const",
-        dest="model",
-        const=gpt_4_turbo_model,
-        help=f"Use {gpt_4_turbo_model} model for the main chat",
-    )
-    gpt_3_model_name = "gpt-3.5-turbo"
-    group.add_argument(
-        "--35turbo",
-        "--35-turbo",
-        "--3",
-        "-3",
-        action="store_const",
-        dest="model",
-        const=gpt_3_model_name,
-        help=f"Use {gpt_3_model_name} model for the main chat",
-    )
-    deepseek_model = "deepseek/deepseek-coder"
-    group.add_argument(
-        "--deepseek",
-        action="store_const",
-        dest="model",
-        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",
@@ -184,12 +116,34 @@ 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(
+        "--thinking-tokens",
+        type=str,
+        help="Set the thinking token budget for models that support it (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",
@@ -204,6 +158,12 @@ def get_parser(default_config_files, git_root):
         const="architect",
         help="Use architect edit format for the main chat",
     )
+    group.add_argument(
+        "--auto-accept-architect",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable automatic acceptance of architect changes (default: True)",
+    )
     group.add_argument(
         "--weak-model",
         metavar="WEAK_MODEL",
@@ -231,26 +191,26 @@ def get_parser(default_config_files, git_root):
         default=True,
         help="Only work with models that have meta-data available (default: True)",
     )
+    group.add_argument(
+        "--check-model-accepts-settings",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Check if model accepts settings like reasoning_effort/thinking_tokens (default: True)"
+        ),
+    )
     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."
+            "Soft limit on tokens for chat history, after which summarization begins."
+            " If unspecified, defaults to 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("Cache Settings")
+    group = parser.add_argument_group("Cache settings")
     group.add_argument(
         "--cache-prompts",
         action=argparse.BooleanOptionalAction,
@@ -265,12 +225,12 @@ def get_parser(default_config_files, git_root):
     )
 
     ##########
-    group = parser.add_argument_group("Repomap Settings")
+    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 (default: 1024)",
+        help="Suggested number of tokens to use for repo map, use 0 to disable",
     )
     group.add_argument(
         "--map-refresh",
@@ -322,7 +282,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",
@@ -410,7 +370,8 @@ def get_parser(default_config_files, git_root):
         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(
@@ -421,7 +382,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,
@@ -437,9 +398,11 @@ def get_parser(default_config_files, git_root):
     default_aiderignore_file = (
         os.path.join(git_root, ".aiderignore") if git_root else ".aiderignore"
     )
+
     group.add_argument(
         "--aiderignore",
         metavar="AIDERIGNORE",
+        type=lambda path_str: resolve_aiderignore_path(path_str, git_root),
         default=default_aiderignore_file,
         help="Specify the aider ignore file (default: .aiderignore in git root)",
     )
@@ -485,6 +448,12 @@ def get_parser(default_config_files, git_root):
         default=False,
         help="Prefix all commit messages with 'aider: ' (default: False)",
     )
+    group.add_argument(
+        "--git-commit-verify",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Enable/disable git pre-commit hooks with --no-verify (default: False)",
+    )
     group.add_argument(
         "--commit",
         action="store_true",
@@ -502,6 +471,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",
@@ -538,12 +519,157 @@ 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(
+        "--analytics",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Enable/disable analytics for current session (default: random)",
+    )
+    group.add_argument(
+        "--analytics-log",
+        metavar="ANALYTICS_LOG_FILE",
+        help="Specify a file to log analytics events",
+    )
+    group.add_argument(
+        "--analytics-disable",
+        action="store_true",
+        help="Permanently disable analytics",
+        default=False,
+    )
+
+    #########
+    group = parser.add_argument_group("Upgrading")
+    group.add_argument(
+        "--just-check-update",
+        action="store_true",
+        help="Check for updates and return status in the exit code",
+        default=False,
+    )
+    group.add_argument(
+        "--check-update",
+        action=argparse.BooleanOptionalAction,
+        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",
+        help="Install the latest version from the main branch",
+        default=False,
+    )
+    group.add_argument(
+        "--upgrade",
+        "--update",
+        action="store_true",
+        help="Upgrade aider to the latest version from PyPI",
+        default=False,
+    )
+    group.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the version number and exit",
+    )
+
+    ##########
+    group = parser.add_argument_group("Modes")
+    group.add_argument(
+        "--message",
+        "--msg",
+        "-m",
+        metavar="COMMAND",
+        help=(
+            "Specify a single message to send the LLM, process reply then exit (disables chat mode)"
+        ),
+    )
+    group.add_argument(
+        "--message-file",
+        "-f",
+        metavar="MESSAGE_FILE",
+        help=(
+            "Specify a file containing the message to send the LLM, process reply, then exit"
+            " (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",
@@ -569,43 +695,7 @@ def get_parser(default_config_files, git_root):
         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",
-        help="Check for updates and return status in the exit code",
-        default=False,
-    )
-    group.add_argument(
-        "--check-update",
-        action=argparse.BooleanOptionalAction,
-        help="Check for new aider versions on launch",
-        default=True,
-    )
-    group.add_argument(
-        "--install-main-branch",
-        action="store_true",
-        help="Install the latest version from the main branch",
-        default=False,
-    )
-    group.add_argument(
-        "--upgrade",
-        "--update",
-        action="store_true",
-        help="Upgrade aider to the latest version from PyPI",
-        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(
-        "--yes",
+        "--yes-always",
         action="store_true",
         help="Always say yes to every confirmation",
         default=None,
@@ -618,46 +708,21 @@ def get_parser(default_config_files, git_root):
         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.add_argument(
-        "--message",
-        "--msg",
-        "-m",
-        metavar="COMMAND",
-        help=(
-            "Specify a single message to send the LLM, process reply then exit (disables chat mode)"
-        ),
-    )
-    group.add_argument(
-        "--message-file",
-        "-f",
-        metavar="MESSAGE_FILE",
-        help=(
-            "Specify a file containing the message to send the LLM, process reply, then exit"
-            " (disables chat mode)"
-        ),
+        "--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",
@@ -668,12 +733,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",
-        "--browser",
-        action="store_true",
-        help="Run aider in your browser",
-        default=False,
+        "--env-file",
+        metavar="ENV_FILE",
+        default=default_env_file(git_root),
+        help="Specify the .env file to load (default: .env in git root)",
     )
     group.add_argument(
         "--suggest-shell-commands",
@@ -681,22 +747,51 @@ 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(
+        "--notifications",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Enable/disable terminal bell notifications when LLM responses are ready (default:"
+            " False)"
+        ),
+    )
+    group.add_argument(
+        "--notifications-command",
+        metavar="COMMAND",
+        default=None,
+        help=(
+            "Specify a command to run for notifications instead of the terminal bell. If not"
+            " specified, a default command for your OS may be used."
+        ),
+    )
+    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 = 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 = parser.add_argument_group("Deprecated model settings")
+    # Add deprecated model shortcut arguments
+    add_deprecated_model_args(parser, group)
 
     return parser
 
@@ -712,7 +807,6 @@ def get_md_help():
     parser.formatter_class = MarkdownHelpFormatter
 
     return argparse.ArgumentParser.format_help(parser)
-    return parser.format_help()
 
 
 def get_sample_yaml():
@@ -726,7 +820,6 @@ def get_sample_yaml():
     parser.formatter_class = YamlHelpFormatter
 
     return argparse.ArgumentParser.format_help(parser)
-    return parser.format_help()
 
 
 def get_sample_dotenv():
@@ -740,7 +833,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

@@ -143,13 +143,22 @@ class YamlHelpFormatter(argparse.HelpFormatter):
             default = "true"
 
         if default:
-            parts.append(f"#{switch}: {default}\n")
+            if "#" in default:
+                parts.append(f'#{switch}: "{default}"\n')
+            else:
+                parts.append(f"#{switch}: {default}\n")
         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("#  - xxx")
+            parts.append("#  - yyy")
+            parts.append("#  - zzz")
         else:
-            parts.append(f"#{switch}: xxx\n")
+            if switch.endswith("color"):
+                parts.append(f'#{switch}: "xxx"\n')
+            else:
+                parts.append(f"#{switch}: xxx\n")
 
         ###
         # parts.append(str(action))

aider/coders/__init__.py

@@ -1,12 +1,16 @@
 from .architect_coder import ArchitectCoder
 from .ask_coder import AskCoder
 from .base_coder import Coder
+from .context_coder import ContextCoder
 from .editblock_coder import EditBlockCoder
 from .editblock_fenced_coder import EditBlockFencedCoder
+from .editor_diff_fenced_coder import EditorDiffFencedCoder
 from .editor_editblock_coder import EditorEditBlockCoder
 from .editor_whole_coder import EditorWholeFileCoder
 from .help_coder import HelpCoder
+from .patch_coder import PatchCoder
 from .udiff_coder import UnifiedDiffCoder
+from .udiff_simple import UnifiedDiffSimpleCoder
 from .wholefile_coder import WholeFileCoder
 
 # from .single_wholefile_func_coder import SingleWholeFileFunctionCoder
@@ -18,9 +22,13 @@ __all__ = [
     EditBlockCoder,
     EditBlockFencedCoder,
     WholeFileCoder,
+    PatchCoder,
     UnifiedDiffCoder,
+    UnifiedDiffSimpleCoder,
     #    SingleWholeFileFunctionCoder,
     ArchitectCoder,
     EditorEditBlockCoder,
     EditorWholeFileCoder,
+    EditorDiffFencedCoder,
+    ContextCoder,
 ]

aider/coders/architect_coder.py

@@ -6,11 +6,15 @@ from .base_coder import Coder
 class ArchitectCoder(AskCoder):
     edit_format = "architect"
     gpt_prompts = ArchitectPrompts()
+    auto_accept_architect = False
 
     def reply_completed(self):
         content = self.partial_response_content
 
-        if not self.io.confirm_ask("Edit the files?"):
+        if not content or not content.strip():
+            return
+
+        if not self.auto_accept_architect and not self.io.confirm_ask("Edit the files?"):
             return
 
         kwargs = dict()
@@ -25,6 +29,7 @@ class ArchitectCoder(AskCoder):
         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)

aider/coders/architect_prompts.py

@@ -13,7 +13,7 @@ Just show the changes needed.
 
 DO NOT show the entire updated function/file/etc!
 
-Always reply in the same language as the change request.
+Always reply to the user in {language}.
 """
 
     example_messages = []

aider/coders/ask_prompts.py

@@ -6,7 +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 the same language they are using.
+Always reply to the user in {language}.
+
+Describe code changes however you like. Don't use SEARCH/REPLACE blocks!
 """
 
     example_messages = []
@@ -30,4 +32,4 @@ 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 = ""
+    system_reminder = "{final_reminders}"

aider/coders/base_prompts.py

@@ -12,6 +12,11 @@ class CoderPrompts:
     lazy_prompt = """You are diligent and tireless!
 You NEVER leave comments describing code without implementing it!
 You always COMPLETELY IMPLEMENT the needed code!
+"""
+
+    overeager_prompt = """Pay careful attention to the scope of the user's request.
+Do what they ask, but no more.
+Do not improve, comment, fix or modify unrelated parts of the code in any way!
 """
 
     example_messages = []
@@ -50,3 +55,6 @@ Do not edit these files!
     shell_cmd_reminder = ""
     no_shell_cmd_prompt = ""
     no_shell_cmd_reminder = ""
+
+    rename_with_shell = ""
+    go_ahead_tip = ""

aider/coders/context_coder.py

@@ -0,0 +1,53 @@
+from .base_coder import Coder
+from .context_prompts import ContextPrompts
+
+
+class ContextCoder(Coder):
+    """Identify which files need to be edited for a given request."""
+
+    edit_format = "context"
+    gpt_prompts = ContextPrompts()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if not self.repo_map:
+            return
+
+        self.repo_map.refresh = "always"
+        self.repo_map.max_map_tokens *= self.repo_map.map_mul_no_files
+        self.repo_map.map_mul_no_files = 1.0
+
+    def reply_completed(self):
+        content = self.partial_response_content
+        if not content or not content.strip():
+            return True
+
+        # dump(repr(content))
+        current_rel_fnames = set(self.get_inchat_relative_files())
+        mentioned_rel_fnames = set(self.get_file_mentions(content, ignore_current=True))
+
+        # dump(current_rel_fnames)
+        # dump(mentioned_rel_fnames)
+        # dump(current_rel_fnames == mentioned_rel_fnames)
+
+        if mentioned_rel_fnames == current_rel_fnames:
+            return True
+
+        if self.num_reflections >= self.max_reflections - 1:
+            return True
+
+        self.abs_fnames = set()
+        for fname in mentioned_rel_fnames:
+            self.add_rel_fname(fname)
+        # dump(self.get_inchat_relative_files())
+
+        self.reflected_message = self.gpt_prompts.try_again
+
+        # mentioned_idents = self.get_ident_mentions(cur_msg_text)
+        # if mentioned_idents:
+
+        return True
+
+    def check_for_file_mentions(self, content):
+        pass

aider/coders/context_prompts.py

@@ -0,0 +1,75 @@
+# flake8: noqa: E501
+
+from .base_prompts import CoderPrompts
+
+
+class ContextPrompts(CoderPrompts):
+    main_system = """Act as an expert code analyst.
+Understand the user's question or request, solely to determine ALL the existing sources files which will need to be modified.
+Return the *complete* list of files which will need to be modified based on the user's request.
+Explain why each file is needed, including names of key classes/functions/methods/variables.
+Be sure to include or omit the names of files already added to the chat, based on whether they are actually needed or not.
+
+The user will use every file you mention, regardless of your commentary.
+So *ONLY* mention the names of relevant files.
+If a file is not relevant DO NOT mention it.
+
+Only return files that will need to be modified, not files that contain useful/relevant functions.
+
+You are only to discuss EXISTING files and symbols.
+Only return existing files, don't suggest the names of new files or functions that we will need to create.
+
+Always reply to the user in {language}.
+
+Be concise in your replies.
+Return:
+1. A bulleted list of files the will need to be edited, and symbols that are highly relevant to the user's request.
+2. A list of classes/functions/methods/variables that are located OUTSIDE those files which will need to be understood. Just the symbols names, *NOT* file names.
+
+# Your response *MUST* use this format:
+
+## ALL files we need to modify, with their relevant symbols:
+
+- alarms/buzz.py
+  - `Buzzer` class which can make the needed sound
+  - `Buzzer.buzz_buzz()` method triggers the sound
+- alarms/time.py
+  - `Time.set_alarm(hour, minute)` to set the alarm
+
+## Relevant symbols from OTHER files:
+
+- AlarmManager class for setup/teardown of alarms
+- SoundFactory will be used to create a Buzzer
+"""
+
+    example_messages = []
+
+    files_content_prefix = """These files have been *added these files to the chat* so we can 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 = """
+NEVER RETURN CODE!
+"""
+
+    try_again = """I have updated the set of files added to the chat.
+Review them to decide if this is the correct set of files or if we need to add more or remove files.
+
+If this is the right set, just return the current list of files.
+Or return a smaller or larger set of files which need to be edited, with symbols that are highly relevant to the user's request.
+"""

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)
-            content = self.io.read_text(full_path)
-            new_content = do_replace(full_path, content, original, updated, self.fence)
-            if not new_content:
+            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 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:
-                self.io.write_text(full_path, 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"
-DIVIDER = r"={5,9}"
-UPDATED = r">{5,9} REPLACE"
+HEAD = r"^<{5,9} SEARCH\s*$"
+DIVIDER = r"^={5,9}\s*$"
+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()
@@ -392,6 +413,15 @@ def strip_filename(filename, fence):
 
     start_fence = fence[0]
     if filename.startswith(start_fence):
+        candidate = filename[len(start_fence) :]
+        if candidate and ("." in candidate or "/" in candidate):
+            return candidate
+        return
+
+    if filename.startswith(triple_backticks):
+        candidate = filename[len(triple_backticks) :]
+        if candidate and ("." in candidate or "/" in candidate):
+            return candidate
         return
 
     filename = filename.rstrip(":")
@@ -400,7 +430,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
@@ -433,7 +463,14 @@ def find_original_update_blocks(content, fence=DEFAULT_FENCE, valid_fnames=None)
             "```csh",
             "```tcsh",
         ]
-        next_is_editblock = i + 1 < len(lines) and head_pattern.match(lines[i + 1].strip())
+
+        # Check if the next line or the one after that is an editblock
+        next_is_editblock = (
+            i + 1 < len(lines)
+            and head_pattern.match(lines[i + 1].strip())
+            or i + 2 < len(lines)
+            and head_pattern.match(lines[i + 2].strip())
+        )
 
         if any(line.strip().startswith(start) for start in shell_starts) and not next_is_editblock:
             shell_content = []
@@ -528,7 +565,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_fenced_prompts.py

@@ -19,7 +19,7 @@ class EditBlockFencedPrompts(EditBlockPrompts):
 
 Here are the *SEARCH/REPLACE* blocks:
 
-{fence[0]}
+{fence[0]}python
 mathweb/flask/app.py
 <<<<<<< SEARCH
 from flask import Flask
@@ -29,7 +29,7 @@ from flask import Flask
 >>>>>>> REPLACE
 {fence[1]}
 
-{fence[0]}
+{fence[0]}python
 mathweb/flask/app.py
 <<<<<<< SEARCH
 def factorial(n):
@@ -44,7 +44,7 @@ def factorial(n):
 >>>>>>> REPLACE
 {fence[1]}
 
-{fence[0]}
+{fence[0]}python
 mathweb/flask/app.py
 <<<<<<< SEARCH
     return str(factorial(n))
@@ -68,7 +68,7 @@ mathweb/flask/app.py
 
 Here are the *SEARCH/REPLACE* blocks:
 
-{fence[0]}
+{fence[0]}python
 hello.py
 <<<<<<< SEARCH
 =======
@@ -79,7 +79,7 @@ def hello():
 >>>>>>> REPLACE
 {fence[1]}
 
-{fence[0]}
+{fence[0]}python
 main.py
 <<<<<<< SEARCH
 def hello():
@@ -93,3 +93,51 @@ from hello import hello
 """,
         ),
     ]
+
+    system_reminder = """
+# *SEARCH/REPLACE block* Rules:
+
+Every *SEARCH/REPLACE block* must use this format:
+1. The opening fence and code language, eg: {fence[0]}python
+2. The *FULL* file path alone on a line, verbatim. No bold asterisks, no quotes around it, no escaping of characters, etc.
+3. The start of search block: <<<<<<< SEARCH
+4. A contiguous chunk of lines to search for in the existing source code
+5. The dividing line: =======
+6. The lines to replace into the source code
+7. The end of the replace block: >>>>>>> REPLACE
+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 *only* replace the first match occurrence.
+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.
+Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+Do not include long runs of unchanging lines in *SEARCH/REPLACE* blocks.
+
+Only create *SEARCH/REPLACE* blocks for files that the user has added to the chat!
+
+To move code within a file, use 2 *SEARCH/REPLACE* blocks: 1 to delete it from its current location, 1 to insert it in the new location.
+
+Pay attention to which filenames the user wants you to edit, especially if they are asking you to create a new file.
+
+If you want to put code in a new file, use a *SEARCH/REPLACE block* with:
+- A new file path, including dir name if needed
+- An empty `SEARCH` section
+- The new file's contents in the `REPLACE` section
+
+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.
+
+{final_reminders}
+ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
+{shell_cmd_reminder}
+"""

aider/coders/editblock_prompts.py

@@ -1,5 +1,6 @@
 # flake8: noqa: E501
 
+from . import shell
 from .base_prompts import CoderPrompts
 
 
@@ -7,11 +8,11 @@ class EditBlockPrompts(CoderPrompts):
     main_system = """Act as an expert software developer.
 Always use best practices when coding.
 Respect and use existing conventions, libraries, etc that are already present in the code base.
-{lazy_prompt}
+{final_reminders}
 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:
 
@@ -28,30 +29,6 @@ You can keep asking if you then decide you need to edit more files.
 All changes to files must use this *SEARCH/REPLACE block* format.
 ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
 {shell_cmd_prompt}
-"""
-
-    shell_cmd_prompt = """
-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 are ready to execute, without placeholders.
-Only suggest at most a few shell commands at a time, not more than 1-3.
-
-Use the appropriate shell based on the user's system info:
-{platform}
-Examples of when to suggest shell commands:
-
-- If you changed a self-contained html file, suggest an OS-appropriate command to open a browser to view it to see the updated content.
-- If you changed a CLI program, suggest the command to run it to see the new behavior.
-- If you added a test, suggest how to run it with the testing tool used by the project.
-- Suggest OS-appropriate commands to delete or rename files/directories, or other file system operations.
-- If your code changes add new dependencies, suggest the command to install them.
-- Etc.
-"""
-
-    no_shell_cmd_prompt = """
-Keep in mind these details about the user's platform and environment:
-{platform}
 """
     example_messages = [
         dict(
@@ -155,12 +132,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.
-Include enough lines to make the SEARCH blocks uniquely match the lines to change.
+*SEARCH/REPLACE* blocks will *only* replace the first match occurrence.
+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.
@@ -178,20 +156,19 @@ If you want to put code in a new file, use a *SEARCH/REPLACE block* with:
 - An empty `SEARCH` section
 - The new file's contents in the `REPLACE` section
 
-To rename files which have been added to the chat, use shell commands at the end of your response.
-
-{lazy_prompt}
-ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
+{rename_with_shell}{go_ahead_tip}{final_reminders}ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
 {shell_cmd_reminder}
 """
 
-    shell_cmd_reminder = """
-Examples of when to suggest shell commands:
+    rename_with_shell = """To rename files which have been added to the chat, use shell commands at the end of your response.
 
-- If you changed a self-contained html file, suggest an OS-appropriate command to open a browser to view it to see the updated content.
-- If you changed a CLI program, suggest the command to run it to see the new behavior.
-- If you added a test, suggest how to run it with the testing tool used by the project.
-- Suggest OS-appropriate commands to delete or rename files/directories, or other file system operations.
-- If your code changes add new dependencies, suggest the command to install them.
-- Etc.
 """
+
+    go_ahead_tip = """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.
+
+"""
+
+    shell_cmd_prompt = shell.shell_cmd_prompt
+    no_shell_cmd_prompt = shell.no_shell_cmd_prompt
+    shell_cmd_reminder = shell.shell_cmd_reminder

aider/coders/editor_diff_fenced_coder.py

@@ -0,0 +1,9 @@
+from .editblock_fenced_coder import EditBlockFencedCoder
+from .editor_diff_fenced_prompts import EditorDiffFencedPrompts
+
+
+class EditorDiffFencedCoder(EditBlockFencedCoder):
+    "A coder that uses search/replace blocks, focused purely on editing files."
+
+    edit_format = "editor-diff-fenced"
+    gpt_prompts = EditorDiffFencedPrompts()

aider/coders/editor_diff_fenced_prompts.py

@@ -0,0 +1,11 @@
+# flake8: noqa: E501
+
+from .editblock_fenced_prompts import EditBlockFencedPrompts
+
+
+class EditorDiffFencedPrompts(EditBlockFencedPrompts):
+    shell_cmd_prompt = ""
+    no_shell_cmd_prompt = ""
+    shell_cmd_reminder = ""
+    go_ahead_tip = ""
+    rename_with_shell = ""

aider/coders/editor_editblock_coder.py

@@ -3,5 +3,6 @@ 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

@@ -5,7 +5,7 @@ from .editblock_prompts import EditBlockPrompts
 
 class EditorEditBlockPrompts(EditBlockPrompts):
     main_system = """Act as an expert software developer who edits source code.
-{lazy_prompt}
+{final_reminders}
 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*!
@@ -14,3 +14,5 @@ ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
     shell_cmd_prompt = ""
     no_shell_cmd_prompt = ""
     shell_cmd_reminder = ""
+    go_ahead_tip = ""
+    rename_with_shell = ""

aider/coders/editor_whole_coder.py

@@ -3,5 +3,6 @@ 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

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

aider/coders/patch_coder.py

@@ -0,0 +1,706 @@
+import pathlib
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Optional, Tuple
+
+from .base_coder import Coder
+from .patch_prompts import PatchPrompts
+
+
+# --------------------------------------------------------------------------- #
+#  Domain objects & Exceptions (Adapted from apply_patch.py)
+# --------------------------------------------------------------------------- #
+class DiffError(ValueError):
+    """Any problem detected while parsing or applying a patch."""
+
+
+class ActionType(str, Enum):
+    ADD = "Add"
+    DELETE = "Delete"
+    UPDATE = "Update"
+
+
+@dataclass
+class Chunk:
+    orig_index: int = -1  # Line number in the *original* file block where the change starts
+    del_lines: List[str] = field(default_factory=list)
+    ins_lines: List[str] = field(default_factory=list)
+
+
+@dataclass
+class PatchAction:
+    type: ActionType
+    path: str
+    # For ADD:
+    new_content: Optional[str] = None
+    # For UPDATE:
+    chunks: List[Chunk] = field(default_factory=list)
+    move_path: Optional[str] = None
+
+
+# Type alias for the return type of get_edits
+EditResult = Tuple[str, PatchAction]
+
+
+@dataclass
+class Patch:
+    actions: Dict[str, PatchAction] = field(default_factory=dict)
+    fuzz: int = 0  # Track fuzziness used during parsing
+
+
+# --------------------------------------------------------------------------- #
+#  Helper functions (Adapted from apply_patch.py)
+# --------------------------------------------------------------------------- #
+def _norm(line: str) -> str:
+    """Strip CR so comparisons work for both LF and CRLF input."""
+    return line.rstrip("\r")
+
+
+def find_context_core(lines: List[str], context: List[str], start: int) -> Tuple[int, int]:
+    """Finds context block, returns start index and fuzz level."""
+    if not context:
+        return start, 0
+
+    # Exact match
+    for i in range(start, len(lines) - len(context) + 1):
+        if lines[i : i + len(context)] == context:
+            return i, 0
+    # Rstrip match
+    norm_context = [s.rstrip() for s in context]
+    for i in range(start, len(lines) - len(context) + 1):
+        if [s.rstrip() for s in lines[i : i + len(context)]] == norm_context:
+            return i, 1  # Fuzz level 1
+    # Strip match
+    norm_context_strip = [s.strip() for s in context]
+    for i in range(start, len(lines) - len(context) + 1):
+        if [s.strip() for s in lines[i : i + len(context)]] == norm_context_strip:
+            return i, 100  # Fuzz level 100
+    return -1, 0
+
+
+def find_context(lines: List[str], context: List[str], start: int, eof: bool) -> Tuple[int, int]:
+    """Finds context, handling EOF marker."""
+    if eof:
+        # If EOF marker, first try matching at the very end
+        if len(lines) >= len(context):
+            new_index, fuzz = find_context_core(lines, context, len(lines) - len(context))
+            if new_index != -1:
+                return new_index, fuzz
+        # If not found at end, search from `start` as fallback
+        new_index, fuzz = find_context_core(lines, context, start)
+        return new_index, fuzz + 10_000  # Add large fuzz penalty if EOF wasn't at end
+    # Normal case: search from `start`
+    return find_context_core(lines, context, start)
+
+
+def peek_next_section(lines: List[str], index: int) -> Tuple[List[str], List[Chunk], int, bool]:
+    """
+    Parses one section (context, -, + lines) of an Update block.
+    Returns: (context_lines, chunks_in_section, next_index, is_eof)
+    """
+    context_lines: List[str] = []
+    del_lines: List[str] = []
+    ins_lines: List[str] = []
+    chunks: List[Chunk] = []
+    mode = "keep"  # Start by expecting context lines
+    start_index = index
+
+    while index < len(lines):
+        line = lines[index]
+        norm_line = _norm(line)
+
+        # Check for section terminators
+        if norm_line.startswith(
+            (
+                "@@",
+                "*** End Patch",
+                "*** Update File:",
+                "*** Delete File:",
+                "*** Add File:",
+                "*** End of File",  # Special terminator
+            )
+        ):
+            break
+        if norm_line == "***":  # Legacy/alternative terminator? Handle just in case.
+            break
+        if norm_line.startswith("***"):  # Invalid line
+            raise DiffError(f"Invalid patch line found in update section: {line}")
+
+        index += 1
+        last_mode = mode
+
+        # Determine line type and strip prefix
+        if line.startswith("+"):
+            mode = "add"
+            line_content = line[1:]
+        elif line.startswith("-"):
+            mode = "delete"
+            line_content = line[1:]
+        elif line.startswith(" "):
+            mode = "keep"
+            line_content = line[1:]
+        elif line.strip() == "":  # Treat blank lines in patch as context ' '
+            mode = "keep"
+            line_content = ""  # Keep it as a blank line
+        else:
+            # Assume lines without prefix are context if format is loose,
+            # but strict format requires ' '. Raise error for strictness.
+            raise DiffError(f"Invalid line prefix in update section: {line}")
+
+        # If mode changes from add/delete back to keep, finalize the previous chunk
+        if mode == "keep" and last_mode != "keep":
+            if del_lines or ins_lines:
+                chunks.append(
+                    Chunk(
+                        # orig_index is relative to the start of the *context* block found
+                        orig_index=len(context_lines) - len(del_lines),
+                        del_lines=del_lines,
+                        ins_lines=ins_lines,
+                    )
+                )
+            del_lines, ins_lines = [], []
+
+        # Collect lines based on mode
+        if mode == "delete":
+            del_lines.append(line_content)
+            context_lines.append(line_content)  # Deleted lines are part of the original context
+        elif mode == "add":
+            ins_lines.append(line_content)
+        elif mode == "keep":
+            context_lines.append(line_content)
+
+    # Finalize any pending chunk at the end of the section
+    if del_lines or ins_lines:
+        chunks.append(
+            Chunk(
+                orig_index=len(context_lines) - len(del_lines),
+                del_lines=del_lines,
+                ins_lines=ins_lines,
+            )
+        )
+
+    # Check for EOF marker
+    is_eof = False
+    if index < len(lines) and _norm(lines[index]) == "*** End of File":
+        index += 1
+        is_eof = True
+
+    if index == start_index and not is_eof:  # Should not happen if patch is well-formed
+        raise DiffError("Empty patch section found.")
+
+    return context_lines, chunks, index, is_eof
+
+
+def identify_files_needed(text: str) -> List[str]:
+    """Extracts file paths from Update and Delete actions."""
+    lines = text.splitlines()
+    paths = set()
+    for line in lines:
+        norm_line = _norm(line)
+        if norm_line.startswith("*** Update File: "):
+            paths.add(norm_line[len("*** Update File: ") :].strip())
+        elif norm_line.startswith("*** Delete File: "):
+            paths.add(norm_line[len("*** Delete File: ") :].strip())
+    return list(paths)
+
+
+# --------------------------------------------------------------------------- #
+#  PatchCoder Class Implementation
+# --------------------------------------------------------------------------- #
+class PatchCoder(Coder):
+    """
+    A coder that uses a custom patch format for code modifications,
+    inspired by the format described in tmp.gpt41edits.txt.
+    Applies patches using logic adapted from the reference apply_patch.py script.
+    """
+
+    edit_format = "patch"
+    gpt_prompts = PatchPrompts()
+
+    def get_edits(self) -> List[EditResult]:
+        """
+        Parses the LLM response content (containing the patch) into a list of
+        tuples, where each tuple contains the file path and the PatchAction object.
+        """
+        content = self.partial_response_content
+        if not content or not content.strip():
+            return []
+
+        # Check for patch sentinels
+        lines = content.splitlines()
+        if (
+            len(lines) < 2
+            or not _norm(lines[0]).startswith("*** Begin Patch")
+            # Allow flexible end, might be EOF or just end of stream
+            # or _norm(lines[-1]) != "*** End Patch"
+        ):
+            # Tolerate missing sentinels if content looks like a patch action
+            is_patch_like = any(
+                _norm(line).startswith(
+                    ("@@", "*** Update File:", "*** Add File:", "*** Delete File:")
+                )
+                for line in lines
+            )
+            if not is_patch_like:
+                # If it doesn't even look like a patch, return empty
+                self.io.tool_warning("Response does not appear to be in patch format.")
+                return []
+            # If it looks like a patch but lacks sentinels, try parsing anyway but warn.
+            self.io.tool_warning(
+                "Patch format warning: Missing '*** Begin Patch'/'*** End Patch' sentinels."
+            )
+            start_index = 0
+        else:
+            start_index = 1  # Skip "*** Begin Patch"
+
+        # Identify files needed for context lookups during parsing
+        needed_paths = identify_files_needed(content)
+        current_files: Dict[str, str] = {}
+        for rel_path in needed_paths:
+            abs_path = self.abs_root_path(rel_path)
+            try:
+                # Use io.read_text to handle potential errors/encodings
+                file_content = self.io.read_text(abs_path)
+                if file_content is None:
+                    raise DiffError(
+                        f"File referenced in patch not found or could not be read: {rel_path}"
+                    )
+                current_files[rel_path] = file_content
+            except FileNotFoundError:
+                raise DiffError(f"File referenced in patch not found: {rel_path}")
+            except IOError as e:
+                raise DiffError(f"Error reading file {rel_path}: {e}")
+
+        try:
+            # Parse the patch text using adapted logic
+            patch_obj = self._parse_patch_text(lines, start_index, current_files)
+            # Convert Patch object actions dict to a list of tuples (path, action)
+            # for compatibility with the base Coder's prepare_to_edit method.
+            results = []
+            for path, action in patch_obj.actions.items():
+                results.append((path, action))
+            return results
+        except DiffError as e:
+            # Raise as ValueError for consistency with other coders' error handling
+            raise ValueError(f"Error parsing patch content: {e}")
+        except Exception as e:
+            # Catch unexpected errors during parsing
+            raise ValueError(f"Unexpected error parsing patch: {e}")
+
+    def _parse_patch_text(
+        self, lines: List[str], start_index: int, current_files: Dict[str, str]
+    ) -> Patch:
+        """
+        Parses patch content lines into a Patch object.
+        Adapted from the Parser class in apply_patch.py.
+        """
+        patch = Patch()
+        index = start_index
+        fuzz_accumulator = 0
+
+        while index < len(lines):
+            line = lines[index]
+            norm_line = _norm(line)
+
+            if norm_line == "*** End Patch":
+                index += 1
+                break  # Successfully reached end
+
+            # ---------- UPDATE ---------- #
+            if norm_line.startswith("*** Update File: "):
+                path = norm_line[len("*** Update File: ") :].strip()
+                index += 1
+                if not path:
+                    raise DiffError("Update File action missing path.")
+
+                # Optional move target
+                move_to = None
+                if index < len(lines) and _norm(lines[index]).startswith("*** Move to: "):
+                    move_to = _norm(lines[index])[len("*** Move to: ") :].strip()
+                    index += 1
+                    if not move_to:
+                        raise DiffError("Move to action missing path.")
+
+                if path not in current_files:
+                    raise DiffError(f"Update File Error - missing file content for: {path}")
+
+                file_content = current_files[path]
+
+                existing_action = patch.actions.get(path)
+                if existing_action is not None:
+                    # Merge additional UPDATE block into the existing one
+                    if existing_action.type != ActionType.UPDATE:
+                        raise DiffError(f"Conflicting actions for file: {path}")
+
+                    new_action, index, fuzz = self._parse_update_file_sections(
+                        lines, index, file_content
+                    )
+                    existing_action.chunks.extend(new_action.chunks)
+
+                    if move_to:
+                        if existing_action.move_path and existing_action.move_path != move_to:
+                            raise DiffError(f"Conflicting move targets for file: {path}")
+                        existing_action.move_path = move_to
+                    fuzz_accumulator += fuzz
+                else:
+                    # First UPDATE block for this file
+                    action, index, fuzz = self._parse_update_file_sections(
+                        lines, index, file_content
+                    )
+                    action.path = path
+                    action.move_path = move_to
+                    patch.actions[path] = action
+                    fuzz_accumulator += fuzz
+                continue
+
+            # ---------- DELETE ---------- #
+            elif norm_line.startswith("*** Delete File: "):
+                path = norm_line[len("*** Delete File: ") :].strip()
+                index += 1
+                if not path:
+                    raise DiffError("Delete File action missing path.")
+                existing_action = patch.actions.get(path)
+                if existing_action:
+                    if existing_action.type == ActionType.DELETE:
+                        # Duplicate delete – ignore the extra block
+                        self.io.tool_warning(f"Duplicate delete action for file: {path} ignored.")
+                        continue
+                    else:
+                        raise DiffError(f"Conflicting actions for file: {path}")
+                if path not in current_files:
+                    raise DiffError(
+                        f"Delete File Error - file not found: {path}"
+                    )  # Check against known files
+
+                patch.actions[path] = PatchAction(type=ActionType.DELETE, path=path)
+                continue
+
+            # ---------- ADD ---------- #
+            elif norm_line.startswith("*** Add File: "):
+                path = norm_line[len("*** Add File: ") :].strip()
+                index += 1
+                if not path:
+                    raise DiffError("Add File action missing path.")
+                if path in patch.actions:
+                    raise DiffError(f"Duplicate action for file: {path}")
+                # Check if file exists in the context provided (should not for Add).
+                # Note: We only have needed files, a full check requires FS access.
+                # if path in current_files:
+                #     raise DiffError(f"Add File Error - file already exists: {path}")
+
+                action, index = self._parse_add_file_content(lines, index)
+                action.path = path  # Ensure path is set
+                patch.actions[path] = action
+                continue
+
+            # If we are here, the line is unexpected
+            # Allow blank lines between actions
+            if not norm_line.strip():
+                index += 1
+                continue
+
+            raise DiffError(f"Unknown or misplaced line while parsing patch: {line}")
+
+        # Check if we consumed the whole input or stopped early
+        # Tolerate missing "*** End Patch" if we processed actions
+        # if index < len(lines) and _norm(lines[index-1]) != "*** End Patch":
+        #    raise DiffError("Patch parsing finished unexpectedly before end of input.")
+
+        patch.fuzz = fuzz_accumulator
+        return patch
+
+    def _parse_update_file_sections(
+        self, lines: List[str], index: int, file_content: str
+    ) -> Tuple[PatchAction, int, int]:
+        """Parses all sections (@@, context, -, +) for a single Update File action."""
+        action = PatchAction(type=ActionType.UPDATE, path="")  # Path set by caller
+        orig_lines = file_content.splitlines()  # Use splitlines for consistency
+        current_file_index = 0  # Track position in original file content
+        total_fuzz = 0
+
+        while index < len(lines):
+            norm_line = _norm(lines[index])
+            # Check for terminators for *this* file update
+            if norm_line.startswith(
+                (
+                    "*** End Patch",
+                    "*** Update File:",
+                    "*** Delete File:",
+                    "*** Add File:",
+                )
+            ):
+                break  # End of this file's update section
+
+            # Handle @@ scope lines (optional)
+            scope_lines = []
+            while index < len(lines) and _norm(lines[index]).startswith("@@"):
+                scope_line_content = lines[index][len("@@") :].strip()
+                if scope_line_content:  # Ignore empty @@ lines?
+                    scope_lines.append(scope_line_content)
+                index += 1
+
+            # Find the scope in the original file if specified
+            if scope_lines:
+                # Simple scope finding: search from current position
+                # A more robust finder could handle nested scopes like the reference @@ @@
+                found_scope = False
+                temp_index = current_file_index
+                while temp_index < len(orig_lines):
+                    # Check if all scope lines match sequentially from temp_index
+                    match = True
+                    for i, scope in enumerate(scope_lines):
+                        if (
+                            temp_index + i >= len(orig_lines)
+                            or _norm(orig_lines[temp_index + i]).strip() != scope
+                        ):
+                            match = False
+                            break
+                    if match:
+                        current_file_index = temp_index + len(scope_lines)
+                        found_scope = True
+                        break
+                    temp_index += 1
+
+                if not found_scope:
+                    # Try fuzzy scope matching (strip whitespace)
+                    temp_index = current_file_index
+                    while temp_index < len(orig_lines):
+                        match = True
+                        for i, scope in enumerate(scope_lines):
+                            if (
+                                temp_index + i >= len(orig_lines)
+                                or _norm(orig_lines[temp_index + i]).strip() != scope.strip()
+                            ):
+                                match = False
+                                break
+                        if match:
+                            current_file_index = temp_index + len(scope_lines)
+                            found_scope = True
+                            total_fuzz += 1  # Add fuzz for scope match difference
+                            break
+                        temp_index += 1
+
+                if not found_scope:
+                    scope_txt = "\n".join(scope_lines)
+                    raise DiffError(f"Could not find scope context:\n{scope_txt}")
+
+            # Peek and parse the next context/change section
+            context_block, chunks_in_section, next_index, is_eof = peek_next_section(lines, index)
+
+            # Find where this context block appears in the original file
+            found_index, fuzz = find_context(orig_lines, context_block, current_file_index, is_eof)
+            total_fuzz += fuzz
+
+            if found_index == -1:
+                ctx_txt = "\n".join(context_block)
+                marker = "*** End of File" if is_eof else ""
+                raise DiffError(
+                    f"Could not find patch context {marker} starting near line"
+                    f" {current_file_index}:\n{ctx_txt}"
+                )
+
+            # Adjust chunk original indices to be absolute within the file
+            for chunk in chunks_in_section:
+                # chunk.orig_index from peek is relative to context_block start
+                # We need it relative to the file start
+                chunk.orig_index += found_index
+                action.chunks.append(chunk)
+
+            # Advance file index past the matched context block
+            current_file_index = found_index + len(context_block)
+            # Advance line index past the processed section in the patch
+            index = next_index
+
+        return action, index, total_fuzz
+
+    def _parse_add_file_content(self, lines: List[str], index: int) -> Tuple[PatchAction, int]:
+        """Parses the content (+) lines for an Add File action."""
+        added_lines: List[str] = []
+        while index < len(lines):
+            line = lines[index]
+            norm_line = _norm(line)
+            # Stop if we hit another action or end marker
+            if norm_line.startswith(
+                (
+                    "*** End Patch",
+                    "*** Update File:",
+                    "*** Delete File:",
+                    "*** Add File:",
+                )
+            ):
+                break
+
+            # Expect lines to start with '+'
+            if not line.startswith("+"):
+                # Tolerate blank lines? Or require '+'? Reference implies '+' required.
+                if norm_line.strip() == "":
+                    # Treat blank line as adding a blank line
+                    added_lines.append("")
+                else:
+                    raise DiffError(f"Invalid Add File line (missing '+'): {line}")
+            else:
+                added_lines.append(line[1:])  # Strip leading '+'
+
+            index += 1
+
+        action = PatchAction(type=ActionType.ADD, path="", new_content="\n".join(added_lines))
+        return action, index
+
+    def apply_edits(self, edits: List[PatchAction]):
+        """
+        Applies the parsed PatchActions to the corresponding files.
+        """
+        if not edits:
+            return
+
+        # Group edits by original path? Not strictly needed if processed sequentially.
+
+        # Edits are now List[Tuple[str, PatchAction]]
+        for _path_tuple_element, action in edits:
+            # action is the PatchAction object
+            # action.path is the canonical path within the action logic
+            full_path = self.abs_root_path(action.path)
+            path_obj = pathlib.Path(full_path)
+
+            try:
+                if action.type == ActionType.ADD:
+                    # Check existence *before* writing
+                    if path_obj.exists():
+                        raise DiffError(f"ADD Error: File already exists: {action.path}")
+                    if action.new_content is None:
+                        # Parser should ensure this doesn't happen
+                        raise DiffError(f"ADD change for {action.path} has no content")
+
+                    self.io.tool_output(f"Adding {action.path}")
+                    path_obj.parent.mkdir(parents=True, exist_ok=True)
+                    # Ensure single trailing newline, matching reference behavior
+                    content_to_write = action.new_content
+                    if not content_to_write.endswith("\n"):
+                        content_to_write += "\n"
+                    self.io.write_text(full_path, content_to_write)
+
+                elif action.type == ActionType.DELETE:
+                    self.io.tool_output(f"Deleting {action.path}")
+                    if not path_obj.exists():
+                        self.io.tool_warning(
+                            f"DELETE Warning: File not found, skipping: {action.path}"
+                        )
+                    else:
+                        path_obj.unlink()
+
+                elif action.type == ActionType.UPDATE:
+                    if not path_obj.exists():
+                        raise DiffError(f"UPDATE Error: File does not exist: {action.path}")
+
+                    current_content = self.io.read_text(full_path)
+                    if current_content is None:
+                        # Should have been caught during parsing if file was needed
+                        raise DiffError(f"Could not read file for UPDATE: {action.path}")
+
+                    # Apply the update logic using the parsed chunks
+                    new_content = self._apply_update(current_content, action, action.path)
+
+                    target_full_path = (
+                        self.abs_root_path(action.move_path) if action.move_path else full_path
+                    )
+                    target_path_obj = pathlib.Path(target_full_path)
+
+                    if action.move_path:
+                        self.io.tool_output(
+                            f"Updating and moving {action.path} to {action.move_path}"
+                        )
+                        # Check if target exists before overwriting/moving
+                        if target_path_obj.exists() and full_path != target_full_path:
+                            self.io.tool_warning(
+                                "UPDATE Warning: Target file for move already exists, overwriting:"
+                                f" {action.move_path}"
+                            )
+                    else:
+                        self.io.tool_output(f"Updating {action.path}")
+
+                    # Ensure parent directory exists for target
+                    target_path_obj.parent.mkdir(parents=True, exist_ok=True)
+                    self.io.write_text(target_full_path, new_content)
+
+                    # Remove original file *after* successful write to new location if moved
+                    if action.move_path and full_path != target_full_path:
+                        path_obj.unlink()
+
+                else:
+                    # Should not happen
+                    raise DiffError(f"Unknown action type encountered: {action.type}")
+
+            except (DiffError, FileNotFoundError, IOError, OSError) as e:
+                # Raise a ValueError to signal failure, consistent with other coders.
+                raise ValueError(f"Error applying action '{action.type}' to {action.path}: {e}")
+            except Exception as e:
+                # Catch unexpected errors during application
+                raise ValueError(
+                    f"Unexpected error applying action '{action.type}' to {action.path}: {e}"
+                )
+
+    def _apply_update(self, text: str, action: PatchAction, path: str) -> str:
+        """
+        Applies UPDATE chunks to the given text content.
+        Adapted from _get_updated_file in apply_patch.py.
+        """
+        if action.type is not ActionType.UPDATE:
+            # Should not be called otherwise, but check for safety
+            raise DiffError("_apply_update called with non-update action")
+
+        orig_lines = text.splitlines()  # Use splitlines to handle endings consistently
+        dest_lines: List[str] = []
+        current_orig_line_idx = 0  # Tracks index in orig_lines processed so far
+
+        # Sort chunks by their original index to apply them sequentially
+        sorted_chunks = sorted(action.chunks, key=lambda c: c.orig_index)
+
+        for chunk in sorted_chunks:
+            # chunk.orig_index is the absolute line number where the change starts
+            # (where the first deleted line was, or where inserted lines go if no deletes)
+            chunk_start_index = chunk.orig_index
+
+            if chunk_start_index < current_orig_line_idx:
+                # This indicates overlapping chunks or incorrect indices from parsing
+                raise DiffError(
+                    f"{path}: Overlapping or out-of-order chunk detected."
+                    f" Current index {current_orig_line_idx}, chunk starts at {chunk_start_index}."
+                )
+
+            # Add lines from original file between the last chunk and this one
+            dest_lines.extend(orig_lines[current_orig_line_idx:chunk_start_index])
+
+            # Verify that the lines to be deleted actually match the original file content
+            # (The parser should have used find_context, but double-check here)
+            num_del = len(chunk.del_lines)
+            actual_deleted_lines = orig_lines[chunk_start_index : chunk_start_index + num_del]
+
+            # Use the same normalization as find_context_core for comparison robustness
+            norm_chunk_del = [_norm(s).strip() for s in chunk.del_lines]
+            norm_actual_del = [_norm(s).strip() for s in actual_deleted_lines]
+
+            if norm_chunk_del != norm_actual_del:
+                # This indicates the context matching failed or the file changed since parsing
+                # Provide detailed error message
+                expected_str = "\n".join(f"- {s}" for s in chunk.del_lines)
+                actual_str = "\n".join(f"  {s}" for s in actual_deleted_lines)
+                raise DiffError(
+                    f"{path}: Mismatch applying patch near line {chunk_start_index + 1}.\n"
+                    f"Expected lines to remove:\n{expected_str}\n"
+                    f"Found lines in file:\n{actual_str}"
+                )
+
+            # Add the inserted lines from the chunk
+            dest_lines.extend(chunk.ins_lines)
+
+            # Advance the original line index past the lines processed (deleted lines)
+            current_orig_line_idx = chunk_start_index + num_del
+
+        # Add any remaining lines from the original file after the last chunk
+        dest_lines.extend(orig_lines[current_orig_line_idx:])
+
+        # Join lines and ensure a single trailing newline
+        result = "\n".join(dest_lines)
+        if result or orig_lines:  # Add newline unless result is empty and original was empty
+            result += "\n"
+        return result

aider/coders/patch_prompts.py

@@ -0,0 +1,161 @@
+# flake8: noqa: E501
+
+from .base_prompts import CoderPrompts
+from .editblock_prompts import EditBlockPrompts
+
+
+class PatchPrompts(EditBlockPrompts):
+    # --------------------------------------------------------------------- #
+    #  SYSTEM PROMPT
+    # --------------------------------------------------------------------- #
+    main_system = """Act as an expert software developer.
+Always use best practices when coding.
+Respect and use existing conventions, libraries, etc that are already present in the code base.
+{final_reminders}
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+
+Always reply to the user in {language}.
+
+Once you understand the request you MUST:
+
+1. Decide if you need to propose edits to any files that haven't been added to the chat. You can create new files without asking!
+
+   • If you need to propose edits to existing files not already added to the chat, you *MUST* tell the user their full path names and ask them to *add the files to the chat*.
+   • End your reply and wait for their approval.
+   • You can keep asking if you then decide you need to edit more files.
+
+2. Think step‑by‑step and explain the needed changes in a few short sentences.
+
+3. Describe the changes using the V4A diff format, enclosed within `*** Begin Patch` and `*** End Patch` markers.
+
+IMPORTANT: Each file MUST appear only once in the patch.
+Consolidate **all** edits for a given file into a single `*** [ACTION] File:` block.
+{shell_cmd_prompt}
+"""
+
+    # --------------------------------------------------------------------- #
+    #  EXAMPLE MESSAGES
+    # --------------------------------------------------------------------- #
+    example_messages = [
+        # --- Example 1 ---------------------------------------------------- #
+        dict(
+            role="user",
+            content="Change get_factorial() to use math.factorial",
+        ),
+        dict(
+            role="assistant",
+            content="""To make this change we need to modify `mathweb/flask/app.py`:
+
+1. Import the `math` module.
+2. Replace the custom recursive `factorial()` helper with `math.factorial`.
+3. Update `get_factorial()` to call `math.factorial`.
+
+Here is the patch:
+
+*** Begin Patch
+*** Update File: mathweb/flask/app.py
+@@
+-from flask import Flask
+-
+-from flask import Flask
++from flask import Flask
++import math
+@@
+-def factorial(n):
+-    "compute factorial"
+-
+-    if n == 0:
+-        return 1
+-    else:
+-        return n * factorial(n-1)
++def factorial(n):
++    "compute factorial"
++
++    return math.factorial(n)
+@@     def get_factorial(self, n):
+-    return str(factorial(n))
++    return str(math.factorial(n))
+*** End Patch
+""",
+        ),
+        # --- Example 2 ---------------------------------------------------- #
+        dict(
+            role="user",
+            content="Refactor hello() into its own file.",
+        ),
+        dict(
+            role="assistant",
+            content="""To make this change we need to modify `main.py` and create a new file `hello.py`:
+
+1. Create `hello.py` with the `hello()` function.
+2. Remove `hello()` from `main.py` and import it instead.
+
+Here is the patch:
+
+*** Begin Patch
+*** Add File: hello.py
++# A simple function
++def hello():
++    "print a greeting"
++
++    print("hello")
+*** Update File: main.py
+@@
+-def hello():
+-    "print a greeting"
+-
+-    print("hello")
++from hello import hello
+*** End Patch
+""",
+        ),
+    ]
+
+    # --------------------------------------------------------------------- #
+    #  SYSTEM REMINDER
+    # --------------------------------------------------------------------- #
+    system_reminder = """# V4A Diff Format Rules:
+
+Your entire response containing the patch MUST start with `*** Begin Patch` on a line by itself.
+Your entire response containing the patch MUST end with `*** End Patch` on a line by itself.
+
+Use the *FULL* file path, as shown to you by the user.
+{quad_backtick_reminder}
+
+For each file you need to modify, start with a marker line:
+
+    *** [ACTION] File: [path/to/file]
+
+Where `[ACTION]` is one of `Add`, `Update`, or `Delete`.
+
+⇨ **Each file MUST appear only once in the patch.**  
+   Consolidate all changes for that file into the same block.  
+   If you are moving code within a file, include both the deletions and the
+   insertions as separate hunks inside this single `*** Update File:` block
+   (do *not* open a second block for the same file).
+
+For `Update` actions, describe each snippet of code that needs to be changed using the following format:
+1. Context lines: Include 3 lines of context *before* the change. These lines MUST start with a single space ` `.
+2. Lines to remove: Precede each line to be removed with a minus sign `-`.
+3. Lines to add: Precede each line to be added with a plus sign `+`.
+4. Context lines: Include 3 lines of context *after* the change. These lines MUST start with a single space ` `.
+
+Context lines MUST exactly match the existing file content, character for character, including indentation.
+If a change is near the beginning or end of the file, include fewer than 3 context lines as appropriate.
+If 3 lines of context is insufficient to uniquely identify the snippet, use `@@ [CLASS_OR_FUNCTION_NAME]` markers on their own lines *before* the context lines to specify the scope. You can use multiple `@@` markers if needed.
+Do not include line numbers.
+
+Only create patches for files that the user has added to the chat!
+
+When moving code *within* a single file, keep everything inside one
+`*** Update File:` block. Provide one hunk that deletes the code from its
+original location and another hunk that inserts it at the new location.
+
+For `Add` actions, use the `*** Add File: [path/to/new/file]` marker, followed by the lines of the new file, each preceded by a plus sign `+`.
+
+For `Delete` actions, use the `*** Delete File: [path/to/file]` marker. No other lines are needed for the deletion.
+
+{rename_with_shell}{go_ahead_tip}{final_reminders}ONLY EVER RETURN CODE IN THE SPECIFIED V4A DIFF FORMAT!
+{shell_cmd_reminder}
+"""

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
 
@@ -231,20 +235,6 @@ Left
 Left
 """
 
-"""
-ri = RelativeIndenter([example])
-dump(example)
-
-rel_example = ri.make_relative(example)
-dump(repr(rel_example))
-
-abs_example = ri.make_absolute(rel_example)
-dump(abs_example)
-
-
-sys.exit()
-"""
-
 
 def relative_indent(texts):
     ri = RelativeIndenter(texts)
@@ -345,7 +335,7 @@ def lines_to_chars(lines, mapping):
     return new_text
 
 
-def dmp_lines_apply(texts, remap=True):
+def dmp_lines_apply(texts):
     debug = False
     # debug = True
 
@@ -651,8 +641,6 @@ def proc(dname):
         (dmp_lines_apply, all_preprocs),
     ]
 
-    _strategies = editblock_strategies  # noqa: F841
-
     short_names = dict(
         search_and_replace="sr",
         git_cherry_pick_osr_onto_o="cp_o",

aider/coders/shell.py

@@ -0,0 +1,37 @@
+shell_cmd_prompt = """
+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 are ready to execute, without placeholders.
+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}
+Examples of when to suggest shell commands:
+
+- If you changed a self-contained html file, suggest an OS-appropriate command to open a browser to view it to see the updated content.
+- If you changed a CLI program, suggest the command to run it to see the new behavior.
+- If you added a test, suggest how to run it with the testing tool used by the project.
+- Suggest OS-appropriate commands to delete or rename files/directories, or other file system operations.
+- If your code changes add new dependencies, suggest the command to install them.
+- Etc.
+"""  # noqa
+
+no_shell_cmd_prompt = """
+Keep in mind these details about the user's platform and environment:
+{platform}
+"""  # noqa
+
+shell_cmd_reminder = """
+Examples of when to suggest shell commands:
+
+- If you changed a self-contained html file, suggest an OS-appropriate command to open a browser to view it to see the updated content.
+- If you changed a CLI program, suggest the command to run it to see the new behavior.
+- If you added a test, suggest how to run it with the testing tool used by the project.
+- Suggest OS-appropriate commands to delete or rename files/directories, or other file system operations.
+- If your code changes add new dependencies, suggest the command to install them.
+- Etc.
+
+"""  # noqa

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_coder.py

@@ -45,6 +45,7 @@ other_hunks_applied = (
 
 class UnifiedDiffCoder(Coder):
     """A coder that uses unified diff format for code modifications."""
+
     edit_format = "udiff"
     gpt_prompts = UnifiedDiffPrompts()
 
@@ -344,7 +345,16 @@ def process_fenced_block(lines, start_line_num):
 
     if block[0].startswith("--- ") and block[1].startswith("+++ "):
         # Extract the file path, considering that it might contain spaces
-        fname = block[1][4:].strip()
+        a_fname = block[0][4:].strip()
+        b_fname = block[1][4:].strip()
+
+        # Check if standard git diff prefixes are present (or /dev/null) and strip them
+        if (a_fname.startswith("a/") or a_fname == "/dev/null") and b_fname.startswith("b/"):
+            fname = b_fname[2:]
+        else:
+            # Otherwise, assume the path is as intended
+            fname = b_fname
+
         block = block[2:]
     else:
         fname = None

aider/coders/udiff_prompts.py

@@ -1,18 +1,19 @@
 # flake8: noqa: E501
 
+from . import shell
 from .base_prompts import CoderPrompts
 
 
 class UnifiedDiffPrompts(CoderPrompts):
     main_system = """Act as an expert software developer.
-{lazy_prompt}
+{final_reminders}
 Always use best practices when coding.
 Respect and use existing conventions, libraries, etc that are already present in the code base.
 
 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.
 """
@@ -106,5 +107,9 @@ To move code within a file, use 2 hunks: 1 to delete it from its current locatio
 
 To make a new file, show a diff from `--- /dev/null` to `+++ path/to/new/file.ext`.
 
-{lazy_prompt}
+{final_reminders}
 """
+
+    shell_cmd_prompt = shell.shell_cmd_prompt
+    no_shell_cmd_prompt = shell.no_shell_cmd_prompt
+    shell_cmd_reminder = shell.shell_cmd_reminder

aider/coders/udiff_simple.py

@@ -0,0 +1,14 @@
+from .udiff_coder import UnifiedDiffCoder
+from .udiff_simple_prompts import UnifiedDiffSimplePrompts
+
+
+class UnifiedDiffSimpleCoder(UnifiedDiffCoder):
+    """
+    A coder that uses unified diff format for code modifications.
+    This variant uses a simpler prompt that doesn't mention specific
+    diff rules like using `@@ ... @@` lines or avoiding line numbers.
+    """
+
+    edit_format = "udiff-simple"
+
+    gpt_prompts = UnifiedDiffSimplePrompts()

aider/coders/udiff_simple_prompts.py

@@ -0,0 +1,25 @@
+from .udiff_prompts import UnifiedDiffPrompts
+
+
+class UnifiedDiffSimplePrompts(UnifiedDiffPrompts):
+    """
+    Prompts for the UnifiedDiffSimpleCoder.
+    Inherits from UnifiedDiffPrompts and can override specific prompts
+    if a simpler wording is desired for this edit format.
+    """
+
+    example_messages = []
+
+    system_reminder = """# File editing rules:
+
+Return edits similar to unified diffs that `diff -U0` would produce.
+
+The user's patch tool needs CORRECT patches that apply cleanly against the current contents of the file!
+Think carefully and make sure you include and mark all lines that need to be removed or changed as `-` lines.
+Make sure you mark all new or modified lines with `+`.
+Don't leave out any lines or the diff patch won't apply correctly.
+
+To make a new file, show a diff from `--- /dev/null` to `+++ path/to/new/file.ext`.
+
+{final_reminders}
+""" # noqa

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()
 

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,9 +8,9 @@ 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}
+{final_reminders}
 Once you understand the request you MUST:
 1. Determine if any code changes are needed.
 2. Explain any needed changes.
@@ -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]}
@@ -61,7 +61,7 @@ To suggest changes to a file you MUST return a *file listing* that contains the
 *NEVER* skip, omit or elide content from a *file listing* using "..." or by adding comments like "... rest of code..."!
 Create a new file you MUST return a *file listing* which includes an appropriate filename, including any appropriate path.
 
-{lazy_prompt}
+{final_reminders}
 """
 
     redacted_edit_message = "No changes are needed."

aider/commands.py

@@ -1,9 +1,11 @@
+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
@@ -12,8 +14,10 @@ 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.io import CommandCompletionException
 from aider.llm import litellm
 from aider.repo import ANY_GIT_ERROR
 from aider.run_cmd import run_cmd
@@ -24,8 +28,9 @@ from .dump import dump  # noqa: F401
 
 
 class SwitchCoder(Exception):
-    def __init__(self, **kwargs):
+    def __init__(self, placeholder=None, **kwargs):
         self.kwargs = kwargs
+        self.placeholder = placeholder
 
 
 class Commands:
@@ -40,10 +45,23 @@ 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,
+        original_read_only_fnames=None,
     ):
         self.io = io
         self.coder = coder
@@ -56,14 +74,58 @@ 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
+
+        # Store the original read-only filenames provided via args.read
+        self.original_read_only_fnames = set(original_read_only_fnames or [])
 
     def cmd_model(self, args):
-        "Switch to a new LLM"
+        "Switch the Main Model to a new LLM"
 
         model_name = args.strip()
-        model = models.Model(model_name)
+        model = models.Model(
+            model_name,
+            editor_model=self.coder.main_model.editor_model.name,
+            weak_model=self.coder.main_model.weak_model.name,
+        )
+        models.sanity_check_models(self.io, model)
+
+        # Check if the current edit format is the default for the old model
+        old_model_edit_format = self.coder.main_model.edit_format
+        current_edit_format = self.coder.edit_format
+
+        new_edit_format = current_edit_format
+        if current_edit_format == old_model_edit_format:
+            # If the user was using the old model's default, switch to the new model's default
+            new_edit_format = model.edit_format
+
+        raise SwitchCoder(main_model=model, edit_format=new_edit_format)
+
+    def cmd_editor_model(self, args):
+        "Switch the Editor Model to a new LLM"
+
+        model_name = args.strip()
+        model = models.Model(
+            self.coder.main_model.name,
+            editor_model=model_name,
+            weak_model=self.coder.main_model.weak_model.name,
+        )
+        models.sanity_check_models(self.io, model)
+        raise SwitchCoder(main_model=model)
+
+    def cmd_weak_model(self, args):
+        "Switch the Weak Model to a new LLM"
+
+        model_name = args.strip()
+        model = models.Model(
+            self.coder.main_model.name,
+            editor_model=self.coder.main_model.editor_model.name,
+            weak_model=model_name,
+        )
         models.sanity_check_models(self.io, model)
         raise SwitchCoder(main_model=model)
 
@@ -89,6 +151,17 @@ 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."
+                    ),
+                ),
+                (
+                    "context",
+                    "Automatically identify which files will need to be edited.",
+                ),
             ]
         )
 
@@ -137,7 +210,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()
@@ -156,11 +229,16 @@ 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:
+            return content
 
-        self.io.tool_output("... done.")
+        self.io.tool_output("... added to chat.")
 
-        return content
+        self.coder.cur_messages += [
+            dict(role="user", content=content),
+            dict(role="assistant", content="Ok."),
+        ]
 
     def is_command(self, inp):
         return inp[0] in "/!"
@@ -221,6 +299,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)
@@ -228,9 +307,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:
@@ -320,7 +403,21 @@ class Commands:
 
     def _drop_all_files(self):
         self.coder.abs_fnames = set()
-        self.coder.abs_read_only_fnames = set()
+
+        # When dropping all files, keep those that were originally provided via args.read
+        if self.original_read_only_fnames:
+            # Keep only the original read-only files
+            to_keep = set()
+            for abs_fname in self.coder.abs_read_only_fnames:
+                rel_fname = self.coder.get_rel_fname(abs_fname)
+                if (
+                    abs_fname in self.original_read_only_fnames
+                    or rel_fname in self.original_read_only_fnames
+                ):
+                    to_keep.add(abs_fname)
+            self.coder.abs_read_only_fnames = to_keep
+        else:
+            self.coder.abs_read_only_fnames = set()
 
     def _clear_chat_history(self):
         self.coder.done_messages = []
@@ -369,6 +466,7 @@ class Commands:
 
         fence = "`" * 3
 
+        file_res = []
         # files
         for fname in self.coder.abs_fnames:
             relative_fname = self.coder.get_rel_fname(fname)
@@ -379,7 +477,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:
@@ -389,7 +487,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:"
@@ -566,6 +667,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,
@@ -584,7 +689,7 @@ class Commands:
         text = document.text_before_cursor
 
         # Skip the first word and the space after it
-        after_command = " ".join(text.split()[1:])
+        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))
@@ -601,17 +706,41 @@ class Commands:
         # 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)
-            yield Completion(
-                text=quoted_text,
-                start_position=adjusted_start_position,
-                display=completion.display,
-                style=completion.style,
-                selected_style=completion.selected_style,
+            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())
         files = files - set(self.coder.get_inchat_relative_files())
@@ -628,7 +757,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}")
@@ -693,12 +822,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):
@@ -707,6 +837,10 @@ 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_error(f"{matched_file} is already in the chat as an editable file")
                 continue
@@ -722,7 +856,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."
@@ -733,7 +869,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):
@@ -747,7 +884,12 @@ class Commands:
         "Remove files from the chat session to free up context space"
 
         if not args.strip():
-            self.io.tool_output("Dropping all files from the chat session.")
+            if self.original_read_only_fnames:
+                self.io.tool_output(
+                    "Dropping all files from the chat session except originally read-only files."
+                )
+            else:
+                self.io.tool_output("Dropping all files from the chat session.")
             self._drop_all_files()
             return
 
@@ -756,15 +898,33 @@ class Commands:
             # Expand tilde in the path
             expanded_word = os.path.expanduser(word)
 
-            # Handle read-only files separately, without glob_filtered_to_repo
-            read_only_matched = [f for f in self.coder.abs_read_only_fnames if expanded_word in f]
+            # Handle read-only files with substring matching and samefile check
+            read_only_matched = []
+            for f in self.coder.abs_read_only_fnames:
+                if expanded_word in f:
+                    read_only_matched.append(f)
+                    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")
+                # 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
 
-            matched_files = self.glob_filtered_to_repo(expanded_word)
+            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)
@@ -824,54 +984,53 @@ 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()
-            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)
+            add = self.io.confirm_ask(f"Add {k_tokens:.1f}k tokens of command output to the chat?")
 
         if add:
-            for line in combined_output.splitlines():
-                self.io.tool_output(line, log_only=True)
+            num_lines = len(combined_output.strip().splitlines())
+            line_plural = "line" if num_lines == 1 else "lines"
+            self.io.tool_output(f"Added {num_lines} {line_plural} of output to the chat.")
 
             msg = prompts.run_output.format(
                 command=args,
                 output=combined_output,
             )
 
-            if instructions:
-                msg = instructions + "\n\n" + msg
+            self.coder.cur_messages += [
+                dict(role="user", content=msg),
+                dict(role="assistant", content="Ok."),
+            ]
 
-            return msg
+            if add_on_nonzero_exit and exit_status != 0:
+                # Return the formatted output message for test failures
+                return msg
+            elif add and exit_status != 0:
+                self.io.placeholder = "What's wrong? Fix"
+
+        # Return None if output wasn't added or command succeeded
+        return None
 
     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"
@@ -935,7 +1094,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)
@@ -978,24 +1138,40 @@ class Commands:
             show_announcements=False,
         )
 
+    def completions_ask(self):
+        raise CommandCompletionException()
+
+    def completions_code(self):
+        raise CommandCompletionException()
+
+    def completions_architect(self):
+        raise CommandCompletionException()
+
+    def completions_context(self):
+        raise CommandCompletionException()
+
     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 mode to discuss high-level design and architecture"
+        """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.")
-            return
+    def cmd_context(self, args):
+        """Enter context mode to see surrounding code context. If no prompt provided, switches to context mode."""  # noqa
+        return self._generic_chat_command(args, "context", placeholder=args.strip() or None)
 
-        from aider.coders import Coder
+    def _generic_chat_command(self, args, edit_format, placeholder=None):
+        if not args.strip():
+            # Switch to the corresponding chat mode if no args provided
+            return self.cmd_chat_mode(edit_format)
+
+        from aider.coders.base_coder import Coder
 
         coder = Coder.create(
             io=self.io,
@@ -1007,11 +1183,13 @@ class Commands:
         user_msg = args
         coder.run(user_msg)
 
+        # Use the provided placeholder if any
         raise SwitchCoder(
             edit_format=self.coder.edit_format,
             summarize_from_coder=False,
             from_coder=coder,
             show_announcements=False,
+            placeholder=placeholder,
         )
 
     def get_help_md(self):
@@ -1042,43 +1220,23 @@ class Commands:
                 self.io.tool_error("To use /voice you must provide an OpenAI API key.")
                 return
             try:
-                self.voice = voice.Voice(audio_format=self.args.voice_format)
+                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.print()
-            self.io.user_input(text, log_only=False)
-            self.io.print()
-
-        return text
+            self.io.placeholder = text
 
     def cmd_paste(self, args):
         """Paste image/text from the clipboard into the chat.\
@@ -1131,29 +1289,52 @@ 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:
-            # Expand the home directory if the path starts with "~"
-            expanded_path = os.path.expanduser(word)
-            abs_path = self.coder.abs_root_path(expanded_path)
+        all_paths = []
 
-            if not os.path.exists(abs_path):
-                self.io.tool_error(f"Path not found: {abs_path}")
-                continue
+        # First collect all expanded paths
+        for pattern in filenames:
+            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 is_image_file(original_name) and not self.coder.main_model.info.get("supports_vision"):
+            self.io.tool_error(
+                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
@@ -1203,7 +1384,75 @@ 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"
@@ -1246,6 +1495,113 @@ 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_edit(self, args=""):
+        "Alias for /editor: Open an editor to write a prompt"
+        return self.cmd_editor(args)
+
+    def cmd_think_tokens(self, args):
+        "Set the thinking token budget (supports formats like 8096, 8k, 10.5k, 0.5M)"
+        model = self.coder.main_model
+
+        if not args.strip():
+            # Display current value if no args are provided
+            formatted_budget = model.get_thinking_tokens()
+            if formatted_budget is None:
+                self.io.tool_output("Thinking tokens are not currently set.")
+            else:
+                budget = model.get_raw_thinking_tokens()
+                self.io.tool_output(
+                    f"Current thinking token budget: {budget:,} tokens ({formatted_budget})."
+                )
+            return
+
+        value = args.strip()
+        model.set_thinking_tokens(value)
+
+        formatted_budget = model.get_thinking_tokens()
+        budget = model.get_raw_thinking_tokens()
+
+        self.io.tool_output(f"Set thinking token budget to {budget:,} tokens ({formatted_budget}).")
+        self.io.tool_output()
+
+        # Output announcements
+        announcements = "\n".join(self.coder.get_announcements())
+        self.io.tool_output(announcements)
+
+    def cmd_reasoning_effort(self, args):
+        "Set the reasoning effort level (values: number or low/medium/high depending on model)"
+        model = self.coder.main_model
+
+        if not args.strip():
+            # Display current value if no args are provided
+            reasoning_value = model.get_reasoning_effort()
+            if reasoning_value is None:
+                self.io.tool_output("Reasoning effort is not currently set.")
+            else:
+                self.io.tool_output(f"Current reasoning effort: {reasoning_value}")
+            return
+
+        value = args.strip()
+        model.set_reasoning_effort(value)
+        reasoning_value = model.get_reasoning_effort()
+        self.io.tool_output(f"Set reasoning effort to {reasoning_value}")
+        self.io.tool_output()
+
+        # Output announcements
+        announcements = "\n".join(self.coder.get_announcements())
+        self.io.tool_output(announcements)
+
+    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/deprecated.py

@@ -0,0 +1,126 @@
+def add_deprecated_model_args(parser, group):
+    """Add deprecated model shortcut arguments to the argparse parser."""
+    opus_model = "claude-3-opus-20240229"
+    group.add_argument(
+        "--opus",
+        action="store_true",
+        help=f"Use {opus_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    sonnet_model = "anthropic/claude-3-7-sonnet-20250219"
+    group.add_argument(
+        "--sonnet",
+        action="store_true",
+        help=f"Use {sonnet_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    haiku_model = "claude-3-5-haiku-20241022"
+    group.add_argument(
+        "--haiku",
+        action="store_true",
+        help=f"Use {haiku_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4_model = "gpt-4-0613"
+    group.add_argument(
+        "--4",
+        "-4",
+        action="store_true",
+        help=f"Use {gpt_4_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4o_model = "gpt-4o"
+    group.add_argument(
+        "--4o",
+        action="store_true",
+        help=f"Use {gpt_4o_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4o_mini_model = "gpt-4o-mini"
+    group.add_argument(
+        "--mini",
+        action="store_true",
+        help=f"Use {gpt_4o_mini_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4_turbo_model = "gpt-4-1106-preview"
+    group.add_argument(
+        "--4-turbo",
+        action="store_true",
+        help=f"Use {gpt_4_turbo_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_3_model_name = "gpt-3.5-turbo"
+    group.add_argument(
+        "--35turbo",
+        "--35-turbo",
+        "--3",
+        "-3",
+        action="store_true",
+        help=f"Use {gpt_3_model_name} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    deepseek_model = "deepseek/deepseek-chat"
+    group.add_argument(
+        "--deepseek",
+        action="store_true",
+        help=f"Use {deepseek_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    o1_mini_model = "o1-mini"
+    group.add_argument(
+        "--o1-mini",
+        action="store_true",
+        help=f"Use {o1_mini_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    o1_preview_model = "o1-preview"
+    group.add_argument(
+        "--o1-preview",
+        action="store_true",
+        help=f"Use {o1_preview_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+
+
+def handle_deprecated_model_args(args, io):
+    """Handle deprecated model shortcut arguments and provide appropriate warnings."""
+    # Define model mapping
+    model_map = {
+        "opus": "claude-3-opus-20240229",
+        "sonnet": "anthropic/claude-3-7-sonnet-20250219",
+        "haiku": "claude-3-5-haiku-20241022",
+        "4": "gpt-4-0613",
+        "4o": "gpt-4o",
+        "mini": "gpt-4o-mini",
+        "4_turbo": "gpt-4-1106-preview",
+        "35turbo": "gpt-3.5-turbo",
+        "deepseek": "deepseek/deepseek-chat",
+        "o1_mini": "o1-mini",
+        "o1_preview": "o1-preview",
+    }
+
+    # Check if any deprecated args are used
+    for arg_name, model_name in model_map.items():
+        arg_name_clean = arg_name.replace("-", "_")
+        if hasattr(args, arg_name_clean) and getattr(args, arg_name_clean):
+            # Find preferred name to display in warning
+            from aider.models import MODEL_ALIASES
+
+            display_name = model_name
+            # Check if there's a shorter alias for this model
+            for alias, full_name in MODEL_ALIASES.items():
+                if full_name == model_name:
+                    display_name = alias
+                    break
+
+            # Show the warning
+            io.tool_warning(
+                f"The --{arg_name.replace('_', '-')} flag is deprecated and will be removed in a"
+                f" future version. Please use --model {display_name} instead."
+            )
+
+            # Set the model
+            if not args.model:
+                args.model = model_name
+            break

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,147 @@
+"""
+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 subprocess
+import tempfile
+
+from rich.console import Console
+
+from aider.dump import dump  # noqa
+
+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.
+
+    Handles cases where the editor command includes arguments, including quoted arguments
+    with spaces (e.g. 'vim -c "set noswapfile"').
+
+    :return: The editor command as a string
+    :rtype: 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)
+
+    return editor
+
+
+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_str = discover_editor(editor)
+    command_str += " " + filepath
+
+    subprocess.call(command_str, 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,107 @@
+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")
+            if "OpenrouterException" in str(ex) and "'choices'" in str(ex):
+                return ExInfo(
+                    "APIConnectionError",
+                    True,
+                    (
+                        "OpenRouter or the upstream API provider is down, overloaded or rate"
+                        " limiting your requests."
+                    ),
+                )
+
+        # Check for specific non-retryable APIError cases like insufficient credits
+        if ex.__class__ is litellm.APIError:
+            err_str = str(ex).lower()
+            if "insufficient credits" in err_str and '"code":402' in err_str:
+                return ExInfo(
+                    "APIError",
+                    False,
+                    "Insufficient credits with the API provider. Please add credits.",
+                )
+            # Fall through to default APIError handling if not the specific credits error
+
+        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

@@ -40,24 +40,45 @@ def get_package_files():
 
 
 def fname_to_url(filepath):
-    website = "website/"
-    index = "/index.md"
+    website = "website"
+    index = "index.md"
     md = ".md"
 
-    docid = ""
-    if filepath.startswith("website/_includes/"):
-        pass
-    elif filepath.startswith(website):
-        docid = filepath[len(website) :]
+    # Convert backslashes to forward slashes for consistency
+    filepath = filepath.replace("\\", "/")
 
-        if filepath.endswith(index):
-            filepath = filepath[: -len(index)] + "/"
-        elif filepath.endswith(md):
-            filepath = filepath[: -len(md)] + ".html"
+    # Convert to Path object for easier manipulation
+    path = Path(filepath)
 
-        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():

aider/help_pats.py

@@ -1,4 +1,7 @@
+# This needs to sync with MANIFEST.in
+
 exclude_website_pats = [
+    "**/.DS_Store",
     "examples/**",
     "_posts/**",
     "HISTORY.md",
@@ -7,4 +10,10 @@ exclude_website_pats = [
     "docs/unified-diffs.md",
     "docs/leaderboards/index.md",
     "assets/**",
+    ".jekyll-metadata",
+    "Gemfile.lock",
+    "Gemfile",
+    "_config.yml",
+    "**/OLD/**",
+    "OLD/**",
 ]

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(
-                    model.name, summarize_messages, extra_params=model.extra_params
-                )
+                summary = model.simple_send_with_retries(summarize_messages)
                 if summary is not None:
                     summary = prompts.summary_prefix + summary
                     return [dict(role="user", content=summary)]

aider/io.py

@@ -1,20 +1,33 @@
 import base64
+import functools
 import os
+import shutil
+import signal
+import subprocess
+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.key_binding.vi_state import InputMode
+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.color import ColorParseError
+from rich.columns import Columns
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.style import Style as RichStyle
@@ -23,8 +36,47 @@ from rich.text import Text
 from aider.mdstream import MarkdownStream
 
 from .dump import dump  # noqa: F401
+from .editor import pipe_editor
 from .utils import is_image_file
 
+# Constants
+NOTIFICATION_MESSAGE = "Aider is waiting for your input"
+
+
+def ensure_hash_prefix(color):
+    """Ensure hex color values have a # prefix."""
+    if not color:
+        return color
+    if isinstance(color, str) and color.strip() and not color.startswith("#"):
+        # Check if it's a valid hex color (3 or 6 hex digits)
+        if all(c in "0123456789ABCDEFabcdef" for c in color) and len(color) in (3, 6):
+            return f"#{color}"
+    return color
+
+
+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
+
+
+class CommandCompletionException(Exception):
+    """Raised when a command should use the normal autocompleter instead of
+    command-specific completion."""
+
+    pass
+
 
 @dataclass
 class ConfirmGroup:
@@ -144,14 +196,23 @@ class AutoCompleter(Completer):
             return
 
         if text[0] == "/":
-            yield from self.get_command_completions(document, complete_event, text, words)
-            return
+            try:
+                yield from self.get_command_completions(document, complete_event, text, words)
+                return
+            except CommandCompletionException:
+                # Fall through to normal completion
+                pass
 
         candidates = self.words
         candidates.update(set(self.fname_to_rel_fnames))
         candidates = [word if type(word) is tuple else (word, word) for word in candidates]
 
         last_word = words[-1]
+
+        # Only provide completions if the user has typed at least 3 characters
+        if len(last_word) < 3:
+            return
+
         completions = []
         for word_match, word_insert in candidates:
             if word_match.lower().startswith(last_word.lower()):
@@ -169,6 +230,9 @@ class AutoCompleter(Completer):
 class InputOutput:
     num_error_outputs = 0
     num_user_asks = 0
+    clipboard_watcher = None
+    bell_on_next_input = False
+    notifications_command = None
 
     def __init__(
         self,
@@ -189,25 +253,48 @@ class InputOutput:
         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=".",
+        notifications=False,
+        notifications_command=None,
     ):
+        self.placeholder = None
+        self.interrupted = False
         self.never_prompts = set()
         self.editingmode = editingmode
+        self.multiline_mode = multiline_mode
+        self.bell_on_next_input = False
+        self.notifications = notifications
+        if notifications and notifications_command is None:
+            self.notifications_command = self.get_default_notification_command()
+        else:
+            self.notifications_command = notifications_command
+
         no_color = os.environ.get("NO_COLOR")
         if no_color is not None and no_color != "":
             pretty = False
 
-        self.user_input_color = user_input_color if pretty else None
-        self.tool_output_color = tool_output_color if pretty else None
-        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.user_input_color = ensure_hash_prefix(user_input_color) if pretty else None
+        self.tool_output_color = ensure_hash_prefix(tool_output_color) if pretty else None
+        self.tool_error_color = ensure_hash_prefix(tool_error_color) if pretty else None
+        self.tool_warning_color = ensure_hash_prefix(tool_warning_color) if pretty else None
+        self.assistant_output_color = ensure_hash_prefix(assistant_output_color)
+        self.completion_menu_color = ensure_hash_prefix(completion_menu_color) if pretty else None
+        self.completion_menu_bg_color = (
+            ensure_hash_prefix(completion_menu_bg_color) if pretty else None
+        )
+        self.completion_menu_current_color = (
+            ensure_hash_prefix(completion_menu_current_color) if pretty else None
+        )
+        self.completion_menu_current_bg_color = (
+            ensure_hash_prefix(completion_menu_current_bg_color) if pretty else None
+        )
 
         self.code_theme = code_theme
 
@@ -228,21 +315,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:
-            # Initialize PromptSession
+        self.is_dumb_terminal = is_dumb_terminal()
+
+        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,
-                "cursor": ModalCursorShapeConfig(),
             }
+            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:
@@ -253,6 +356,40 @@ 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
+
+        # Validate color settings after console is initialized
+        self._validate_color_settings()
+
+    def _validate_color_settings(self):
+        """Validate configured color strings and reset invalid ones."""
+        color_attributes = [
+            "user_input_color",
+            "tool_output_color",
+            "tool_error_color",
+            "tool_warning_color",
+            "assistant_output_color",
+            "completion_menu_color",
+            "completion_menu_bg_color",
+            "completion_menu_current_color",
+            "completion_menu_current_bg_color",
+        ]
+        for attr_name in color_attributes:
+            color_value = getattr(self, attr_name, None)
+            if color_value:
+                try:
+                    # Try creating a style to validate the color
+                    RichStyle(color=color_value)
+                except ColorParseError as e:
+                    self.console.print(
+                        "[bold red]Warning:[/bold red] Invalid configuration for"
+                        f" {attr_name}: '{color_value}'. {e}. Disabling this color."
+                    )
+                    setattr(self, attr_name, None)  # Reset invalid color to None
 
     def _get_style(self):
         style_dict = {}
@@ -279,9 +416,9 @@ class InputOutput:
         # 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}")
+            completion_menu_current_style.append(self.completion_menu_current_bg_color)
         if self.completion_menu_current_color:
-            completion_menu_current_style.append(self.completion_menu_current_color)
+            completion_menu_current_style.append(f"bg:{self.completion_menu_current_color}")
         if completion_menu_current_style:
             style_dict["completion-menu.completion.current"] = " ".join(
                 completion_menu_current_style
@@ -307,35 +444,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:
-            self.tool_error(f"{filename}: file not found error")
+            if not silent:
+                self.tool_error(f"{filename}: file not found error")
             return
         except IsADirectoryError:
-            self.tool_error(f"{filename}: is a directory")
+            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:
-            self.tool_error(f"{filename}: {e}")
-            self.tool_error("Use --encoding to set the unicode encoding.")
+            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
-        try:
-            with open(str(filename), "w", encoding=self.encoding) as f:
-                f.write(content)
-        except OSError as err:
-            self.tool_error(f"Unable to write file {filename}: {err}")
+
+        delay = initial_delay
+        for attempt in range(max_retries):
+            try:
+                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:
@@ -344,6 +507,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,
@@ -355,13 +525,26 @@ class InputOutput:
     ):
         self.rule()
 
+        # Ring the bell if needed
+        self.ring_bell()
+
         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)
+
+        prompt_prefix = ""
         if edit_format:
-            show += edit_format
-        show += "> "
+            prompt_prefix += edit_format
+        if self.multiline_mode:
+            prompt_prefix += (" " if edit_format else "") + "multi"
+        prompt_prefix += "> "
+
+        show += prompt_prefix
+        self.prompt_prefix = prompt_prefix
 
         inp = ""
         multiline_input = False
@@ -379,44 +562,161 @@ class InputOutput:
             )
         )
 
+        def suspend_to_bg(event):
+            """Suspend currently running application."""
+            event.app.suspend_to_background()
+
         kb = KeyBindings()
 
+        @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("escape", "c-m", eager=True)
+        @kb.add("c-up")
         def _(event):
-            event.current_buffer.insert_text("\n")
+            "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("c-x", "c-e")
+        def _(event):
+            "Edit current input in external editor (like Bash)"
+            buffer = event.current_buffer
+            current_text = buffer.text
+
+            # Open the editor with the current text
+            edited_text = pipe_editor(input_data=current_text, suffix="md")
+
+            # Replace the buffer with the edited text, strip any trailing newlines
+            buffer.text = edited_text.rstrip("\n")
+
+            # Move cursor to the end of the text
+            buffer.cursor_position = len(buffer.text)
+
+        @kb.add("enter", eager=True, filter=~is_searching)
+        def _(event):
+            "Handle Enter key press"
+            if self.multiline_mode and not (
+                self.editingmode == EditingMode.VI
+                and event.app.vi_state.input_mode == InputMode.NAVIGATION
+            ):
+                # In multiline mode and if not in vi-mode or vi navigation/normal 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:
             if multiline_input:
-                show = ". "
+                show = self.prompt_prefix
 
             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 self.prompt_prefix
+
                     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:
-                multiline_input = True
-                inp += line[1:] + "\n"
+            if line.strip("\r\n") and not multiline_input:
+                stripped = line.strip("\r\n")
+                if stripped == "{":
+                    multiline_input = True
+                    multiline_tag = None
+                    inp += ""
+                elif stripped[0] == "{":
+                    # 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 line and line[-1] == "}" and multiline_input:
-                inp += line[:-1] + "\n"
-                break
+            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:
@@ -430,10 +730,13 @@ class InputOutput:
     def add_to_input_history(self, inp):
         if not self.input_history_file:
             return
-        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"):
-            self.session.history.append_string(inp)
+        try:
+            FileHistory(self.input_history_file).append_string(inp)
+            # Also add to the in-memory history if it exists
+            if self.prompt_session and self.prompt_session.history:
+                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:
@@ -450,14 +753,17 @@ class InputOutput:
             log_file.write(f"{role.upper()} {timestamp}\n")
             log_file.write(content + "\n")
 
+    def display_user_input(self, inp):
+        if self.pretty and self.user_input_color:
+            style = dict(style=self.user_input_color)
+        else:
+            style = dict()
+
+        self.console.print(Text(inp), **style)
+
     def user_input(self, inp, log_only=True):
         if not log_only:
-            if self.pretty and self.user_input_color:
-                style = dict(style=self.user_input_color)
-            else:
-                style = dict()
-
-            self.console.print(Text(inp), **style)
+            self.display_user_input(inp)
 
         prefix = "####"
         if inp:
@@ -477,6 +783,16 @@ 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,
@@ -488,6 +804,9 @@ class InputOutput:
     ):
         self.num_user_asks += 1
 
+        # Ring the bell if needed
+        self.ring_bell()
+
         question_id = (question, subject)
 
         if question_id in self.never_prompts:
@@ -498,19 +817,22 @@ class InputOutput:
         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")
 
-        question += options + " [Yes]: "
+        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()
@@ -539,16 +861,22 @@ class InputOutput:
             self.user_input(f"{question}{res}", log_only=False)
         else:
             while True:
-                if self.prompt_session:
-                    res = self.prompt_session.prompt(
-                        question,
-                        style=style,
-                    )
-                else:
-                    res = input(question)
+                try:
+                    if self.prompt_session:
+                        res = self.prompt_session.prompt(
+                            question,
+                            style=style,
+                            complete_while_typing=False,
+                        )
+                    else:
+                        res = input(question)
+                except EOFError:
+                    # Treat EOF (Ctrl+D) as if the user pressed Enter
+                    res = default
+                    break
 
                 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)
@@ -585,9 +913,13 @@ class InputOutput:
 
         return is_yes
 
+    @restore_multiline
     def prompt_ask(self, question, default="", subject=None):
         self.num_user_asks += 1
 
+        # Ring the bell if needed
+        self.ring_bell()
+
         if subject:
             self.tool_output()
             self.tool_output(subject, bold=True)
@@ -599,10 +931,19 @@ class InputOutput:
         elif self.yes is False:
             res = "no"
         else:
-            if self.prompt_session:
-                res = self.prompt_session.prompt(question + " ", default=default, style=style)
-            else:
-                res = input(question + " ")
+            try:
+                if self.prompt_session:
+                    res = self.prompt_session.prompt(
+                        question + " ",
+                        default=default,
+                        style=style,
+                        complete_while_typing=True,
+                    )
+                else:
+                    res = input(question + " ")
+            except EOFError:
+                # Treat EOF (Ctrl+D) as if the user pressed Enter
+                res = default
 
         hist = f"{question.strip()} {res.strip()}"
         self.append_chat_history(hist, linebreak=True, blockquote=True)
@@ -620,9 +961,18 @@ class InputOutput:
                 hist = message.strip() if strip else message
                 self.append_chat_history(hist, linebreak=True, blockquote=True)
 
-        message = Text(message)
+        if not isinstance(message, Text):
+            message = Text(message)
+        color = ensure_hash_prefix(color) if color else None
         style = dict(style=color) if self.pretty and color else dict()
-        self.console.print(message, **style)
+        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):
         self.num_error_outputs += 1
@@ -644,7 +994,7 @@ class InputOutput:
         style = dict()
         if self.pretty:
             if self.tool_output_color:
-                style["color"] = self.tool_output_color
+                style["color"] = ensure_hash_prefix(self.tool_output_color)
             style["reverse"] = bold
 
         style = RichStyle(**style)
@@ -656,6 +1006,10 @@ class InputOutput:
         return mdStream
 
     def assistant_output(self, message, pretty=None):
+        if not message:
+            self.tool_warning("Empty response received from LLM. Check your provider account?")
+            return
+
         show_resp = message
 
         # Coder will force pretty off if fence is not triple-backticks
@@ -667,13 +1021,84 @@ class InputOutput:
                 message, style=self.assistant_output_color, code_theme=self.code_theme
             )
         else:
-            show_resp = Text(message or "<no response>")
+            show_resp = Text(message or "(empty response)")
 
         self.console.print(show_resp)
 
+    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 llm_started(self):
+        """Mark that the LLM has started processing, so we should ring the bell on next input"""
+        self.bell_on_next_input = True
+
+    def get_default_notification_command(self):
+        """Return a default notification command based on the operating system."""
+        import platform
+
+        system = platform.system()
+
+        if system == "Darwin":  # macOS
+            # Check for terminal-notifier first
+            if shutil.which("terminal-notifier"):
+                return f"terminal-notifier -title 'Aider' -message '{NOTIFICATION_MESSAGE}'"
+            # Fall back to osascript
+            return (
+                f'osascript -e \'display notification "{NOTIFICATION_MESSAGE}" with title "Aider"\''
+            )
+        elif system == "Linux":
+            # Check for common Linux notification tools
+            for cmd in ["notify-send", "zenity"]:
+                if shutil.which(cmd):
+                    if cmd == "notify-send":
+                        return f"notify-send 'Aider' '{NOTIFICATION_MESSAGE}'"
+                    elif cmd == "zenity":
+                        return f"zenity --notification --text='{NOTIFICATION_MESSAGE}'"
+            return None  # No known notification tool found
+        elif system == "Windows":
+            # PowerShell notification
+            return (
+                "powershell -command"
+                " \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms');"
+                f" [System.Windows.Forms.MessageBox]::Show('{NOTIFICATION_MESSAGE}',"
+                " 'Aider')\""
+            )
+
+        return None  # Unknown system
+
+    def ring_bell(self):
+        """Ring the terminal bell if needed and clear the flag"""
+        if self.bell_on_next_input and self.notifications:
+            if self.notifications_command:
+                try:
+                    result = subprocess.run(
+                        self.notifications_command, shell=True, capture_output=True
+                    )
+                    if result.returncode != 0 and result.stderr:
+                        error_msg = result.stderr.decode("utf-8", errors="replace")
+                        self.tool_warning(f"Failed to run notifications command: {error_msg}")
+                except Exception as e:
+                    self.tool_warning(f"Failed to run notifications command: {e}")
+            else:
+                print("\a", end="", flush=True)  # Ring the bell
+            self.bell_on_next_input = False  # Clear the flag
+
+    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:
@@ -689,9 +1114,61 @@ class InputOutput:
             try:
                 with self.chat_history_file.open("a", encoding=self.encoding, errors="ignore") as f:
                     f.write(text)
-            except (PermissionError, OSError):
-                self.tool_error(
-                    f"Warning: Unable to write to chat history file {self.chat_history_file}."
-                    " Permission denied."
-                )
+            except (PermissionError, OSError) as err:
+                print(f"Warning: Unable to write to chat history file {self.chat_history_file}.")
+                print(err)
                 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

@@ -4,13 +4,15 @@ import subprocess
 import sys
 import traceback
 import warnings
+import shlex
 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)
@@ -43,27 +45,23 @@ class Linter:
             return fname
 
     def run_cmd(self, cmd, rel_fname, code):
-        cmd += " " + rel_fname
-        cmd = cmd.split()
+        cmd += " " + shlex.quote(rel_fname)
 
+        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
 
@@ -152,12 +150,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:
@@ -221,7 +219,12 @@ def basic_lint(fname, code):
 
     tree = parser.parse(bytes(code, "utf-8"))
 
-    errors = traverse_tree(tree.root_node)
+    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/mdstream.py

@@ -3,17 +3,27 @@
 import io
 import time
 
+from rich import box
 from rich.console import Console
 from rich.live import Live
-from rich.markdown import Markdown
+from rich.markdown import CodeBlock, Heading, Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
 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 +37,9 @@ Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem
 
 
 ```python
-import sys
+"""
 
-def greeting():
-    print("Hello world!")
+_text_suffix = """
 ```
 
 ## Sub header too
@@ -40,82 +49,188 @@ The end.
 """  # noqa: E501
 
 
+class NoInsetCodeBlock(CodeBlock):
+    """A code block with syntax highlighting and no padding."""
+
+    def __rich_console__(self, console, options):
+        code = str(self.text).rstrip()
+        syntax = Syntax(code, self.lexer_name, theme=self.theme, word_wrap=True, padding=(1, 0))
+        yield syntax
+
+
+class LeftHeading(Heading):
+    """A heading class that renders left-justified."""
+
+    def __rich_console__(self, console, options):
+        text = self.text
+        text.justify = "left"  # Override justification
+        if self.tag == "h1":
+            # Draw a border around h1s, but keep text left-aligned
+            yield Panel(
+                text,
+                box=box.HEAVY,
+                style="markdown.h1.border",
+            )
+        else:
+            # Styled text for h2 and beyond
+            if self.tag == "h2":
+                yield Text("")  # Keep the blank line before h2
+            yield text
+
+
+class NoInsetMarkdown(Markdown):
+    """Markdown with code blocks that have no padding and left-justified headings."""
+
+    elements = {
+        **Markdown.elements,
+        "fence": NoInsetCodeBlock,
+        "code_block": NoInsetCodeBlock,
+        "heading_open": LeftHeading,
+    }
+
+
 class MarkdownStream:
-    live = None
-    when = 0
-    min_delay = 0.050
-    live_window = 6
+    """Streaming markdown renderer that progressively displays content with a live updating window.
+
+    Uses rich.console and rich.live to render markdown content with smooth scrolling
+    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 = NoInsetMarkdown(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()
-        console = Console(file=string_io, force_terminal=True)
+        # Measure render time and adjust min_delay to maintain smooth rendering
+        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:
-            rest = lines[num_lines:]
-            rest = "".join(rest)
-            # rest = '...\n' + rest
-            rest = Text.from_ansi(rest)
-            self.live.update(rest)
+            return
+
+        # Update the live window with remaining lines
+        rest = lines[num_lines:]
+        rest = "".join(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)):
+    print("Using NoInsetMarkdown for code blocks with padding=0")
+    for i in range(6, len(_text), 5):
         pm.update(_text[:i])
         time.sleep(0.01)
 

aider/onboarding.py

@@ -0,0 +1,428 @@
+import base64
+import hashlib
+import http.server
+import os
+import secrets
+import socketserver
+import threading
+import time
+import webbrowser
+from urllib.parse import parse_qs, urlparse
+
+import requests
+
+from aider import urls
+from aider.io import InputOutput
+
+
+def check_openrouter_tier(api_key):
+    """
+    Checks if the user is on a free tier for OpenRouter.
+
+    Args:
+        api_key: The OpenRouter API key to check.
+
+    Returns:
+        A boolean indicating if the user is on a free tier (True) or paid tier (False).
+        Returns True if the check fails.
+    """
+    try:
+        response = requests.get(
+            "https://openrouter.ai/api/v1/auth/key",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=5,  # Add a reasonable timeout
+        )
+        response.raise_for_status()
+        data = response.json()
+        # According to the documentation, 'is_free_tier' will be true if the user has never paid
+        return data.get("data", {}).get("is_free_tier", True)  # Default to True if not found
+    except Exception:
+        # If there's any error, we'll default to assuming free tier
+        return True
+
+
+def try_to_select_default_model():
+    """
+    Attempts to select a default model based on available API keys.
+    Checks OpenRouter tier status to select appropriate model.
+
+    Returns:
+        The name of the selected model, or None if no suitable default is found.
+    """
+    # Special handling for OpenRouter
+    openrouter_key = os.environ.get("OPENROUTER_API_KEY")
+    if openrouter_key:
+        # Check if the user is on a free tier
+        is_free_tier = check_openrouter_tier(openrouter_key)
+        if is_free_tier:
+            return "openrouter/google/gemini-2.5-pro-exp-03-25:free"
+        else:
+            return "openrouter/anthropic/claude-3.7-sonnet"
+
+    # Select model based on other available API keys
+    model_key_pairs = [
+        ("ANTHROPIC_API_KEY", "sonnet"),
+        ("DEEPSEEK_API_KEY", "deepseek"),
+        ("OPENAI_API_KEY", "gpt-4o"),
+        ("GEMINI_API_KEY", "gemini/gemini-2.5-pro-exp-03-25"),
+        ("VERTEXAI_PROJECT", "vertex_ai/gemini-2.5-pro-exp-03-25"),
+    ]
+
+    for env_key, model_name in model_key_pairs:
+        api_key_value = os.environ.get(env_key)
+        if api_key_value:
+            return model_name
+
+    return None
+
+
+def offer_openrouter_oauth(io, analytics):
+    """
+    Offers OpenRouter OAuth flow to the user if no API keys are found.
+
+    Args:
+        io: The InputOutput object for user interaction.
+        analytics: The Analytics object for tracking events.
+
+    Returns:
+        True if authentication was successful, False otherwise.
+    """
+    # No API keys found - Offer OpenRouter OAuth
+    io.tool_output("OpenRouter provides free and paid access to many LLMs.")
+    # Use confirm_ask which handles non-interactive cases
+    if io.confirm_ask(
+        "Login to OpenRouter or create a free account?",
+        default="y",
+    ):
+        analytics.event("oauth_flow_initiated", provider="openrouter")
+        openrouter_key = start_openrouter_oauth_flow(io, analytics)
+        if openrouter_key:
+            # Successfully got key via OAuth, use the default OpenRouter model
+            # Ensure OPENROUTER_API_KEY is now set in the environment for later use
+            os.environ["OPENROUTER_API_KEY"] = openrouter_key
+            # Track OAuth success leading to model selection
+            analytics.event("oauth_flow_success")
+            return True
+
+        # OAuth failed or was cancelled by user implicitly (e.g., closing browser)
+        # Error messages are handled within start_openrouter_oauth_flow
+        analytics.event("oauth_flow_failure")
+        io.tool_error("OpenRouter authentication did not complete successfully.")
+        # Fall through to the final error message
+
+    return False
+
+
+def select_default_model(args, io, analytics):
+    """
+    Selects a default model based on available API keys if no model is specified.
+    Offers OAuth flow for OpenRouter if no keys are found.
+
+    Args:
+        args: The command line arguments object.
+        io: The InputOutput object for user interaction.
+        analytics: The Analytics object for tracking events.
+
+    Returns:
+        The name of the selected model, or None if no suitable default is found.
+    """
+    if args.model:
+        return args.model  # Model already specified
+
+    model = try_to_select_default_model()
+    if model:
+        io.tool_warning(f"Using {model} model with API key from environment.")
+        analytics.event("auto_model_selection", model=model)
+        return model
+
+    no_model_msg = "No LLM model was specified and no API keys were provided."
+    io.tool_warning(no_model_msg)
+
+    # Try OAuth if no model was detected
+    offer_openrouter_oauth(io, analytics)
+
+    # Check again after potential OAuth success
+    model = try_to_select_default_model()
+    if model:
+        return model
+
+    io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
+
+
+# Helper function to find an available port
+def find_available_port(start_port=8484, end_port=8584):
+    for port in range(start_port, end_port + 1):
+        try:
+            # Check if the port is available by trying to bind to it
+            with socketserver.TCPServer(("localhost", port), None):
+                return port
+        except OSError:
+            # Port is likely already in use
+            continue
+    return None
+
+
+# PKCE code generation
+def generate_pkce_codes():
+    code_verifier = secrets.token_urlsafe(64)
+    hasher = hashlib.sha256()
+    hasher.update(code_verifier.encode("utf-8"))
+    code_challenge = base64.urlsafe_b64encode(hasher.digest()).rstrip(b"=").decode("utf-8")
+    return code_verifier, code_challenge
+
+
+# Function to exchange the authorization code for an API key
+def exchange_code_for_key(code, code_verifier, io):
+    try:
+        response = requests.post(
+            "https://openrouter.ai/api/v1/auth/keys",
+            headers={"Content-Type": "application/json"},
+            json={
+                "code": code,
+                "code_verifier": code_verifier,
+                "code_challenge_method": "S256",
+            },
+            timeout=30,  # Add a timeout
+        )
+        response.raise_for_status()  # Raise exception for bad status codes (4xx or 5xx)
+        data = response.json()
+        api_key = data.get("key")
+        if not api_key:
+            io.tool_error("Error: 'key' not found in OpenRouter response.")
+            io.tool_error(f"Response: {response.text}")
+            return None
+        return api_key
+    except requests.exceptions.Timeout:
+        io.tool_error("Error: Request to OpenRouter timed out during code exchange.")
+        return None
+    except requests.exceptions.HTTPError as e:
+        io.tool_error(
+            "Error exchanging code for OpenRouter key:"
+            f" {e.response.status_code} {e.response.reason}"
+        )
+        io.tool_error(f"Response: {e.response.text}")
+        return None
+    except requests.exceptions.RequestException as e:
+        io.tool_error(f"Error exchanging code for OpenRouter key: {e}")
+        return None
+    except Exception as e:
+        io.tool_error(f"Unexpected error during code exchange: {e}")
+        return None
+
+
+# Function to start the OAuth flow
+def start_openrouter_oauth_flow(io, analytics):
+    """Initiates the OpenRouter OAuth PKCE flow using a local server."""
+
+    port = find_available_port()
+    if not port:
+        io.tool_error("Could not find an available port between 8484 and 8584.")
+        io.tool_error("Please ensure a port in this range is free, or configure manually.")
+        return None
+
+    callback_url = f"http://localhost:{port}/callback/aider"
+    auth_code = None
+    server_error = None
+    server_started = threading.Event()
+    shutdown_server = threading.Event()
+
+    class OAuthCallbackHandler(http.server.SimpleHTTPRequestHandler):
+        def do_GET(self):
+            nonlocal auth_code, server_error
+            parsed_path = urlparse(self.path)
+            if parsed_path.path == "/callback/aider":
+                query_params = parse_qs(parsed_path.query)
+                if "code" in query_params:
+                    auth_code = query_params["code"][0]
+                    self.send_response(200)
+                    self.send_header("Content-type", "text/html")
+                    self.end_headers()
+                    self.wfile.write(
+                        b"<html><body><h1>Success!</h1>"
+                        b"<p>Aider has received the authentication code. "
+                        b"You can close this browser tab.</p></body></html>"
+                    )
+                    # Signal the main thread to shut down the server
+                    # Signal the main thread to shut down the server
+                    shutdown_server.set()
+                else:
+                    # Redirect to aider website if 'code' is missing (e.g., user visited manually)
+                    self.send_response(302)  # Found (temporary redirect)
+                    self.send_header("Location", urls.website)
+                    self.end_headers()
+                    # No need to set server_error, just redirect.
+                    # Do NOT shut down the server here; wait for timeout or success.
+            else:
+                # Redirect anything else (e.g., favicon.ico) to the main website as well
+                self.send_response(302)
+                self.send_header("Location", urls.website)
+                self.end_headers()
+                self.wfile.write(b"Not Found")
+
+        def log_message(self, format, *args):
+            # Suppress server logging to keep terminal clean
+            pass
+
+    def run_server():
+        nonlocal server_error
+        try:
+            with socketserver.TCPServer(("localhost", port), OAuthCallbackHandler) as httpd:
+                io.tool_output(f"Temporary server listening on {callback_url}", log_only=True)
+                server_started.set()  # Signal that the server is ready
+                # Wait until shutdown is requested or timeout occurs (handled by main thread)
+                while not shutdown_server.is_set():
+                    httpd.handle_request()  # Handle one request at a time
+                    # Add a small sleep to prevent busy-waiting if needed,
+                    # though handle_request should block appropriately.
+                    time.sleep(0.1)
+                io.tool_output("Shutting down temporary server.", log_only=True)
+        except Exception as e:
+            server_error = f"Failed to start or run temporary server: {e}"
+            server_started.set()  # Signal even if failed, error will be checked
+            shutdown_server.set()  # Ensure shutdown logic proceeds
+
+    server_thread = threading.Thread(target=run_server, daemon=True)
+    server_thread.start()
+
+    # Wait briefly for the server to start, or for an error
+    if not server_started.wait(timeout=5):
+        io.tool_error("Temporary authentication server failed to start in time.")
+        shutdown_server.set()  # Ensure thread exits if it eventually starts
+        server_thread.join(timeout=1)
+        return None
+
+    # Check if server failed during startup
+    if server_error:
+        io.tool_error(server_error)
+        shutdown_server.set()  # Ensure thread exits
+        server_thread.join(timeout=1)
+        return None
+
+    # Generate codes and URL
+    code_verifier, code_challenge = generate_pkce_codes()
+    auth_url_base = "https://openrouter.ai/auth"
+    auth_params = {
+        "callback_url": callback_url,
+        "code_challenge": code_challenge,
+        "code_challenge_method": "S256",
+    }
+    auth_url = f"{auth_url_base}?{'&'.join(f'{k}={v}' for k, v in auth_params.items())}"
+
+    io.tool_output("\nPlease open this URL in your browser to connect Aider with OpenRouter:")
+    io.tool_output()
+    print(auth_url)
+
+    MINUTES = 5
+    io.tool_output(f"\nWaiting up to {MINUTES} minutes for you to finish in the browser...")
+    io.tool_output("Use Control-C to interrupt.")
+
+    try:
+        webbrowser.open(auth_url)
+    except Exception:
+        pass
+
+    # Wait for the callback to set the auth_code or for timeout/error
+    interrupted = False
+    try:
+        shutdown_server.wait(timeout=MINUTES * 60)  # Convert minutes to seconds
+    except KeyboardInterrupt:
+        io.tool_warning("\nOAuth flow interrupted.")
+        analytics.event("oauth_flow_failed", provider="openrouter", reason="user_interrupt")
+        interrupted = True
+        # Ensure the server thread is signaled to shut down
+        shutdown_server.set()
+
+    # Join the server thread to ensure it's cleaned up
+    server_thread.join(timeout=1)
+
+    if interrupted:
+        return None  # Return None if interrupted by user
+
+    if server_error:
+        io.tool_error(f"Authentication failed: {server_error}")
+        analytics.event("oauth_flow_failed", provider="openrouter", reason=server_error)
+        return None
+
+    if not auth_code:
+        io.tool_error("Authentication with OpenRouter failed.")
+        analytics.event("oauth_flow_failed", provider="openrouter")
+        return None
+
+    io.tool_output("Completing authentication...")
+    analytics.event("oauth_flow_code_received", provider="openrouter")
+
+    # Exchange code for key
+    api_key = exchange_code_for_key(auth_code, code_verifier, io)
+
+    if api_key:
+        # Set env var for the current session immediately
+        os.environ["OPENROUTER_API_KEY"] = api_key
+
+        # Save the key to the oauth-keys.env file
+        try:
+            config_dir = os.path.expanduser("~/.aider")
+            os.makedirs(config_dir, exist_ok=True)
+            key_file = os.path.join(config_dir, "oauth-keys.env")
+            with open(key_file, "a", encoding="utf-8") as f:
+                f.write(f'OPENROUTER_API_KEY="{api_key}"\n')
+
+            io.tool_warning("Aider will load the OpenRouter key automatically in future sessions.")
+            io.tool_output()
+
+            analytics.event("oauth_flow_success", provider="openrouter")
+            return api_key
+        except Exception as e:
+            io.tool_error(f"Successfully obtained key, but failed to save it to file: {e}")
+            io.tool_warning("Set OPENROUTER_API_KEY environment variable for this session only.")
+            # Still return the key for the current session even if saving failed
+            analytics.event("oauth_flow_save_failed", provider="openrouter", reason=str(e))
+            return api_key
+    else:
+        io.tool_error("Authentication with OpenRouter failed.")
+        analytics.event("oauth_flow_failed", provider="openrouter", reason="code_exchange_failed")
+        return None
+
+
+# Dummy Analytics class for testing
+class DummyAnalytics:
+    def event(self, *args, **kwargs):
+        # print(f"Analytics Event: {args} {kwargs}") # Optional: print events
+        pass
+
+
+def main():
+    """Main function to test the OpenRouter OAuth flow."""
+    print("Starting OpenRouter OAuth flow test...")
+
+    # Use a real IO object for interaction
+    io = InputOutput(
+        pretty=True,
+        yes=False,
+        input_history_file=None,
+        chat_history_file=None,
+        tool_output_color="BLUE",
+        tool_error_color="RED",
+    )
+    # Use a dummy analytics object
+    analytics = DummyAnalytics()
+
+    # Ensure OPENROUTER_API_KEY is not set, to trigger the flow naturally
+    # (though start_openrouter_oauth_flow doesn't check this itself)
+    if "OPENROUTER_API_KEY" in os.environ:
+        print("Warning: OPENROUTER_API_KEY is already set in environment.")
+        # del os.environ["OPENROUTER_API_KEY"] # Optionally unset it for testing
+
+    api_key = start_openrouter_oauth_flow(io, analytics)
+
+    if api_key:
+        print("\nOAuth flow completed successfully!")
+        print(f"Obtained API Key (first 5 chars): {api_key[:5]}...")
+        # Be careful printing the key, even partially
+    else:
+        print("\nOAuth flow failed or was cancelled.")
+
+    print("\nOpenRouter OAuth flow test finished.")
+
+
+if __name__ == "__main__":
+    main()

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.
-The commit message MUST use the imperative tense.
+Generate a one-line commit message for those changes.
 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/README.md

@@ -0,0 +1,7 @@
+These scm files are all adapted from the github repositories listed here:
+
+https://github.com/Goldziher/tree-sitter-language-pack/blob/main/sources/language_definitions.json
+
+See this URL for information on the licenses of each repo:
+
+https://github.com/Goldziher/tree-sitter-language-pack/

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

@@ -0,0 +1,5 @@
+(function_declarator
+  declarator: (identifier) @name.definition.function) @definition.function
+
+(call_expression
+  function: (identifier) @name.reference.call) @reference.call

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

@@ -0,0 +1,16 @@
+; Definitions
+(intent_def
+  (intent) @name.definition.intent) @definition.intent
+
+(slot_def
+  (slot) @name.definition.slot) @definition.slot
+
+(alias_def
+  (alias) @name.definition.alias) @definition.alias
+
+; References
+(slot_ref
+  (slot) @name.reference.slot) @reference.slot
+
+(alias_ref
+  (alias) @name.reference.alias) @reference.alias

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

@@ -0,0 +1,122 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Function Definitions ;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun_header
+  function_name: (sym_lit) @name.definition.function) @definition.function
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Function Calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Basically, we consider every list literal with symbol as the
+;;; first element to be a call to a function named by that element.
+;;; But we must exclude some cases. Note, tree-sitter @ignore
+;;; cases only work if they are declared before the cases
+;;; we want to include.
+
+;; Exclude lambda lists for function definitions
+;; For example:
+;;
+;;    (defun my-func (arg1 arg2) ...)
+;;
+;; do not treat (arg1 arg2) as a call of function arg1
+;;
+(defun_header
+  lambda_list: (list_lit . [(sym_lit) (package_lit)] @ignore))
+
+;; Similar to the above, but for
+;;
+;;     (defmethod m ((type1 param1) (type2 param2)) ...)
+;;
+;; where list literals having symbol as their first element
+;; are nested inside the lambda list.
+(defun_header
+  lambda_list: (list_lit (list_lit . [(sym_lit) (package_lit)] @ignore)))
+
+;;
+;;      (let ((var ...) (var2 ...)) ...)
+;;
+;; - exclude var, var2
+;; - the same for let*, flet, labels, macrolet, symbol-macrolet
+(list_lit . [(sym_lit) (package_lit)] @name.reference.call
+          . (list_lit (list_lit . [(sym_lit) (package_lit)] @ignore))
+          (#match? @name.reference.call
+                   "(?i)^(cl:)?(let|let\\*|flet|labels|macrolet|symbol-macrolet)$")
+  )
+
+;; TODO:
+;;     - exclude also:
+;;       - (defclass name (parent parent2)
+;;           ((slot1 ...)
+;;            (slot2 ...))
+;;              exclude the parent, slot1, slot2
+;;       - (flet ((func-1 (param1 param2))) ...)
+;;           - we already exclude func-1, but param1 is still recognized
+;;             as a function call - exclude it too
+;;           - the same for labels
+;;           - the same macrolet
+;;       - what else?
+;;         (that's a non-goal to completely support all macros
+;;          and special operators, but every one we support
+;;          makes the solution a little bit better)
+;;     - (flet ((func-1 (param1 param2))) ...)
+;;       - instead of simply excluding it, as we do today,
+;;         tag func-1 as @local.definition.function (I suppose)
+;;       - the same for labels, macrolet
+;;     - @local.scope for let, let*, flet, labels, macrolet
+;;       - I guess the whole span of the scope text,
+;;         till the closing paren, should be tagged as @local.scope;
+;;         Hopefully, combined with @local.definition.function
+;;         within the scope, the usual  @reference.call within
+;;         that scope will refer to the local definition,
+;;         and there will be no need to use @local.reference.call
+;;         (which is more difficult to implement).
+;;       - When implementing, remember the scope rules differences
+;;         of let vs let*, flet vs labels.
+
+
+;; Include all other cases - list literal with symbol as the
+;; first element
+(list_lit . [(sym_lit) (package_lit)] @name.reference.call) @reference.call
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; classes
+
+(list_lit . [(sym_lit) (package_lit)] @ignore
+          . [(sym_lit) (package_lit)] @name.definition.class
+  (#match? @ignore "(?i)^(cl:)?defclass$")
+          ) @definition.class
+
+(list_lit . [(sym_lit) (package_lit)] @ignore
+          . (quoting_lit [(sym_lit) (package_lit)] @name.reference.class)
+  (#match? @ignore "(?i)^(cl:)?make-instance$")
+          ) @reference.class
+
+;;; TODO:
+;;  - @reference.class for base classes
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; TODO:
+;; - Symbols referenced in defpackage
+;;
+;;       (defpackage ...
+;;         (:export (symbol-a :symbol-b #:symbol-c "SYMBOL-D")))
+;;
+;;   The goal is to allow quick navigation from the API
+;;   overview in the form of defpackage, to the definition
+;;   where user can read parameters, docstring, etc.
+;;   - The @name must not include the colon, or sharpsign colon, quotes,
+;;     just symbol-a, symbol-b, symbol-c, sybmol-d
+;;   - Downcase the names specified as string literals?
+;;     ("SYMBOL-D" -> symbol-d)
+;;   - We don't know if the exported symbol is a function, variable,
+;;     class or something else. The official doc
+;;     (https://tree-sitter.github.io/tree-sitter/code-navigation-systems)
+;;     does not even suggest a tag for variable reference.
+;;     (Although in practice, the `tree-sitter tags` command
+;;     allows any @reference.* and @definition.* tags)
+;;     Probably it's better to just use @reference.call for all
+;;     the symbols in the :export clause.
+;;
+;; - The same for the export function call:
+;; 
+;;       (export '(symbol-a :symbol-b #:symbol-c "SYMBOL-D"))

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

@@ -0,0 +1,15 @@
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(function_declarator declarator: (field_identifier) @name.definition.function) @definition.function
+
+(function_declarator declarator: (qualified_identifier scope: (namespace_identifier) @local.scope name: (identifier) @name.definition.method)) @definition.method
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+
+(enum_specifier name: (type_identifier) @name.definition.type) @definition.type
+
+(class_specifier name: (type_identifier) @name.definition.class) @definition.class

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

@@ -0,0 +1,26 @@
+; Based on https://github.com/tree-sitter/tree-sitter-c-sharp/blob/master/queries/tags.scm
+; MIT License.
+
+(class_declaration name: (identifier) @name.definition.class) @definition.class
+
+(class_declaration (base_list (_) @name.reference.class)) @reference.class
+
+(interface_declaration name: (identifier) @name.definition.interface) @definition.interface
+
+(interface_declaration (base_list (_) @name.reference.interface)) @reference.interface
+
+(method_declaration name: (identifier) @name.definition.method) @definition.method
+
+(object_creation_expression type: (identifier) @name.reference.class) @reference.class
+
+(type_parameter_constraints_clause (identifier) @name.reference.class) @reference.class
+
+(type_parameter_constraint (type type: (identifier) @name.reference.class)) @reference.class
+
+(variable_declaration type: (identifier) @name.reference.class) @reference.class
+
+(invocation_expression function: (member_access_expression name: (identifier) @name.reference.send)) @reference.send
+
+(namespace_declaration name: (identifier) @name.definition.module) @definition.module
+
+(namespace_declaration name: (identifier) @name.definition.module) @module

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

@@ -0,0 +1,26 @@
+(module_def (module_declaration (module_fqn) @name.definition.module)) @definition.module
+
+(struct_declaration (struct) . (identifier) @name.definition.class) @definition.class
+(interface_declaration (interface) . (identifier) @name.definition.interface) @definition.interface
+(enum_declaration (enum) . (identifier) @name.definition.type) @definition.type
+
+(class_declaration (class) . (identifier) @name.definition.class) @definition.class
+(constructor (this) @name.definition.method) @definition.method
+(destructor (this) @name.definition.method) @definition.method
+(postblit (this) @name.definition.method) @definition.method
+
+(manifest_declarator . (identifier) @name.definition.type) @definition.type
+
+(function_declaration (identifier) @name.definition.function) @definition.function
+
+(union_declaration (union) . (identifier) @name.definition.type) @definition.type
+
+(anonymous_enum_declaration (enum_member . (identifier) @name.definition.constant)) @definition.constant
+
+(enum_declaration (enum_member . (identifier) @name.definition.constant)) @definition.constant
+
+(call_expression (identifier) @name.reference.call) @reference.call
+(call_expression (type (template_instance (identifier) @name.reference.call))) @reference.call
+(parameter (type (identifier) @name.reference.class) @reference.class (identifier))
+
+(variable_declaration (type (identifier) @name.reference.class) @reference.class (declarator))

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

@@ -0,0 +1,92 @@
+
+(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
+
+
+(new_expression
+  (type_identifier) @name.reference.class) @reference.class
+
+(enum_declaration
+  name: (identifier) @name.definition.enum) @definition.enum
+
+(function_signature
+  name: (identifier) @name.definition.function) @definition.function 
+
+(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.send))) @reference.call
+
+(assignment_expression
+  left: (assignable_expression 
+		  (identifier)
+		  (conditional_assignable_selector
+			"?."
+			(identifier) @name.reference.send))) @reference.call
+
+((identifier) @name.reference.send
+ (selector
+    "!"?
+    (conditional_assignable_selector
+      "?." (identifier) @name.reference.send)?
+    (unconditional_assignable_selector
+      "."? (identifier) @name.reference.send)?
+    (argument_part
+      (arguments
+        (argument)*))?)*
+	(cascade_section
+	  (cascade_selector
+		(identifier)) @name.reference.send 
+	  (argument_part 
+		(arguments
+		  (argument)*))?)?) @reference.call
+

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

@@ -0,0 +1,5 @@
+;; defun/defsubst
+(function_definition name: (symbol) @name.definition.function) @definition.function
+
+;; Treat macros as function definitions for the sake of TAGS.
+(macro_definition name: (symbol) @name.definition.function) @definition.function

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

@@ -0,0 +1,54 @@
+; Definitions
+
+; * modules and protocols
+(call
+  target: (identifier) @ignore
+  (arguments (alias) @name.definition.module)
+  (#any-of? @ignore "defmodule" "defprotocol")) @definition.module
+
+; * functions/macros
+(call
+  target: (identifier) @ignore
+  (arguments
+    [
+      ; zero-arity functions with no parentheses
+      (identifier) @name.definition.function
+      ; regular function clause
+      (call target: (identifier) @name.definition.function)
+      ; function clause with a guard clause
+      (binary_operator
+        left: (call target: (identifier) @name.definition.function)
+        operator: "when")
+    ])
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp")) @definition.function
+
+; References
+
+; ignore calls to kernel/special-forms keywords
+(call
+  target: (identifier) @ignore
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp" "defmodule" "defprotocol" "defimpl" "defstruct" "defexception" "defoverridable" "alias" "case" "cond" "else" "for" "if" "import" "quote" "raise" "receive" "require" "reraise" "super" "throw" "try" "unless" "unquote" "unquote_splicing" "use" "with"))
+
+; ignore module attributes
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: (identifier) @ignore))
+
+; * function call
+(call
+  target: [
+   ; local
+   (identifier) @name.reference.call
+   ; remote
+   (dot
+     right: (identifier) @name.reference.call)
+  ]) @reference.call
+
+; * pipe into function call
+(binary_operator
+  operator: "|>"
+  right: (identifier) @name.reference.call) @reference.call
+
+; * modules
+(alias) @name.reference.module @reference.module

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

@@ -0,0 +1,19 @@
+(value_declaration (function_declaration_left (lower_case_identifier) @name.definition.function)) @definition.function
+
+(function_call_expr (value_expr (value_qid) @name.reference.function)) @reference.function
+(exposed_value (lower_case_identifier) @name.reference.function) @reference.function
+(type_annotation ((lower_case_identifier) @name.reference.function) (colon)) @reference.function
+
+(type_declaration ((upper_case_identifier) @name.definition.type) ) @definition.type
+
+(type_ref (upper_case_qid (upper_case_identifier) @name.reference.type)) @reference.type
+(exposed_type (upper_case_identifier) @name.reference.type) @reference.type
+
+(type_declaration (union_variant (upper_case_identifier) @name.definition.union)) @definition.union
+
+(value_expr (upper_case_qid (upper_case_identifier) @name.reference.union)) @reference.union
+
+
+(module_declaration 
+    (upper_case_qid (upper_case_identifier)) @name.definition.module
+) @definition.module

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

@@ -0,0 +1,41 @@
+; Modules
+(module) @name.reference.module @reference.module
+(import alias: (identifier) @name.reference.module) @reference.module
+(remote_type_identifier
+  module: (identifier) @name.reference.module) @reference.module
+((field_access
+  record: (identifier) @name.reference.module)
+ (#is-not? local)) @reference.module
+
+; Functions
+(function
+  name: (identifier) @name.definition.function) @definition.function
+(external_function
+  name: (identifier) @name.definition.function) @definition.function
+(unqualified_import (identifier) @name.reference.function) @reference.function
+((function_call
+   function: (identifier) @name.reference.function) @reference.function
+ (#is-not? local))
+((field_access
+  record: (identifier) @ignore
+  field: (label) @name.reference.function)
+ (#is-not? local)) @reference.function
+((binary_expression
+   operator: "|>"
+   right: (identifier) @name.reference.function)
+ (#is-not? local)) @reference.function
+
+; Types
+(type_definition
+  (type_name
+    name: (type_identifier) @name.definition.type)) @definition.type
+(type_definition
+  (data_constructors
+    (data_constructor
+      name: (constructor_name) @name.definition.constructor))) @definition.constructor
+(external_type
+  (type_name
+    name: (type_identifier) @name.definition.type)) @definition.type
+
+(type_identifier) @name.reference.type @reference.type
+(constructor_name) @name.reference.constructor @reference.constructor

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

@@ -0,0 +1,42 @@
+(
+  (comment)* @doc
+  .
+  (function_declaration
+    name: (identifier) @name.definition.function) @definition.function
+  (#strip! @doc "^//\\s*")
+  (#set-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (method_declaration
+    name: (field_identifier) @name.definition.method) @definition.method
+  (#strip! @doc "^//\\s*")
+  (#set-adjacent! @doc @definition.method)
+)
+
+(call_expression
+  function: [
+    (identifier) @name.reference.call
+    (parenthesized_expression (identifier) @name.reference.call)
+    (selector_expression field: (field_identifier) @name.reference.call)
+    (parenthesized_expression (selector_expression field: (field_identifier) @name.reference.call))
+  ]) @reference.call
+
+(type_spec
+  name: (type_identifier) @name.definition.type) @definition.type
+
+(type_identifier) @name.reference.type @reference.type
+
+(package_clause "package" (package_identifier) @name.definition.module)
+
+(type_declaration (type_spec name: (type_identifier) @name.definition.interface type: (interface_type)))
+
+(type_declaration (type_spec name: (type_identifier) @name.definition.class type: (struct_type)))
+
+(import_declaration (import_spec) @name.reference.module)
+
+(var_declaration (var_spec name: (identifier) @name.definition.variable))
+
+(const_declaration (const_spec name: (identifier) @name.definition.constant))

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

@@ -0,0 +1,20 @@
+(class_declaration
+  name: (identifier) @name.definition.class) @definition.class
+
+(method_declaration
+  name: (identifier) @name.definition.method) @definition.method
+
+(method_invocation
+  name: (identifier) @name.reference.method
+  arguments: (argument_list) @reference.call)
+
+(interface_declaration
+  name: (identifier) @name.definition.interface) @definition.interface
+
+(type_list
+  (type_identifier) @name.reference.interface) @reference.implementation
+
+(object_creation_expression
+  type: (type_identifier) @name.reference.class) @reference.class
+
+(superclass (type_identifier) @name.reference.class) @reference.class

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-language-pack/lua-tags.scm

@@ -0,0 +1,34 @@
+(function_declaration
+  name: [
+    (identifier) @name.definition.function
+    (dot_index_expression
+      field: (identifier) @name.definition.function)
+  ]) @definition.function
+
+(function_declaration
+  name: (method_index_expression
+    method: (identifier) @name.definition.method)) @definition.method
+
+(assignment_statement
+  (variable_list .
+    name: [
+      (identifier) @name.definition.function
+      (dot_index_expression
+        field: (identifier) @name.definition.function)
+    ])
+  (expression_list .
+    value: (function_definition))) @definition.function
+
+(table_constructor
+  (field
+    name: (identifier) @name.definition.function
+    value: (function_definition))) @definition.function
+
+(function_call
+  name: [
+    (identifier) @name.reference.call
+    (dot_index_expression
+      field: (identifier) @name.reference.call)
+    (method_index_expression
+      method: (identifier) @name.reference.method)
+  ]) @reference.call

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

@@ -0,0 +1,39 @@
+;Class definitions 	@definition.class
+;Function definitions 	@definition.function
+;Interface definitions 	@definition.interface
+;Method definitions 	@definition.method
+;Module definitions 	@definition.module
+;Function/method calls 	@reference.call
+;Class reference 	@reference.class
+;Interface implementation 	@reference.implementation
+(
+  (identifier) @reference.class
+  (#match? @reference.class "^_*[A-Z][a-zA-Z0-9_]*$")
+)
+
+(class_definition (identifier) @name.definition.class) @definition.class
+(actor_definition (identifier) @name.definition.class) @definition.class
+(primitive_definition (identifier) @name.definition.class) @definition.class
+(struct_definition (identifier) @name.definition.class) @definition.class
+(type_alias (identifier) @name.definition.class) @definition.class
+
+(trait_definition (identifier) @name.definition.interface) @definition.interface
+(interface_definition (identifier) @name.definition.interface) @definition.interface
+
+(constructor (identifier) @name.definition.method) @definition.method
+(method (identifier) @name.definition.method) @definition.method
+(behavior (identifier) @name.definition.method) @definition.method
+
+(class_definition (type) @name.reference.implementation) @reference.implementation
+(actor_definition (type) @name.reference.implementation) @reference.implementation
+(primitive_definition (type) @name.reference.implementation) @reference.implementation
+(struct_definition (type) @name.reference.implementation) @reference.implementation
+(type_alias (type) @name.reference.implementation) @reference.implementation
+
+; calls - not catching all possible call cases of callees for capturing the method name
+(call_expression callee: [(identifier) (ffi_identifier)] @name.reference.call) @reference.call
+(call_expression callee: (generic_expression [(identifier) (ffi_identifier)] @name.reference.call)) @reference.call
+(call_expression callee: (member_expression (identifier) @name.reference.call .)) @reference.call
+(call_expression callee: (member_expression (generic_expression [(identifier) (ffi_identifier)] @name.reference.call) .)) @reference.call
+; TODO: add more possible callee expressions
+(call_expression) @reference.call

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

@@ -0,0 +1,5 @@
+(property
+  (key) @name.definition.property) @definition.property
+
+(substitution
+  (key) @name.reference.property) @reference.property

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

@@ -0,0 +1,14 @@
+(module (expression_statement (assignment left: (identifier) @name.definition.constant) @definition.constant))
+
+(class_definition
+  name: (identifier) @name.definition.class) @definition.class
+
+(function_definition
+  name: (identifier) @name.definition.function) @definition.function
+
+(call
+  function: [
+      (identifier) @name.reference.call
+      (attribute
+        attribute: (identifier) @name.reference.call)
+  ]) @reference.call

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

@@ -0,0 +1,21 @@
+(binary_operator
+    lhs: (identifier) @name.definition.function
+    operator: "<-"
+    rhs: (function_definition)
+) @definition.function
+
+(binary_operator
+    lhs: (identifier) @name.definition.function
+    operator: "="
+    rhs: (function_definition)
+) @definition.function
+
+(call
+    function: (identifier) @name.reference.call
+) @reference.call
+
+(call
+    function: (namespace_operator
+        rhs: (identifier) @name.reference.call
+    )
+) @reference.call

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

@@ -0,0 +1,12 @@
+(list
+  .
+  (symbol) @reference._define
+  (#match? @reference._define "^(define|define/contract)$")
+  .
+  (list
+    .
+    (symbol) @name.definition.function) @definition.function)
+
+(list
+  .
+  (symbol) @name.reference.call)

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

@@ -0,0 +1,60 @@
+; ADT definitions
+
+(struct_item
+    name: (type_identifier) @name.definition.class) @definition.class
+
+(enum_item
+    name: (type_identifier) @name.definition.class) @definition.class
+
+(union_item
+    name: (type_identifier) @name.definition.class) @definition.class
+
+; type aliases
+
+(type_item
+    name: (type_identifier) @name.definition.class) @definition.class
+
+; method definitions
+
+(declaration_list
+    (function_item
+        name: (identifier) @name.definition.method) @definition.method)
+
+; function definitions
+
+(function_item
+    name: (identifier) @name.definition.function) @definition.function
+
+; trait definitions
+(trait_item
+    name: (type_identifier) @name.definition.interface) @definition.interface
+
+; module definitions
+(mod_item
+    name: (identifier) @name.definition.module) @definition.module
+
+; macro definitions
+
+(macro_definition
+    name: (identifier) @name.definition.macro) @definition.macro
+
+; references
+
+(call_expression
+    function: (identifier) @name.reference.call) @reference.call
+
+(call_expression
+    function: (field_expression
+        field: (field_identifier) @name.reference.call)) @reference.call
+
+(macro_invocation
+    macro: (identifier) @name.reference.call) @reference.call
+
+; implementations
+
+(impl_item
+    trait: (type_identifier) @name.reference.implementation) @reference.implementation
+
+(impl_item
+    type: (type_identifier) @name.reference.implementation
+    !trait) @reference.implementation

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

@@ -0,0 +1,43 @@
+;; Method and Function declarations
+(contract_declaration (_
+    (function_definition
+        name: (identifier) @name.definition.function) @definition.method))
+
+(source_file
+    (function_definition
+        name: (identifier) @name.definition.function) @definition.function)
+
+;; Contract, struct, enum and interface declarations
+(contract_declaration
+  name: (identifier) @name.definition.class) @definition.class
+
+(interface_declaration
+  name: (identifier) @name.definition.interface) @definition.interface
+
+(library_declaration
+  name: (identifier) @name.definition.class) @definition.interface
+
+(struct_declaration name: (identifier) @name.definition.class) @definition.class
+(enum_declaration name: (identifier) @name.definition.class) @definition.class
+(event_definition name: (identifier) @name.definition.class) @definition.class
+
+;; Function calls
+(call_expression (expression (identifier)) @name.reference.call ) @reference.call
+
+(call_expression
+    (expression (member_expression
+        property: (_) @name.reference.method ))) @reference.call
+
+;; Log emit
+(emit_statement name: (_) @name.reference.class) @reference.class
+
+
+;; Inheritance
+
+(inheritance_specifier
+    ancestor: (user_defined_type (_) @name.reference.class . )) @reference.class
+
+
+;; Imports ( note that unknown is not standardised )
+(import_directive
+  import_name: (_) @name.reference.module ) @reference.unknown

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

@@ -0,0 +1,51 @@
+(class_declaration
+  name: (type_identifier) @name.definition.class) @definition.class
+
+(protocol_declaration
+  name: (type_identifier) @name.definition.interface) @definition.interface
+
+(class_declaration
+    (class_body
+        [
+            (function_declaration
+                name: (simple_identifier) @name.definition.method
+            )
+            (subscript_declaration
+                (parameter (simple_identifier) @name.definition.method)
+            )
+            (init_declaration "init" @name.definition.method)
+            (deinit_declaration "deinit" @name.definition.method)
+        ]
+    )
+) @definition.method
+
+(protocol_declaration
+    (protocol_body
+        [
+            (protocol_function_declaration
+                name: (simple_identifier) @name.definition.method
+            )
+            (subscript_declaration
+                (parameter (simple_identifier) @name.definition.method)
+            )
+            (init_declaration "init" @name.definition.method)
+        ]
+    )
+) @definition.method
+
+(class_declaration
+    (class_body
+        [
+            (property_declaration
+                (pattern (simple_identifier) @name.definition.property)
+            )
+        ]
+    )
+) @definition.property
+
+(property_declaration
+    (pattern (simple_identifier) @name.definition.property)
+) @definition.property
+
+(function_declaration
+    name: (simple_identifier) @name.definition.function) @definition.function

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

@@ -0,0 +1,20 @@
+(assignment
+  key: "LABEL"
+  (value
+    (content) @name.definition.label)) @definition.label
+
+(assignment
+  key: "GOTO"
+  (value
+    (content) @name.reference.label)) @reference.label
+
+(assignment
+  key: "ENV"
+  (env_var) @name.definition.variable) @definition.variable
+
+(match
+  key: "ENV"
+  (env_var) @name.reference.variable) @reference.variable
+
+(var_sub
+  (env_var) @name.reference.variable) @reference.variable

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

@@ -0,0 +1,9 @@
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+
+(enum_specifier name: (type_identifier) @name.definition.type) @definition.type

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
+
+