hc99 commited on Feb 6

Commit

d6c5b16

verified ·

1 Parent(s): 9ce23df

Add files using upload-large-folder tool

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

testbed/Aider-AI__aider/.github/workflows/release.yml +31 -0
testbed/Aider-AI__aider/.github/workflows/ubuntu-tests.yml +39 -0
testbed/Aider-AI__aider/.github/workflows/windows-tests.yml +38 -0
testbed/Aider-AI__aider/_layouts/default.html +50 -0
testbed/Aider-AI__aider/aider/__init__.py +1 -0
testbed/Aider-AI__aider/aider/coders/__init__.py +15 -0
testbed/Aider-AI__aider/aider/coders/base_coder.py +904 -0
testbed/Aider-AI__aider/aider/coders/base_prompts.py +8 -0
testbed/Aider-AI__aider/aider/coders/editblock_coder.py +406 -0
testbed/Aider-AI__aider/aider/coders/editblock_func_coder.py +140 -0
testbed/Aider-AI__aider/aider/coders/editblock_func_prompts.py +27 -0
testbed/Aider-AI__aider/aider/coders/editblock_prompts.py +61 -0
testbed/Aider-AI__aider/aider/coders/single_wholefile_func_coder.py +111 -0
testbed/Aider-AI__aider/aider/coders/single_wholefile_func_prompts.py +27 -0
testbed/Aider-AI__aider/aider/coders/wholefile_coder.py +137 -0
testbed/Aider-AI__aider/aider/coders/wholefile_func_coder.py +132 -0
testbed/Aider-AI__aider/aider/coders/wholefile_func_prompts.py +27 -0
testbed/Aider-AI__aider/aider/coders/wholefile_prompts.py +43 -0
testbed/Aider-AI__aider/aider/commands.py +486 -0
testbed/Aider-AI__aider/aider/diffs.py +129 -0
testbed/Aider-AI__aider/aider/dump.py +29 -0
testbed/Aider-AI__aider/aider/history.py +132 -0
testbed/Aider-AI__aider/aider/io.py +338 -0
testbed/Aider-AI__aider/aider/main.py +536 -0
testbed/Aider-AI__aider/aider/models.py +76 -0
testbed/Aider-AI__aider/aider/prompts.py +44 -0
testbed/Aider-AI__aider/aider/repo.py +194 -0
testbed/Aider-AI__aider/aider/repomap.py +471 -0
testbed/Aider-AI__aider/aider/sendchat.py +79 -0
testbed/Aider-AI__aider/aider/utils.py +27 -0
testbed/Aider-AI__aider/aider/versioncheck.py +27 -0
testbed/Aider-AI__aider/aider/voice.py +90 -0
testbed/Aider-AI__aider/assets/benchmarks.svg +2198 -0
testbed/Aider-AI__aider/assets/css/style.scss +67 -0
testbed/Aider-AI__aider/assets/screencast.svg +0 -0
testbed/Aider-AI__aider/benchmark/__init__.py +0 -0
testbed/Aider-AI__aider/benchmark/benchmark.py +696 -0
testbed/Aider-AI__aider/benchmark/docker.sh +12 -0
testbed/Aider-AI__aider/benchmark/docker_build.sh +8 -0
testbed/Aider-AI__aider/benchmark/plot.sh +29 -0
testbed/Aider-AI__aider/benchmark/prompts.py +16 -0
testbed/Aider-AI__aider/benchmark/rungrid.py +60 -0
testbed/Aider-AI__aider/benchmark/test_benchmark.py +47 -0
testbed/Aider-AI__aider/docs/install.md +147 -0
testbed/Aider-AI__aider/examples/pong.md +304 -0
testbed/Aider-AI__aider/tests/test_coder.py +366 -0
testbed/Aider-AI__aider/tests/test_editblock.py +350 -0
testbed/Aider-AI__aider/tests/test_io.py +24 -0
testbed/Aider-AI__aider/tests/test_main.py +180 -0
testbed/Aider-AI__aider/tests/test_repo.py +196 -0

testbed/Aider-AI__aider/.github/workflows/release.yml ADDED Viewed

	@@ -0,0 +1,31 @@

+name: Release
+on:
+  push:
+    tags:
+      - 'v*'
+jobs:
+  build_and_publish:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      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 setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        python setup.py sdist bdist_wheel
+        twine upload dist/*

testbed/Aider-AI__aider/.github/workflows/ubuntu-tests.yml ADDED Viewed

	@@ -0,0 +1,39 @@

+name: Ubuntu Python Tests
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11"]
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install universal ctags
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y universal-ctags
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+    - name: Run tests
+      run: |
+        python -m unittest discover -s tests

testbed/Aider-AI__aider/.github/workflows/windows-tests.yml ADDED Viewed

	@@ -0,0 +1,38 @@

+name: Windows Python Tests
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11"]
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install universal ctags
+      run: |
+        choco install universal-ctags
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+    - name: Run tests
+      run: |
+        python -m unittest discover -s tests

testbed/Aider-AI__aider/_layouts/default.html ADDED Viewed

	@@ -0,0 +1,50 @@

+<!DOCTYPE html>
+<html lang="{{ site.lang | default: "en-US" }}">
+  <head>
+    <meta charset="UTF-8">
+{% seo %}
+<meta property="og:image" content="{{ site.url }}/assets/screenshot.png">
+<meta property="twitter:image" content="{{ site.url }}/assets/screenshot.png">
+    <link rel="preconnect" href="https://fonts.gstatic.com">
+    <link rel="preload" href="https://fonts.googleapis.com/css?family=Open+Sans:400,700&display=swap" as="style" type="text/css" crossorigin>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="theme-color" content="#157878">
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+    <link rel="stylesheet" href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}">
+    {% include head-custom.html %}
+  </head>
+  <body>
+    <a id="skip-to-content" href="#content">Skip to the content.</a>
+    <header class="page-header" role="banner">
+      {% if page.url == "/" %}
+      <h1 class="project-name">aider</h1>
+      <h2 class="project-tagline">AI pair programming in your terminal</h2>
+      {% else %}
+      <h1 class="project-name">{{ page.title | default: site.title | default: site.github.repository_name }}</h1>
+      <h2 class="project-tagline">{{ page.description | default: site.description | default: site.github.project_tagline }}</h2>
+      {% endif %}
+      <a href="{{ site.baseurl }}/" class="btn">Home</a>
+      <a href="{{ site.baseurl }}/examples/" class="btn">Examples</a>
+      {% if site.github.is_project_page %}
+        <a href="{{ site.github.repository_url }}" class="btn">GitHub</a>
+      {% endif %}
+      {% if site.show_downloads %}
+        <a href="{{ site.github.zip_url }}" class="btn">Download .zip</a>
+        <a href="{{ site.github.tar_url }}" class="btn">Download .tar.gz</a>
+      {% endif %}
+    </header>
+    <main id="content" class="main-content" role="main">
+      {{ content }}
+      <footer class="site-footer">
+        {% if site.github.is_project_page %}
+          <span class="site-footer-owner"><a href="{{ site.github.repository_url }}">{{ site.github.repository_name }}</a> is maintained by <a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a>.</span>
+        {% endif %}
+        <span class="site-footer-credits">This page was generated by <a href="https://pages.github.com">GitHub Pages</a>.</span>
+      </footer>
+    </main>
+  </body>
+</html>

testbed/Aider-AI__aider/aider/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ __version__ = "0.12.1-dev"

testbed/Aider-AI__aider/aider/coders/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+from .base_coder import Coder
+from .editblock_coder import EditBlockCoder
+from .editblock_func_coder import EditBlockFunctionCoder
+from .single_wholefile_func_coder import SingleWholeFileFunctionCoder
+from .wholefile_coder import WholeFileCoder
+from .wholefile_func_coder import WholeFileFunctionCoder
+__all__ = [
+    Coder,
+    EditBlockCoder,
+    WholeFileCoder,
+    WholeFileFunctionCoder,
+    EditBlockFunctionCoder,
+    SingleWholeFileFunctionCoder,
+]

testbed/Aider-AI__aider/aider/coders/base_coder.py ADDED Viewed

	@@ -0,0 +1,904 @@

+#!/usr/bin/env python
+import hashlib
+import json
+import os
+import sys
+import threading
+import time
+import traceback
+from json.decoder import JSONDecodeError
+from pathlib import Path
+import openai
+from jsonschema import Draft7Validator
+from rich.console import Console, Text
+from rich.live import Live
+from rich.markdown import Markdown
+from aider import models, prompts, utils
+from aider.commands import Commands
+from aider.history import ChatSummary
+from aider.repo import GitRepo
+from aider.repomap import RepoMap
+from aider.sendchat import send_with_retries
+from ..dump import dump  # noqa: F401
+class MissingAPIKeyError(ValueError):
+    pass
+class ExhaustedContextWindow(Exception):
+    pass
+def wrap_fence(name):
+    return f"<{name}>", f"</{name}>"
+class Coder:
+    abs_fnames = None
+    repo = None
+    last_aider_commit_hash = None
+    last_asked_for_commit_time = 0
+    repo_map = None
+    functions = None
+    total_cost = 0.0
+    num_exhausted_context_windows = 0
+    last_keyboard_interrupt = None
+    @classmethod
+    def create(
+        self,
+        main_model,
+        edit_format,
+        io,
+        **kwargs,
+    ):
+        from . import (
+            EditBlockCoder,
+            EditBlockFunctionCoder,
+            SingleWholeFileFunctionCoder,
+            WholeFileCoder,
+            WholeFileFunctionCoder,
+        )
+        if not main_model:
+            main_model = models.GPT35_16k
+        if not main_model.always_available:
+            if not check_model_availability(main_model):
+                if main_model != models.GPT4:
+                    io.tool_error(
+                        f"API key does not support {main_model.name}, falling back to"
+                        f" {models.GPT35_16k.name}"
+                    )
+                main_model = models.GPT35_16k
+        if edit_format is None:
+            edit_format = main_model.edit_format
+        if edit_format == "diff":
+            return EditBlockCoder(main_model, io, **kwargs)
+        elif edit_format == "whole":
+            return WholeFileCoder(main_model, io, **kwargs)
+        elif edit_format == "whole-func":
+            return WholeFileFunctionCoder(main_model, io, **kwargs)
+        elif edit_format == "single-whole-func":
+            return SingleWholeFileFunctionCoder(main_model, io, **kwargs)
+        elif edit_format == "diff-func-list":
+            return EditBlockFunctionCoder("list", main_model, io, **kwargs)
+        elif edit_format in ("diff-func", "diff-func-string"):
+            return EditBlockFunctionCoder("string", main_model, io, **kwargs)
+        else:
+            raise ValueError(f"Unknown edit format {edit_format}")
+    def __init__(
+        self,
+        main_model,
+        io,
+        fnames=None,
+        git_dname=None,
+        pretty=True,
+        show_diffs=False,
+        auto_commits=True,
+        dirty_commits=True,
+        dry_run=False,
+        map_tokens=1024,
+        verbose=False,
+        assistant_output_color="blue",
+        code_theme="default",
+        stream=True,
+        use_git=True,
+        voice_language=None,
+    ):
+        if not fnames:
+            fnames = []
+        self.chat_completion_call_hashes = []
+        self.chat_completion_response_hashes = []
+        self.verbose = verbose
+        self.abs_fnames = set()
+        self.cur_messages = []
+        self.done_messages = []
+        self.io = io
+        self.stream = stream
+        if not auto_commits:
+            dirty_commits = False
+        self.auto_commits = auto_commits
+        self.dirty_commits = dirty_commits
+        self.assistant_output_color = assistant_output_color
+        self.code_theme = code_theme
+        self.dry_run = dry_run
+        self.pretty = pretty
+        if pretty:
+            self.console = Console()
+        else:
+            self.console = Console(force_terminal=False, no_color=True)
+        self.main_model = main_model
+        self.io.tool_output(f"Model: {main_model.name}")
+        self.show_diffs = show_diffs
+        self.commands = Commands(self.io, self, voice_language)
+        for fname in fnames:
+            fname = Path(fname)
+            if not fname.exists():
+                self.io.tool_output(f"Creating empty file {fname}")
+                fname.parent.mkdir(parents=True, exist_ok=True)
+                fname.touch()
+            if not fname.is_file():
+                raise ValueError(f"{fname} is not a file")
+            self.abs_fnames.add(str(fname.resolve()))
+        if use_git:
+            try:
+                self.repo = GitRepo(self.io, fnames, git_dname)
+                self.root = self.repo.root
+            except FileNotFoundError:
+                self.repo = None
+        if self.repo:
+            rel_repo_dir = self.repo.get_rel_repo_dir()
+            self.io.tool_output(f"Git repo: {rel_repo_dir}")
+        else:
+            self.io.tool_output("Git repo: none")
+            self.find_common_root()
+        if main_model.use_repo_map and self.repo and self.gpt_prompts.repo_content_prefix:
+            self.repo_map = RepoMap(
+                map_tokens,
+                self.root,
+                self.main_model,
+                io,
+                self.gpt_prompts.repo_content_prefix,
+                self.verbose,
+            )
+            if self.repo_map.use_ctags:
+                self.io.tool_output(f"Repo-map: universal-ctags using {map_tokens} tokens")
+            elif not self.repo_map.has_ctags and map_tokens > 0:
+                self.io.tool_output(
+                    f"Repo-map: basic using {map_tokens} tokens"
+                    f" ({self.repo_map.ctags_disabled_reason})"
+                )
+            else:
+                self.io.tool_output("Repo-map: disabled because map_tokens == 0")
+        else:
+            self.io.tool_output("Repo-map: disabled")
+        for fname in self.get_inchat_relative_files():
+            self.io.tool_output(f"Added {fname} to the chat.")
+        if self.repo:
+            self.repo.add_new_files(fname for fname in fnames if not Path(fname).is_dir())
+        self.summarizer = ChatSummary()
+        self.summarizer_thread = None
+        self.summarized_done_messages = None
+        # validate the functions jsonschema
+        if self.functions:
+            for function in self.functions:
+                Draft7Validator.check_schema(function)
+            if self.verbose:
+                self.io.tool_output("JSON Schema:")
+                self.io.tool_output(json.dumps(self.functions, indent=4))
+    def find_common_root(self):
+        if len(self.abs_fnames) == 1:
+            self.root = os.path.dirname(list(self.abs_fnames)[0])
+        elif self.abs_fnames:
+            self.root = os.path.commonpath(list(self.abs_fnames))
+        else:
+            self.root = os.getcwd()
+        self.root = utils.safe_abs_path(self.root)
+    def add_rel_fname(self, rel_fname):
+        self.abs_fnames.add(self.abs_root_path(rel_fname))
+    def abs_root_path(self, path):
+        res = Path(self.root) / path
+        return utils.safe_abs_path(res)
+    fences = [
+        ("``" + "`", "``" + "`"),
+        wrap_fence("source"),
+        wrap_fence("code"),
+        wrap_fence("pre"),
+        wrap_fence("codeblock"),
+        wrap_fence("sourcecode"),
+    ]
+    fence = fences[0]
+    def get_abs_fnames_content(self):
+        for fname in list(self.abs_fnames):
+            content = self.io.read_text(fname)
+            if content is None:
+                relative_fname = self.get_rel_fname(fname)
+                self.io.tool_error(f"Dropping {relative_fname} from the chat.")
+                self.abs_fnames.remove(fname)
+            else:
+                yield fname, content
+    def choose_fence(self):
+        all_content = ""
+        for _fname, content in self.get_abs_fnames_content():
+            all_content += content + "\n"
+        good = False
+        for fence_open, fence_close in self.fences:
+            if fence_open in all_content or fence_close in all_content:
+                continue
+            good = True
+            break
+        if good:
+            self.fence = (fence_open, fence_close)
+        else:
+            self.fence = self.fences[0]
+            self.io.tool_error(
+                "Unable to find a fencing strategy! Falling back to:"
+                " {self.fence[0]}...{self.fence[1]}"
+            )
+        return
+    def get_files_content(self, fnames=None):
+        if not fnames:
+            fnames = self.abs_fnames
+        prompt = ""
+        for fname, content in self.get_abs_fnames_content():
+            relative_fname = self.get_rel_fname(fname)
+            prompt += "\n"
+            prompt += relative_fname
+            prompt += f"\n{self.fence[0]}\n"
+            prompt += content
+            prompt += f"{self.fence[1]}\n"
+        return prompt
+    def get_repo_map(self):
+        if not self.repo_map:
+            return
+        other_files = set(self.get_all_abs_files()) - set(self.abs_fnames)
+        repo_content = self.repo_map.get_repo_map(self.abs_fnames, other_files)
+        return repo_content
+    def get_files_messages(self):
+        all_content = ""
+        if self.abs_fnames:
+            files_content = self.gpt_prompts.files_content_prefix
+            files_content += self.get_files_content()
+        else:
+            files_content = self.gpt_prompts.files_no_full_files
+        all_content += files_content
+        repo_content = self.get_repo_map()
+        if repo_content:
+            if all_content:
+                all_content += "\n"
+            all_content += repo_content
+        files_messages = [
+            dict(role="user", content=all_content),
+            dict(role="assistant", content="Ok."),
+        ]
+        if self.abs_fnames:
+            files_messages += [
+                dict(role="system", content=self.fmt_system_reminder()),
+            ]
+        return files_messages
+    def run(self, with_message=None):
+        while True:
+            try:
+                if with_message:
+                    new_user_message = with_message
+                    self.io.user_input(with_message)
+                else:
+                    new_user_message = self.run_loop()
+                while new_user_message:
+                    new_user_message = self.send_new_user_message(new_user_message)
+                if with_message:
+                    return
+            except KeyboardInterrupt:
+                self.keyboard_interrupt()
+            except EOFError:
+                return
+    def keyboard_interrupt(self):
+        now = time.time()
+        thresh = 2  # seconds
+        if self.last_keyboard_interrupt and now - self.last_keyboard_interrupt < thresh:
+            self.io.tool_error("\n\n^C KeyboardInterrupt")
+            sys.exit()
+        self.io.tool_error("\n\n^C again to exit")
+        self.last_keyboard_interrupt = now
+    def summarize_start(self):
+        if not self.summarizer.too_big(self.done_messages):
+            return
+        self.summarize_end()
+        if self.verbose:
+            self.io.tool_output("Starting to summarize chat history.")
+        self.summarizer_thread = threading.Thread(target=self.summarize_worker)
+        self.summarizer_thread.start()
+    def summarize_worker(self):
+        self.summarized_done_messages = self.summarizer.summarize(self.done_messages)
+        if self.verbose:
+            self.io.tool_output("Finished summarizing chat history.")
+    def summarize_end(self):
+        if self.summarizer_thread is None:
+            return
+        self.summarizer_thread.join()
+        self.summarizer_thread = None
+        self.done_messages = self.summarized_done_messages
+        self.summarized_done_messages = None
+    def move_back_cur_messages(self, message):
+        self.done_messages += self.cur_messages
+        self.summarize_start()
+        if message:
+            self.done_messages += [
+                dict(role="user", content=message),
+                dict(role="assistant", content="Ok."),
+            ]
+        self.cur_messages = []
+    def run_loop(self):
+        inp = self.io.get_input(
+            self.root,
+            self.get_inchat_relative_files(),
+            self.get_addable_relative_files(),
+            self.commands,
+        )
+        if self.should_dirty_commit(inp) and self.dirty_commit():
+            if inp.strip():
+                self.io.tool_output("Use up-arrow to retry previous command:", inp)
+            return
+        if not inp:
+            return
+        if self.commands.is_command(inp):
+            return self.commands.run(inp)
+        self.check_for_file_mentions(inp)
+        return self.send_new_user_message(inp)
+    def fmt_system_reminder(self):
+        prompt = self.gpt_prompts.system_reminder
+        prompt = prompt.format(fence=self.fence)
+        return prompt
+    def send_new_user_message(self, inp):
+        self.choose_fence()
+        self.cur_messages += [
+            dict(role="user", content=inp),
+        ]
+        main_sys = self.gpt_prompts.main_system
+        # if self.main_model.max_context_tokens > 4 * 1024:
+        main_sys += "\n" + self.fmt_system_reminder()
+        messages = [
+            dict(role="system", content=main_sys),
+        ]
+        self.summarize_end()
+        messages += self.done_messages
+        messages += self.get_files_messages()
+        messages += self.cur_messages
+        if self.verbose:
+            utils.show_messages(messages, functions=self.functions)
+        exhausted = False
+        interrupted = False
+        try:
+            interrupted = self.send(messages, functions=self.functions)
+        except ExhaustedContextWindow:
+            exhausted = True
+        except openai.error.InvalidRequestError as err:
+            if "maximum context length" in str(err):
+                exhausted = True
+            else:
+                raise err
+        if exhausted:
+            self.num_exhausted_context_windows += 1
+            self.io.tool_error("The chat session is larger than the context window!\n")
+            self.commands.cmd_tokens("")
+            self.io.tool_error("\nTo reduce token usage:")
+            self.io.tool_error(" - Use /drop to remove unneeded files from the chat session.")
+            self.io.tool_error(" - Use /clear to clear chat history.")
+            return
+        if self.partial_response_function_call:
+            args = self.parse_partial_args()
+            if args:
+                content = args["explanation"]
+            else:
+                content = ""
+        elif self.partial_response_content:
+            content = self.partial_response_content
+        else:
+            content = ""
+        if interrupted:
+            content += "\n^C KeyboardInterrupt"
+        self.io.tool_output()
+        if interrupted:
+            self.cur_messages += [dict(role="assistant", content=content)]
+            return
+        edited, edit_error = self.apply_updates()
+        if edit_error:
+            self.update_cur_messages(set())
+            return edit_error
+        self.update_cur_messages(edited)
+        if edited:
+            if self.repo and self.auto_commits and not self.dry_run:
+                saved_message = self.auto_commit()
+            elif hasattr(self.gpt_prompts, "files_content_gpt_edits_no_repo"):
+                saved_message = self.gpt_prompts.files_content_gpt_edits_no_repo
+            else:
+                saved_message = None
+            self.move_back_cur_messages(saved_message)
+        add_rel_files_message = self.check_for_file_mentions(content)
+        if add_rel_files_message:
+            return add_rel_files_message
+    def update_cur_messages(self, edited):
+        if self.partial_response_content:
+            self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
+        if self.partial_response_function_call:
+            self.cur_messages += [
+                dict(
+                    role="assistant",
+                    content=None,
+                    function_call=self.partial_response_function_call,
+                )
+            ]
+    def check_for_file_mentions(self, content):
+        words = set(word for word in content.split())
+        # drop sentence punctuation from the end
+        words = set(word.rstrip(",.!;") for word in words)
+        # strip away all kinds of quotes
+        quotes = "".join(['"', "'", "`"])
+        words = set(word.strip(quotes) for word in words)
+        addable_rel_fnames = self.get_addable_relative_files()
+        mentioned_rel_fnames = set()
+        fname_to_rel_fnames = {}
+        for rel_fname in addable_rel_fnames:
+            if rel_fname in words:
+                mentioned_rel_fnames.add(str(rel_fname))
+            fname = os.path.basename(rel_fname)
+            if fname not in fname_to_rel_fnames:
+                fname_to_rel_fnames[fname] = []
+            fname_to_rel_fnames[fname].append(rel_fname)
+        for fname, rel_fnames in fname_to_rel_fnames.items():
+            if len(rel_fnames) == 1 and fname in words:
+                mentioned_rel_fnames.add(rel_fnames[0])
+        if not mentioned_rel_fnames:
+            return
+        for rel_fname in mentioned_rel_fnames:
+            self.io.tool_output(rel_fname)
+        if not self.io.confirm_ask("Add these files to the chat?"):
+            return
+        for rel_fname in mentioned_rel_fnames:
+            self.add_rel_fname(rel_fname)
+        return prompts.added_files.format(fnames=", ".join(mentioned_rel_fnames))
+    def send(self, messages, model=None, functions=None):
+        if not model:
+            model = self.main_model.name
+        self.partial_response_content = ""
+        self.partial_response_function_call = dict()
+        interrupted = False
+        try:
+            hash_object, completion = send_with_retries(model, messages, functions, self.stream)
+            self.chat_completion_call_hashes.append(hash_object.hexdigest())
+            if self.stream:
+                self.show_send_output_stream(completion)
+            else:
+                self.show_send_output(completion)
+        except KeyboardInterrupt:
+            self.keyboard_interrupt()
+            interrupted = True
+        if self.partial_response_content:
+            self.io.ai_output(self.partial_response_content)
+        elif self.partial_response_function_call:
+            # TODO: push this into subclasses
+            args = self.parse_partial_args()
+            if args:
+                self.io.ai_output(json.dumps(args, indent=4))
+        return interrupted
+    def show_send_output(self, completion):
+        if self.verbose:
+            print(completion)
+        show_func_err = None
+        show_content_err = None
+        try:
+            self.partial_response_function_call = completion.choices[0].message.function_call
+        except AttributeError as func_err:
+            show_func_err = func_err
+        try:
+            self.partial_response_content = completion.choices[0].message.content
+        except AttributeError as content_err:
+            show_content_err = content_err
+        resp_hash = dict(
+            function_call=self.partial_response_function_call,
+            content=self.partial_response_content,
+        )
+        resp_hash = hashlib.sha1(json.dumps(resp_hash, sort_keys=True).encode())
+        self.chat_completion_response_hashes.append(resp_hash.hexdigest())
+        if show_func_err and show_content_err:
+            self.io.tool_error(show_func_err)
+            self.io.tool_error(show_content_err)
+            raise Exception("No data found in openai response!")
+        prompt_tokens = completion.usage.prompt_tokens
+        completion_tokens = completion.usage.completion_tokens
+        tokens = f"{prompt_tokens} prompt tokens, {completion_tokens} completion tokens"
+        if self.main_model.prompt_price:
+            cost = prompt_tokens * self.main_model.prompt_price / 1000
+            cost += completion_tokens * self.main_model.completion_price / 1000
+            tokens += f", ${cost:.6f} cost"
+            self.total_cost += cost
+        show_resp = self.render_incremental_response(True)
+        if self.pretty:
+            show_resp = Markdown(
+                show_resp, style=self.assistant_output_color, code_theme=self.code_theme
+            )
+        else:
+            show_resp = Text(show_resp or "<no response>")
+        self.io.console.print(show_resp)
+        self.io.tool_output(tokens)
+    def show_send_output_stream(self, completion):
+        live = None
+        if self.pretty:
+            live = Live(vertical_overflow="scroll")
+        try:
+            if live:
+                live.start()
+            for chunk in completion:
+                if len(chunk.choices) == 0:
+                    continue
+                if chunk.choices[0].finish_reason == "length":
+                    raise ExhaustedContextWindow()
+                try:
+                    func = chunk.choices[0].delta.function_call
+                    # dump(func)
+                    for k, v in func.items():
+                        if k in self.partial_response_function_call:
+                            self.partial_response_function_call[k] += v
+                        else:
+                            self.partial_response_function_call[k] = v
+                except AttributeError:
+                    pass
+                try:
+                    text = chunk.choices[0].delta.content
+                    if text:
+                        self.partial_response_content += text
+                except AttributeError:
+                    text = None
+                if self.pretty:
+                    self.live_incremental_response(live, False)
+                elif text:
+                    sys.stdout.write(text)
+                    sys.stdout.flush()
+        finally:
+            if live:
+                self.live_incremental_response(live, True)
+                live.stop()
+    def live_incremental_response(self, live, final):
+        show_resp = self.render_incremental_response(final)
+        if not show_resp:
+            return
+        md = Markdown(show_resp, style=self.assistant_output_color, code_theme=self.code_theme)
+        live.update(md)
+    def render_incremental_response(self, final):
+        return self.partial_response_content
+    def get_rel_fname(self, fname):
+        return os.path.relpath(fname, self.root)
+    def get_inchat_relative_files(self):
+        files = [self.get_rel_fname(fname) for fname in self.abs_fnames]
+        return sorted(set(files))
+    def get_all_relative_files(self):
+        if self.repo:
+            files = self.repo.get_tracked_files()
+        else:
+            files = self.get_inchat_relative_files()
+        return sorted(set(files))
+    def get_all_abs_files(self):
+        files = self.get_all_relative_files()
+        files = [self.abs_root_path(path) for path in files]
+        return files
+    def get_last_modified(self):
+        files = [Path(fn) for fn in self.get_all_abs_files() if Path(fn).exists()]
+        if not files:
+            return 0
+        return max(path.stat().st_mtime for path in files)
+    def get_addable_relative_files(self):
+        return set(self.get_all_relative_files()) - set(self.get_inchat_relative_files())
+    def allowed_to_edit(self, path, write_content=None):
+        full_path = self.abs_root_path(path)
+        if full_path in self.abs_fnames:
+            if write_content:
+                self.io.write_text(full_path, write_content)
+            return full_path
+        if not Path(full_path).exists():
+            question = f"Allow creation of new file {path}?"  # noqa: E501
+        else:
+            question = f"Allow edits to {path} which was not previously provided?"  # noqa: E501
+        if not self.io.confirm_ask(question):
+            self.io.tool_error(f"Skipping edit to {path}")
+            return
+        if not Path(full_path).exists() and not self.dry_run:
+            Path(full_path).parent.mkdir(parents=True, exist_ok=True)
+            Path(full_path).touch()
+        self.abs_fnames.add(full_path)
+        # Check if the file is already in the repo
+        if self.repo:
+            tracked_files = set(self.repo.get_tracked_files())
+            relative_fname = self.get_rel_fname(full_path)
+            if relative_fname not in tracked_files and self.io.confirm_ask(f"Add {path} to git?"):
+                if not self.dry_run:
+                    self.repo.repo.git.add(full_path)
+        if write_content:
+            self.io.write_text(full_path, write_content)
+        return full_path
+    apply_update_errors = 0
+    def apply_updates(self):
+        max_apply_update_errors = 3
+        try:
+            edited = self.update_files()
+        except ValueError as err:
+            err = err.args[0]
+            self.apply_update_errors += 1
+            if self.apply_update_errors < max_apply_update_errors:
+                self.io.tool_error(f"Malformed response #{self.apply_update_errors}, retrying...")
+                self.io.tool_error(str(err))
+                return None, err
+            else:
+                self.io.tool_error(f"Malformed response #{self.apply_update_errors}, aborting.")
+                return False, None
+        except Exception as err:
+            print(err)
+            print()
+            traceback.print_exc()
+            self.apply_update_errors += 1
+            if self.apply_update_errors < max_apply_update_errors:
+                self.io.tool_error(f"Update exception #{self.apply_update_errors}, retrying...")
+                return None, str(err)
+            else:
+                self.io.tool_error(f"Update exception #{self.apply_update_errors}, aborting")
+                return False, None
+        self.apply_update_errors = 0
+        if edited:
+            for path in sorted(edited):
+                if self.dry_run:
+                    self.io.tool_output(f"Did not apply edit to {path} (--dry-run)")
+                else:
+                    self.io.tool_output(f"Applied edit to {path}")
+        return edited, None
+    def parse_partial_args(self):
+        # dump(self.partial_response_function_call)
+        data = self.partial_response_function_call.get("arguments")
+        if not data:
+            return
+        try:
+            return json.loads(data)
+        except JSONDecodeError:
+            pass
+        try:
+            return json.loads(data + "]}")
+        except JSONDecodeError:
+            pass
+        try:
+            return json.loads(data + "}]}")
+        except JSONDecodeError:
+            pass
+        try:
+            return json.loads(data + '"}]}')
+        except JSONDecodeError:
+            pass
+    # commits...
+    def get_context_from_history(self, history):
+        context = ""
+        if history:
+            for msg in history:
+                context += "\n" + msg["role"].upper() + ": " + msg["content"] + "\n"
+        return context
+    def auto_commit(self):
+        context = self.get_context_from_history(self.cur_messages)
+        res = self.repo.commit(context=context, prefix="aider: ")
+        if res:
+            commit_hash, commit_message = res
+            self.last_aider_commit_hash = commit_hash
+            return self.gpt_prompts.files_content_gpt_edits.format(
+                hash=commit_hash,
+                message=commit_message,
+            )
+        self.io.tool_output("No changes made to git tracked files.")
+        return self.gpt_prompts.files_content_gpt_no_edits
+    def should_dirty_commit(self, inp):
+        cmds = self.commands.matching_commands(inp)
+        if cmds:
+            matching_commands, _, _ = cmds
+            if len(matching_commands) == 1:
+                cmd = matching_commands[0][1:]
+                if cmd in "add clear commit diff drop exit help ls tokens".split():
+                    return
+        if self.last_asked_for_commit_time >= self.get_last_modified():
+            return
+        return True
+    def dirty_commit(self):
+        if not self.dirty_commits:
+            return
+        if not self.repo:
+            return
+        if not self.repo.is_dirty():
+            return
+        self.io.tool_output("Git repo has uncommitted changes.")
+        self.repo.show_diffs(self.pretty)
+        self.last_asked_for_commit_time = self.get_last_modified()
+        res = self.io.prompt_ask(
+            "Commit before the chat proceeds [y/n/commit message]?",
+            default="y",
+        ).strip()
+        if res.lower() in ["n", "no"]:
+            self.io.tool_error("Skipped commmit.")
+            return
+        if res.lower() in ["y", "yes"]:
+            message = None
+        else:
+            message = res.strip()
+        self.repo.commit(message=message)
+        # files changed, move cur messages back behind the files messages
+        self.move_back_cur_messages(self.gpt_prompts.files_content_local_edits)
+        return True
+def check_model_availability(main_model):
+    available_models = openai.Model.list()
+    model_ids = [model.id for model in available_models["data"]]
+    return main_model.name in model_ids

testbed/Aider-AI__aider/aider/coders/base_prompts.py ADDED Viewed

	@@ -0,0 +1,8 @@

+class CoderPrompts:
+    files_content_gpt_edits = "I committed the changes with git hash {hash} & commit msg: {message}"
+    files_content_gpt_edits_no_repo = "I updated the files."
+    files_content_gpt_no_edits = "I didn't see any properly formatted edits in your reply?!"
+    files_content_local_edits = "I edited the files myself."

testbed/Aider-AI__aider/aider/coders/editblock_coder.py ADDED Viewed

	@@ -0,0 +1,406 @@

+import math
+import re
+from difflib import SequenceMatcher
+from pathlib import Path
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .editblock_prompts import EditBlockPrompts
+class EditBlockCoder(Coder):
+    def __init__(self, *args, **kwargs):
+        self.gpt_prompts = EditBlockPrompts()
+        super().__init__(*args, **kwargs)
+    def update_files(self):
+        content = self.partial_response_content
+        # might raise ValueError for malformed ORIG/UPD blocks
+        edits = list(find_original_update_blocks(content))
+        edited = set()
+        for path, original, updated in edits:
+            full_path = self.allowed_to_edit(path)
+            if not full_path:
+                continue
+            content = self.io.read_text(full_path)
+            content = do_replace(full_path, content, original, updated)
+            if content:
+                self.io.write_text(full_path, content)
+                edited.add(path)
+                continue
+            raise ValueError(f"""InvalidEditBlock: edit failed!
+{path} does not contain the *exact sequence* of HEAD lines you specified.
+Try again.
+DO NOT skip blank lines, comments, docstrings, etc!
+The HEAD block needs to be EXACTLY the same as the lines in {path} with nothing missing!
+{path} does not contain these {len(original.splitlines())} exact lines in a row:
+```
+{original}```
+""")
+        return edited
+def prep(content):
+    if content and not content.endswith("\n"):
+        content += "\n"
+    lines = content.splitlines(keepends=True)
+    return content, lines
+def perfect_or_whitespace(whole_lines, part_lines, replace_lines):
+    # Try for a perfect match
+    res = perfect_replace(whole_lines, part_lines, replace_lines)
+    if res:
+        return res
+    # Try being flexible about leading whitespace
+    res = replace_part_with_missing_leading_whitespace(whole_lines, part_lines, replace_lines)
+    if res:
+        return res
+def perfect_replace(whole_lines, part_lines, replace_lines):
+    part_tup = tuple(part_lines)
+    part_len = len(part_lines)
+    for i in range(len(whole_lines) - part_len + 1):
+        whole_tup = tuple(whole_lines[i : i + part_len])
+        if part_tup == whole_tup:
+            res = whole_lines[:i] + replace_lines + whole_lines[i + part_len :]
+            return "".join(res)
+def replace_most_similar_chunk(whole, part, replace):
+    """Best efforts to find the `part` lines in `whole` and replace them with `replace`"""
+    whole, whole_lines = prep(whole)
+    part, part_lines = prep(part)
+    replace, replace_lines = prep(replace)
+    res = perfect_or_whitespace(whole_lines, part_lines, replace_lines)
+    if res:
+        return res
+    # drop leading empty line, GPT sometimes adds them spuriously (issue #25)
+    if len(part_lines) > 2 and not part_lines[0].strip():
+        skip_blank_line_part_lines = part_lines[1:]
+        res = perfect_or_whitespace(whole_lines, skip_blank_line_part_lines, replace_lines)
+        if res:
+            return res
+    # Try to handle when it elides code with ...
+    try:
+        res = try_dotdotdots(whole, part, replace)
+        if res:
+            return res
+    except ValueError:
+        pass
+    return
+    # Try fuzzy matching
+    res = replace_closest_edit_distance(whole_lines, part, part_lines, replace_lines)
+    if res:
+        return res
+def try_dotdotdots(whole, part, replace):
+    """
+    See if the edit block has ... lines.
+    If not, return none.
+    If yes, try and do a perfect edit with the ... chunks.
+    If there's a mismatch or otherwise imperfect edit, raise ValueError.
+    If perfect edit succeeds, return the updated whole.
+    """
+    dots_re = re.compile(r"(^\s*\.\.\.\n)", re.MULTILINE | re.DOTALL)
+    part_pieces = re.split(dots_re, part)
+    replace_pieces = re.split(dots_re, replace)
+    if len(part_pieces) != len(replace_pieces):
+        raise ValueError("Unpaired ... in edit block")
+    if len(part_pieces) == 1:
+        # no dots in this edit block, just return None
+        return
+    # Compare odd strings in part_pieces and replace_pieces
+    all_dots_match = all(part_pieces[i] == replace_pieces[i] for i in range(1, len(part_pieces), 2))
+    if not all_dots_match:
+        raise ValueError("Unmatched ... in edit block")
+    part_pieces = [part_pieces[i] for i in range(0, len(part_pieces), 2)]
+    replace_pieces = [replace_pieces[i] for i in range(0, len(replace_pieces), 2)]
+    pairs = zip(part_pieces, replace_pieces)
+    for part, replace in pairs:
+        if not part and not replace:
+            continue
+        if not part and replace:
+            if not whole.endswith("\n"):
+                whole += "\n"
+            whole += replace
+            continue
+        if whole.count(part) != 1:
+            raise ValueError(
+                "No perfect matching chunk in edit block with ... or part appears more than once"
+            )
+        whole = whole.replace(part, replace, 1)
+    return whole
+def replace_part_with_missing_leading_whitespace(whole_lines, part_lines, replace_lines):
+    # GPT often messes up leading whitespace.
+    # It usually does it uniformly across the ORIG and UPD blocks.
+    # Either omitting all leading whitespace, or including only some of it.
+    # Outdent everything in part_lines and replace_lines by the max fixed amount possible
+    leading = [len(p) - len(p.lstrip()) for p in part_lines if p.strip()] + [
+        len(p) - len(p.lstrip()) for p in replace_lines if p.strip()
+    ]
+    if leading and min(leading):
+        num_leading = min(leading)
+        part_lines = [p[num_leading:] if p.strip() else p for p in part_lines]
+        replace_lines = [p[num_leading:] if p.strip() else p for p in replace_lines]
+    # can we find an exact match not including the leading whitespace
+    num_part_lines = len(part_lines)
+    for i in range(len(whole_lines) - num_part_lines + 1):
+        add_leading = match_but_for_leading_whitespace(
+            whole_lines[i : i + num_part_lines], part_lines
+        )
+        if add_leading is None:
+            continue
+        replace_lines = [add_leading + rline if rline.strip() else rline for rline in replace_lines]
+        whole_lines = whole_lines[:i] + replace_lines + whole_lines[i + num_part_lines :]
+        return "".join(whole_lines)
+    return None
+def match_but_for_leading_whitespace(whole_lines, part_lines):
+    num = len(whole_lines)
+    # does the non-whitespace all agree?
+    if not all(whole_lines[i].lstrip() == part_lines[i].lstrip() for i in range(num)):
+        return
+    # are they all offset the same?
+    add = set(
+        whole_lines[i][: len(whole_lines[i]) - len(part_lines[i])]
+        for i in range(num)
+        if whole_lines[i].strip()
+    )
+    if len(add) != 1:
+        return
+    return add.pop()
+def replace_closest_edit_distance(whole_lines, part, part_lines, replace_lines):
+    similarity_thresh = 0.8
+    max_similarity = 0
+    most_similar_chunk_start = -1
+    most_similar_chunk_end = -1
+    scale = 0.1
+    min_len = math.floor(len(part_lines) * (1 - scale))
+    max_len = math.ceil(len(part_lines) * (1 + scale))
+    for length in range(min_len, max_len):
+        for i in range(len(whole_lines) - length + 1):
+            chunk = whole_lines[i : i + length]
+            chunk = "".join(chunk)
+            similarity = SequenceMatcher(None, chunk, part).ratio()
+            if similarity > max_similarity and similarity:
+                max_similarity = similarity
+                most_similar_chunk_start = i
+                most_similar_chunk_end = i + length
+    if max_similarity < similarity_thresh:
+        return
+    modified_whole = (
+        whole_lines[:most_similar_chunk_start]
+        + replace_lines
+        + whole_lines[most_similar_chunk_end:]
+    )
+    modified_whole = "".join(modified_whole)
+    return modified_whole
+def strip_quoted_wrapping(res, fname=None, fence=None):
+    """
+    Given an input string which may have extra "wrapping" around it, remove the wrapping.
+    For example:
+    filename.ext
+    ```
+    We just want this content
+    Not the filename and triple quotes
+    ```
+    """
+    if not res:
+        return res
+    if not fence:
+        fence = ("```", "```")
+    res = res.splitlines()
+    if fname and res[0].strip().endswith(Path(fname).name):
+        res = res[1:]
+    if res[0].startswith(fence[0]) and res[-1].startswith(fence[1]):
+        res = res[1:-1]
+    res = "\n".join(res)
+    if res and res[-1] != "\n":
+        res += "\n"
+    return res
+def do_replace(fname, content, before_text, after_text, fence=None):
+    before_text = strip_quoted_wrapping(before_text, fname, fence)
+    after_text = strip_quoted_wrapping(after_text, fname, fence)
+    fname = Path(fname)
+    # does it want to make a new file?
+    if not fname.exists() and not before_text.strip():
+        fname.touch()
+        content = ""
+    if content is None:
+        return
+    if not before_text.strip():
+        # append to existing file, or start a new file
+        new_content = content + after_text
+    else:
+        new_content = replace_most_similar_chunk(content, before_text, after_text)
+    return new_content
+HEAD = "<<<<<<< HEAD"
+DIVIDER = "======="
+UPDATED = ">>>>>>> updated"
+separators = "|".join([HEAD, DIVIDER, UPDATED])
+split_re = re.compile(r"^((?:" + separators + r")[ ]*\n)", re.MULTILINE | re.DOTALL)
+def find_original_update_blocks(content):
+    # make sure we end with a newline, otherwise the regex will miss <<UPD on the last line
+    if not content.endswith("\n"):
+        content = content + "\n"
+    pieces = re.split(split_re, content)
+    pieces.reverse()
+    processed = []
+    # Keep using the same filename in cases where GPT produces an edit block
+    # without a filename.
+    current_filename = None
+    try:
+        while pieces:
+            cur = pieces.pop()
+            if cur in (DIVIDER, UPDATED):
+                processed.append(cur)
+                raise ValueError(f"Unexpected {cur}")
+            if cur.strip() != HEAD:
+                processed.append(cur)
+                continue
+            processed.append(cur)  # original_marker
+            filename = processed[-2].splitlines()[-1].strip()
+            try:
+                if not len(filename) or "`" in filename:
+                    filename = processed[-2].splitlines()[-2].strip()
+                if not len(filename) or "`" in filename:
+                    if current_filename:
+                        filename = current_filename
+                    else:
+                        raise ValueError(
+                            f"Bad/missing filename. It should go right above the {HEAD}"
+                        )
+            except IndexError:
+                if current_filename:
+                    filename = current_filename
+                else:
+                    raise ValueError(f"Bad/missing filename. It should go right above the {HEAD}")
+            current_filename = filename
+            original_text = pieces.pop()
+            processed.append(original_text)
+            divider_marker = pieces.pop()
+            processed.append(divider_marker)
+            if divider_marker.strip() != DIVIDER:
+                raise ValueError(f"Expected `{DIVIDER}` not {divider_marker.strip()}")
+            updated_text = pieces.pop()
+            processed.append(updated_text)
+            updated_marker = pieces.pop()
+            processed.append(updated_marker)
+            if updated_marker.strip() != UPDATED:
+                raise ValueError(f"Expected `{UPDATED}` not `{updated_marker.strip()}")
+            yield filename, original_text, updated_text
+    except ValueError as e:
+        processed = "".join(processed)
+        err = e.args[0]
+        raise ValueError(f"{processed}\n^^^ {err}")
+    except IndexError:
+        processed = "".join(processed)
+        raise ValueError(f"{processed}\n^^^ Incomplete HEAD/updated block.")
+    except Exception:
+        processed = "".join(processed)
+        raise ValueError(f"{processed}\n^^^ Error parsing HEAD/updated block.")
+if __name__ == "__main__":
+    edit = """
+Here's the change:
+```text
+foo.txt
+<<<<<<< HEAD
+Two
+=======
+Tooooo
+>>>>>>> updated
+```
+Hope you like it!
+"""
+    print(list(find_original_update_blocks(edit)))

testbed/Aider-AI__aider/aider/coders/editblock_func_coder.py ADDED Viewed

	@@ -0,0 +1,140 @@

+import json
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .editblock_coder import do_replace
+from .editblock_func_prompts import EditBlockFunctionPrompts
+class EditBlockFunctionCoder(Coder):
+    functions = [
+        dict(
+            name="replace_lines",
+            description="create or update one or more files",
+            parameters=dict(
+                type="object",
+                required=["explanation", "edits"],
+                properties=dict(
+                    explanation=dict(
+                        type="string",
+                        description=(
+                            "Step by step plan for the changes to be made to the code (future"
+                            " tense, markdown format)"
+                        ),
+                    ),
+                    edits=dict(
+                        type="array",
+                        items=dict(
+                            type="object",
+                            required=["path", "original_lines", "updated_lines"],
+                            properties=dict(
+                                path=dict(
+                                    type="string",
+                                    description="Path of file to edit",
+                                ),
+                                original_lines=dict(
+                                    type="array",
+                                    items=dict(
+                                        type="string",
+                                    ),
+                                    description=(
+                                        "A unique stretch of lines from the original file,"
+                                        " including all whitespace, without skipping any lines"
+                                    ),
+                                ),
+                                updated_lines=dict(
+                                    type="array",
+                                    items=dict(
+                                        type="string",
+                                    ),
+                                    description="New content to replace the `original_lines` with",
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ]
+    def __init__(self, code_format, *args, **kwargs):
+        self.code_format = code_format
+        if code_format == "string":
+            original_lines = dict(
+                type="string",
+                description=(
+                    "A unique stretch of lines from the original file, including all"
+                    " whitespace and newlines, without skipping any lines"
+                ),
+            )
+            updated_lines = dict(
+                type="string",
+                description="New content to replace the `original_lines` with",
+            )
+            self.functions[0]["parameters"]["properties"]["edits"]["items"]["properties"][
+                "original_lines"
+            ] = original_lines
+            self.functions[0]["parameters"]["properties"]["edits"]["items"]["properties"][
+                "updated_lines"
+            ] = updated_lines
+        self.gpt_prompts = EditBlockFunctionPrompts()
+        super().__init__(*args, **kwargs)
+    def render_incremental_response(self, final=False):
+        if self.partial_response_content:
+            return self.partial_response_content
+        args = self.parse_partial_args()
+        res = json.dumps(args, indent=4)
+        return res
+    def update_files(self):
+        name = self.partial_response_function_call.get("name")
+        if name and name != "replace_lines":
+            raise ValueError(f'Unknown function_call name="{name}", use name="replace_lines"')
+        args = self.parse_partial_args()
+        if not args:
+            return
+        edits = args.get("edits", [])
+        edited = set()
+        for edit in edits:
+            path = get_arg(edit, "path")
+            original = get_arg(edit, "original_lines")
+            updated = get_arg(edit, "updated_lines")
+            # gpt-3.5 returns lists even when instructed to return a string!
+            if self.code_format == "list" or type(original) == list:
+                original = "\n".join(original)
+            if self.code_format == "list" or type(updated) == list:
+                updated = "\n".join(updated)
+            if original and not original.endswith("\n"):
+                original += "\n"
+            if updated and not updated.endswith("\n"):
+                updated += "\n"
+            full_path = self.allowed_to_edit(path)
+            if not full_path:
+                continue
+            content = self.io.read_text(full_path)
+            content = do_replace(full_path, content, original, updated)
+            if content:
+                self.io.write_text(full_path, content)
+                edited.add(path)
+                continue
+            self.io.tool_error(f"Failed to apply edit to {path}")
+        return edited
+def get_arg(edit, arg):
+    if arg not in edit:
+        raise ValueError(f"Missing `{arg}` parameter: {edit}")
+    return edit[arg]

testbed/Aider-AI__aider/aider/coders/editblock_func_prompts.py ADDED Viewed

	@@ -0,0 +1,27 @@

+# flake8: noqa: E501
+from .base_prompts import CoderPrompts
+class EditBlockFunctionPrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+Once you understand the request you MUST use the `replace_lines` function to edit the files to make the needed changes.
+"""
+    system_reminder = """
+ONLY return code using the `replace_lines` function.
+NEVER return code outside the `replace_lines` function.
+"""
+    files_content_prefix = "Here is the current content of the files:\n"
+    files_no_full_files = "I am not sharing any files yet."
+    redacted_edit_message = "No changes are needed."
+    repo_content_prefix = (
+        "Below here are summaries of other files! Do not propose changes to these *read-only*"
+        " files without asking me first.\n"
+    )

testbed/Aider-AI__aider/aider/coders/editblock_prompts.py ADDED Viewed

	@@ -0,0 +1,61 @@

+# flake8: noqa: E501
+from .base_prompts import CoderPrompts
+class EditBlockPrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Always use best practices when coding.
+When you edit or add code, respect and use existing conventions, libraries, etc.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+Once you understand the request you MUST:
+1. List the files you need to modify. *NEVER* suggest changes to a *read-only* file. Instead, 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.
+2. Think step-by-step and explain the needed changes.
+3. Describe each change with an *edit block* per the example below.
+"""
+    system_reminder = """You MUST format EVERY code change with an *edit block* like this:
+{fence[0]}python
+some/dir/example.py
+<<<<<<< HEAD
+    # some comment
+    # Func to multiply
+    def mul(a,b)
+=======
+    # updated comment
+    # Function to add
+    def add(a,b):
+>>>>>>> updated
+{fence[1]}
+A program will parse the edit blocks you generate and replace the `HEAD` lines with the `updated` lines.
+So edit blocks must be precise and unambiguous!
+Every *edit block* must be fenced with {fence[0]}...{fence[1]} with the correct code language.
+Every *edit block* must start with the full path! *NEVER* propose edit blocks for *read-only* files.
+The `HEAD` section must be an *exact set of sequential lines* from the file!
+NEVER SKIP LINES in the `HEAD` section!
+NEVER ELIDE LINES AND REPLACE THEM WITH A COMMENT!
+NEVER OMIT ANY WHITESPACE in the `HEAD` section!
+Edits to different parts of a file each need their own *edit block*.
+If you want to put code in a new file, use an edit block with:
+- A new file path, including dir name if needed
+- An empty `HEAD` section
+- The new file's contents in the `updated` section
+"""
+    files_content_prefix = "These are the *read-write* files:\n"
+    files_no_full_files = "I am not sharing any *read-write* files yet."
+    repo_content_prefix = """Below here are summaries of other files!
+Do not propose changes to these files, they are *read-only*.
+To make a file *read-write*, ask me to *add it to the chat*.
+"""

testbed/Aider-AI__aider/aider/coders/single_wholefile_func_coder.py ADDED Viewed

	@@ -0,0 +1,111 @@

+from aider import diffs
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .single_wholefile_func_prompts import SingleWholeFileFunctionPrompts
+class SingleWholeFileFunctionCoder(Coder):
+    functions = [
+        dict(
+            name="write_file",
+            description="write new content into the file",
+            parameters=dict(
+                type="object",
+                required=["explanation", "content"],
+                properties=dict(
+                    explanation=dict(
+                        type="string",
+                        description=(
+                            "Step by step plan for the changes to be made to the code (future"
+                            " tense, markdown format)"
+                        ),
+                    ),
+                    content=dict(
+                        type="string",
+                        description="Content to write to the file",
+                    ),
+                ),
+            ),
+        ),
+    ]
+    def __init__(self, *args, **kwargs):
+        self.gpt_prompts = SingleWholeFileFunctionPrompts()
+        super().__init__(*args, **kwargs)
+    def update_cur_messages(self, edited):
+        if edited:
+            self.cur_messages += [
+                dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)
+            ]
+        else:
+            self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
+    def render_incremental_response(self, final=False):
+        if self.partial_response_content:
+            return self.partial_response_content
+        args = self.parse_partial_args()
+        return str(args)
+        if not args:
+            return
+        explanation = args.get("explanation")
+        files = args.get("files", [])
+        res = ""
+        if explanation:
+            res += f"{explanation}\n\n"
+        for i, file_upd in enumerate(files):
+            path = file_upd.get("path")
+            if not path:
+                continue
+            content = file_upd.get("content")
+            if not content:
+                continue
+            this_final = (i < len(files) - 1) or final
+            res += self.live_diffs(path, content, this_final)
+        return res
+    def live_diffs(self, fname, content, final):
+        lines = content.splitlines(keepends=True)
+        # ending an existing block
+        full_path = self.abs_root_path(fname)
+        content = self.io.read_text(full_path)
+        if content is None:
+            orig_lines = []
+        else:
+            orig_lines = content.splitlines()
+        show_diff = diffs.diff_partial_update(
+            orig_lines,
+            lines,
+            final,
+            fname=fname,
+        ).splitlines()
+        return "\n".join(show_diff)
+    def update_files(self):
+        name = self.partial_response_function_call.get("name")
+        if name and name != "write_file":
+            raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
+        args = self.parse_partial_args()
+        if not args:
+            return
+        content = args["content"]
+        path = self.get_inchat_relative_files()[0]
+        if self.allowed_to_edit(path, content):
+            return set([path])
+        return set()

testbed/Aider-AI__aider/aider/coders/single_wholefile_func_prompts.py ADDED Viewed

	@@ -0,0 +1,27 @@

+# flake8: noqa: E501
+from .base_prompts import CoderPrompts
+class SingleWholeFileFunctionPrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+Once you understand the request you MUST use the `write_file` function to update the file to make the changes.
+"""
+    system_reminder = """
+ONLY return code using the `write_file` function.
+NEVER return code outside the `write_file` function.
+"""
+    files_content_prefix = "Here is the current content of the file:\n"
+    files_no_full_files = "I am not sharing any files yet."
+    redacted_edit_message = "No changes are needed."
+    # TODO: should this be present for using this with gpt-4?
+    repo_content_prefix = None
+    # TODO: fix the chat history, except we can't keep the whole file

testbed/Aider-AI__aider/aider/coders/wholefile_coder.py ADDED Viewed

	@@ -0,0 +1,137 @@

+from pathlib import Path
+from aider import diffs
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .wholefile_prompts import WholeFilePrompts
+class WholeFileCoder(Coder):
+    def __init__(self, *args, **kwargs):
+        self.gpt_prompts = WholeFilePrompts()
+        super().__init__(*args, **kwargs)
+    def update_cur_messages(self, edited):
+        if edited:
+            self.cur_messages += [
+                dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)
+            ]
+        else:
+            self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
+    def render_incremental_response(self, final):
+        try:
+            return self.update_files(mode="diff")
+        except ValueError:
+            return self.partial_response_content
+    def update_files(self, mode="update"):
+        content = self.partial_response_content
+        chat_files = self.get_inchat_relative_files()
+        output = []
+        lines = content.splitlines(keepends=True)
+        edits = []
+        saw_fname = None
+        fname = None
+        fname_source = None
+        new_lines = []
+        for i, line in enumerate(lines):
+            if line.startswith(self.fence[0]) or line.startswith(self.fence[1]):
+                if fname is not None:
+                    # ending an existing block
+                    saw_fname = None
+                    full_path = (Path(self.root) / fname).absolute()
+                    if mode == "diff":
+                        output += self.do_live_diff(full_path, new_lines, True)
+                    else:
+                        edits.append((fname, fname_source, new_lines))
+                    fname = None
+                    fname_source = None
+                    new_lines = []
+                    continue
+                # fname==None ... starting a new block
+                if i > 0:
+                    fname_source = "block"
+                    fname = lines[i - 1].strip()
+                    fname = fname.strip("*")  # handle **filename.py**
+                    # Did gpt prepend a bogus dir? It especially likes to
+                    # include the path/to prefix from the one-shot example in
+                    # the prompt.
+                    if fname and fname not in chat_files and Path(fname).name in chat_files:
+                        fname = Path(fname).name
+                if not fname:  # blank line? or ``` was on first line i==0
+                    if saw_fname:
+                        fname = saw_fname
+                        fname_source = "saw"
+                    elif len(chat_files) == 1:
+                        fname = chat_files[0]
+                        fname_source = "chat"
+                    else:
+                        # TODO: sense which file it is by diff size
+                        raise ValueError(
+                            f"No filename provided before {self.fence[0]} in file listing"
+                        )
+            elif fname is not None:
+                new_lines.append(line)
+            else:
+                for word in line.strip().split():
+                    word = word.rstrip(".:,;!")
+                    for chat_file in chat_files:
+                        quoted_chat_file = f"`{chat_file}`"
+                        if word == quoted_chat_file:
+                            saw_fname = chat_file
+                output.append(line)
+        if mode == "diff":
+            if fname is not None:
+                # ending an existing block
+                full_path = (Path(self.root) / fname).absolute()
+                output += self.do_live_diff(full_path, new_lines, False)
+            return "\n".join(output)
+        if fname:
+            edits.append((fname, fname_source, new_lines))
+        edited = set()
+        # process from most reliable filename, to least reliable
+        for source in ("block", "saw", "chat"):
+            for fname, fname_source, new_lines in edits:
+                if fname_source != source:
+                    continue
+                # if a higher priority source already edited the file, skip
+                if fname in edited:
+                    continue
+                # we have a winner
+                new_lines = "".join(new_lines)
+                if self.allowed_to_edit(fname, new_lines):
+                    edited.add(fname)
+        return edited
+    def do_live_diff(self, full_path, new_lines, final):
+        if full_path.exists():
+            orig_lines = self.io.read_text(full_path).splitlines(keepends=True)
+            show_diff = diffs.diff_partial_update(
+                orig_lines,
+                new_lines,
+                final=final,
+            ).splitlines()
+            output = show_diff
+        else:
+            output = ["```"] + new_lines + ["```"]
+        return output

testbed/Aider-AI__aider/aider/coders/wholefile_func_coder.py ADDED Viewed

	@@ -0,0 +1,132 @@

+from aider import diffs
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .wholefile_func_prompts import WholeFileFunctionPrompts
+class WholeFileFunctionCoder(Coder):
+    functions = [
+        dict(
+            name="write_file",
+            description="create or update one or more files",
+            parameters=dict(
+                type="object",
+                required=["explanation", "files"],
+                properties=dict(
+                    explanation=dict(
+                        type="string",
+                        description=(
+                            "Step by step plan for the changes to be made to the code (future"
+                            " tense, markdown format)"
+                        ),
+                    ),
+                    files=dict(
+                        type="array",
+                        items=dict(
+                            type="object",
+                            required=["path", "content"],
+                            properties=dict(
+                                path=dict(
+                                    type="string",
+                                    description="Path of file to write",
+                                ),
+                                content=dict(
+                                    type="string",
+                                    description="Content to write to the file",
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ]
+    def __init__(self, *args, **kwargs):
+        self.gpt_prompts = WholeFileFunctionPrompts()
+        super().__init__(*args, **kwargs)
+    def update_cur_messages(self, edited):
+        if edited:
+            self.cur_messages += [
+                dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)
+            ]
+        else:
+            self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
+    def render_incremental_response(self, final=False):
+        if self.partial_response_content:
+            return self.partial_response_content
+        args = self.parse_partial_args()
+        if not args:
+            return
+        explanation = args.get("explanation")
+        files = args.get("files", [])
+        res = ""
+        if explanation:
+            res += f"{explanation}\n\n"
+        for i, file_upd in enumerate(files):
+            path = file_upd.get("path")
+            if not path:
+                continue
+            content = file_upd.get("content")
+            if not content:
+                continue
+            this_final = (i < len(files) - 1) or final
+            res += self.live_diffs(path, content, this_final)
+        return res
+    def live_diffs(self, fname, content, final):
+        lines = content.splitlines(keepends=True)
+        # ending an existing block
+        full_path = self.abs_root_path(fname)
+        content = self.io.read_text(full_path)
+        if content is None:
+            orig_lines = []
+        else:
+            orig_lines = content.splitlines()
+        show_diff = diffs.diff_partial_update(
+            orig_lines,
+            lines,
+            final,
+            fname=fname,
+        ).splitlines()
+        return "\n".join(show_diff)
+    def update_files(self):
+        name = self.partial_response_function_call.get("name")
+        if name and name != "write_file":
+            raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
+        args = self.parse_partial_args()
+        if not args:
+            return
+        files = args.get("files", [])
+        edited = set()
+        for file_upd in files:
+            path = file_upd.get("path")
+            if not path:
+                raise ValueError(f"Missing path parameter: {file_upd}")
+            content = file_upd.get("content")
+            if not content:
+                raise ValueError(f"Missing content parameter: {file_upd}")
+            if self.allowed_to_edit(path, content):
+                edited.add(path)
+        return edited

testbed/Aider-AI__aider/aider/coders/wholefile_func_prompts.py ADDED Viewed

	@@ -0,0 +1,27 @@

+# flake8: noqa: E501
+from .base_prompts import CoderPrompts
+class WholeFileFunctionPrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+Once you understand the request you MUST use the `write_file` function to edit the files to make the needed changes.
+"""
+    system_reminder = """
+ONLY return code using the `write_file` function.
+NEVER return code outside the `write_file` function.
+"""
+    files_content_prefix = "Here is the current content of the files:\n"
+    files_no_full_files = "I am not sharing any files yet."
+    redacted_edit_message = "No changes are needed."
+    # TODO: should this be present for using this with gpt-4?
+    repo_content_prefix = None
+    # TODO: fix the chat history, except we can't keep the whole file

testbed/Aider-AI__aider/aider/coders/wholefile_prompts.py ADDED Viewed

	@@ -0,0 +1,43 @@

+# flake8: noqa: E501
+from .base_prompts import CoderPrompts
+class WholeFilePrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+Once you understand the request you MUST:
+1. Determine if any code changes are needed.
+2. Explain any needed changes.
+3. If changes are needed, output a copy of each file that needs changes.
+"""
+    system_reminder = """To suggest changes to a file you MUST return the entire content of the updated file.
+You MUST use this *file listing* format:
+path/to/filename.js
+{fence[0]}
+// entire file content ...
+// ... goes in between
+{fence[1]}
+Every *file listing* MUST use this format:
+- First line: the filename with any originally provided path
+- Second line: opening {fence[0]}
+- ... entire content of the file ...
+- Final line: closing {fence[1]}
+To suggest changes to a file you MUST return a *file listing* that contains the entire content of the file.
+*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.
+"""
+    files_content_prefix = "Here is the current content of the files:\n"
+    files_no_full_files = "I am not sharing any files yet."
+    redacted_edit_message = "No changes are needed."
+    # this coder is not able to handle repo content
+    repo_content_prefix = None

testbed/Aider-AI__aider/aider/commands.py ADDED Viewed

	@@ -0,0 +1,486 @@

+import json
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+import git
+import tiktoken
+from prompt_toolkit.completion import Completion
+from aider import prompts, voice
+from .dump import dump  # noqa: F401
+class Commands:
+    def __init__(self, io, coder, voice_language=None):
+        self.io = io
+        self.coder = coder
+        if voice_language == "auto":
+            voice_language = None
+        self.voice_language = voice_language
+        self.tokenizer = tiktoken.encoding_for_model(coder.main_model.name)
+    def is_command(self, inp):
+        if inp[0] == "/":
+            return True
+    def get_commands(self):
+        commands = []
+        for attr in dir(self):
+            if attr.startswith("cmd_"):
+                commands.append("/" + attr[4:])
+        return commands
+    def get_command_completions(self, cmd_name, partial):
+        cmd_completions_method_name = f"completions_{cmd_name}"
+        cmd_completions_method = getattr(self, cmd_completions_method_name, None)
+        if cmd_completions_method:
+            for completion in cmd_completions_method(partial):
+                yield completion
+    def do_run(self, cmd_name, args):
+        cmd_method_name = f"cmd_{cmd_name}"
+        cmd_method = getattr(self, cmd_method_name, None)
+        if cmd_method:
+            return cmd_method(args)
+        else:
+            self.io.tool_output(f"Error: Command {cmd_name} not found.")
+    def matching_commands(self, inp):
+        words = inp.strip().split()
+        if not words:
+            return
+        first_word = words[0]
+        rest_inp = inp[len(words[0]) :]
+        all_commands = self.get_commands()
+        matching_commands = [cmd for cmd in all_commands if cmd.startswith(first_word)]
+        return matching_commands, first_word, rest_inp
+    def run(self, inp):
+        res = self.matching_commands(inp)
+        if res is None:
+            return
+        matching_commands, first_word, rest_inp = res
+        if len(matching_commands) == 1:
+            return self.do_run(matching_commands[0][1:], rest_inp)
+        elif len(matching_commands) > 1:
+            self.io.tool_error(f"Ambiguous command: {', '.join(matching_commands)}")
+        else:
+            self.io.tool_error(f"Invalid command: {first_word}")
+    # any method called cmd_xxx becomes a command automatically.
+    # each one must take an args param.
+    def cmd_commit(self, args):
+        "Commit edits to the repo made outside the chat (commit message optional)"
+        if not self.coder.repo:
+            self.io.tool_error("No git repository found.")
+            return
+        if not self.coder.repo.is_dirty():
+            self.io.tool_error("No more changes to commit.")
+            return
+        commit_message = args.strip()
+        self.coder.repo.commit(message=commit_message)
+    def cmd_clear(self, args):
+        "Clear the chat history"
+        self.coder.done_messages = []
+        self.coder.cur_messages = []
+    def cmd_tokens(self, args):
+        "Report on the number of tokens used by the current chat context"
+        res = []
+        # system messages
+        msgs = [
+            dict(role="system", content=self.coder.gpt_prompts.main_system),
+            dict(role="system", content=self.coder.gpt_prompts.system_reminder),
+        ]
+        tokens = len(self.tokenizer.encode(json.dumps(msgs)))
+        res.append((tokens, "system messages", ""))
+        # chat history
+        msgs = self.coder.done_messages + self.coder.cur_messages
+        if msgs:
+            msgs = [dict(role="dummy", content=msg) for msg in msgs]
+            msgs = json.dumps(msgs)
+            tokens = len(self.tokenizer.encode(msgs))
+            res.append((tokens, "chat history", "use /clear to clear"))
+        # repo map
+        other_files = set(self.coder.get_all_abs_files()) - set(self.coder.abs_fnames)
+        if self.coder.repo_map:
+            repo_content = self.coder.repo_map.get_repo_map(self.coder.abs_fnames, other_files)
+            if repo_content:
+                tokens = len(self.tokenizer.encode(repo_content))
+                res.append((tokens, "repository map", "use --map-tokens to resize"))
+        # files
+        for fname in self.coder.abs_fnames:
+            relative_fname = self.coder.get_rel_fname(fname)
+            content = self.io.read_text(fname)
+            # approximate
+            content = f"{relative_fname}\n```\n" + content + "```\n"
+            tokens = len(self.tokenizer.encode(content))
+            res.append((tokens, f"{relative_fname}", "use /drop to drop from chat"))
+        self.io.tool_output("Approximate context window usage, in tokens:")
+        self.io.tool_output()
+        width = 8
+        cost_width = 7
+        def fmt(v):
+            return format(int(v), ",").rjust(width)
+        col_width = max(len(row[1]) for row in res)
+        cost_pad = " " * cost_width
+        total = 0
+        total_cost = 0.0
+        for tk, msg, tip in res:
+            total += tk
+            cost = tk * (self.coder.main_model.prompt_price / 1000)
+            total_cost += cost
+            msg = msg.ljust(col_width)
+            self.io.tool_output(f"${cost:5.2f} {fmt(tk)} {msg} {tip}")
+        self.io.tool_output("=" * (width + cost_width + 1))
+        self.io.tool_output(f"${total_cost:5.2f} {fmt(total)} tokens total")
+        limit = self.coder.main_model.max_context_tokens
+        remaining = limit - total
+        if remaining > 1024:
+            self.io.tool_output(f"{cost_pad}{fmt(remaining)} tokens remaining in context window")
+        elif remaining > 0:
+            self.io.tool_error(
+                f"{cost_pad}{fmt(remaining)} tokens remaining in context window (use /drop or"
+                " /clear to make space)"
+            )
+        else:
+            self.io.tool_error(f"{cost_pad}{fmt(remaining)} tokens remaining, window exhausted!")
+        self.io.tool_output(f"{cost_pad}{fmt(limit)} tokens max context window size")
+    def cmd_undo(self, args):
+        "Undo the last git commit if it was done by aider"
+        if not self.coder.repo:
+            self.io.tool_error("No git repository found.")
+            return
+        if self.coder.repo.is_dirty():
+            self.io.tool_error(
+                "The repository has uncommitted changes. Please commit or stash them before"
+                " undoing."
+            )
+            return
+        local_head = self.coder.repo.repo.git.rev_parse("HEAD")
+        current_branch = self.coder.repo.repo.active_branch.name
+        try:
+            remote_head = self.coder.repo.repo.git.rev_parse(f"origin/{current_branch}")
+            has_origin = True
+        except git.exc.GitCommandError:
+            has_origin = False
+        if has_origin:
+            if local_head == remote_head:
+                self.io.tool_error(
+                    "The last commit has already been pushed to the origin. Undoing is not"
+                    " possible."
+                )
+                return
+        last_commit = self.coder.repo.repo.head.commit
+        if (
+            not last_commit.message.startswith("aider:")
+            or last_commit.hexsha[:7] != self.coder.last_aider_commit_hash
+        ):
+            self.io.tool_error("The last commit was not made by aider in this chat session.")
+            return
+        self.coder.repo.repo.git.reset("--hard", "HEAD~1")
+        self.io.tool_output(
+            f"{last_commit.message.strip()}\n"
+            f"The above commit {self.coder.last_aider_commit_hash} "
+            "was reset and removed from git.\n"
+        )
+        if self.coder.main_model.send_undo_reply:
+            return prompts.undo_command_reply
+    def cmd_diff(self, args):
+        "Display the diff of the last aider commit"
+        if not self.coder.repo:
+            self.io.tool_error("No git repository found.")
+            return
+        if not self.coder.last_aider_commit_hash:
+            self.io.tool_error("No previous aider commit found.")
+            return
+        commits = f"{self.coder.last_aider_commit_hash}~1"
+        diff = self.coder.repo.get_diffs(
+            self.coder.pretty,
+            commits,
+            self.coder.last_aider_commit_hash,
+        )
+        # don't use io.tool_output() because we don't want to log or further colorize
+        print(diff)
+    def completions_add(self, partial):
+        files = set(self.coder.get_all_relative_files())
+        files = files - set(self.coder.get_inchat_relative_files())
+        for fname in files:
+            if partial.lower() in fname.lower():
+                yield Completion(fname, start_position=-len(partial))
+    def glob_filtered_to_repo(self, pattern):
+        raw_matched_files = list(Path(self.coder.root).glob(pattern))
+        matched_files = []
+        for fn in raw_matched_files:
+            matched_files += expand_subdir(fn)
+        matched_files = [str(Path(fn).relative_to(self.coder.root)) for fn in matched_files]
+        # if repo, filter against it
+        if self.coder.repo:
+            git_files = self.coder.repo.get_tracked_files()
+            matched_files = [fn for fn in matched_files if str(fn) in git_files]
+        res = list(map(str, matched_files))
+        return res
+    def cmd_add(self, args):
+        "Add matching files to the chat session using glob patterns"
+        added_fnames = []
+        git_added = []
+        git_files = self.coder.repo.get_tracked_files() if self.coder.repo else []
+        all_matched_files = set()
+        for word in args.split():
+            matched_files = self.glob_filtered_to_repo(word)
+            if not matched_files:
+                if any(char in word for char in "*?[]"):
+                    self.io.tool_error(f"No files to add matching pattern: {word}")
+                else:
+                    if Path(word).exists():
+                        if Path(word).is_file():
+                            matched_files = [word]
+                        else:
+                            self.io.tool_error(f"Unable to add: {word}")
+                    elif self.io.confirm_ask(
+                        f"No files matched '{word}'. Do you want to create the file?"
+                    ):
+                        (Path(self.coder.root) / word).touch()
+                        matched_files = [word]
+            all_matched_files.update(matched_files)
+        for matched_file in all_matched_files:
+            abs_file_path = self.coder.abs_root_path(matched_file)
+            if self.coder.repo and matched_file not in git_files:
+                self.coder.repo.repo.git.add(abs_file_path)
+                git_added.append(matched_file)
+            if abs_file_path in self.coder.abs_fnames:
+                self.io.tool_error(f"{matched_file} is already in the chat")
+            else:
+                content = self.io.read_text(abs_file_path)
+                if content is None:
+                    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")
+                    added_fnames.append(matched_file)
+        if self.coder.repo and git_added:
+            git_added = " ".join(git_added)
+            commit_message = f"aider: Added {git_added}"
+            self.coder.repo.commit(message=commit_message)
+        if not added_fnames:
+            return
+        # only reply if there's been some chatting since the last edit
+        if not self.coder.cur_messages:
+            return
+        reply = prompts.added_files.format(fnames=", ".join(added_fnames))
+        return reply
+    def completions_drop(self, partial):
+        files = self.coder.get_inchat_relative_files()
+        for fname in files:
+            if partial.lower() in fname.lower():
+                yield Completion(fname, start_position=-len(partial))
+    def cmd_drop(self, args):
+        "Remove matching files from the chat session"
+        if not args.strip():
+            self.io.tool_output("Dropping all files from the chat session.")
+            self.coder.abs_fnames = set()
+        for word in args.split():
+            matched_files = self.glob_filtered_to_repo(word)
+            if not matched_files:
+                self.io.tool_error(f"No files matched '{word}'")
+            for matched_file in matched_files:
+                abs_fname = self.coder.abs_root_path(matched_file)
+                if abs_fname in self.coder.abs_fnames:
+                    self.coder.abs_fnames.remove(abs_fname)
+                    self.io.tool_output(f"Removed {matched_file} from the chat")
+    def cmd_git(self, args):
+        "Run a git command"
+        combined_output = None
+        try:
+            parsed_args = shlex.split("git " + args)
+            env = dict(GIT_EDITOR="true", **subprocess.os.environ)
+            result = subprocess.run(
+                parsed_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, env=env
+            )
+            combined_output = result.stdout
+        except Exception as e:
+            self.io.tool_error(f"Error running git command: {e}")
+        if combined_output is None:
+            return
+        self.io.tool_output(combined_output)
+    def cmd_run(self, args):
+        "Run a shell command and optionally add the output to the chat"
+        combined_output = None
+        try:
+            parsed_args = shlex.split(args)
+            result = subprocess.run(
+                parsed_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+            )
+            combined_output = result.stdout
+        except Exception as e:
+            self.io.tool_error(f"Error running command: {e}")
+        if combined_output is None:
+            return
+        self.io.tool_output(combined_output)
+        if self.io.confirm_ask("Add the output to the chat?", default="y"):
+            for line in combined_output.splitlines():
+                self.io.tool_output(line, log_only=True)
+            msg = prompts.run_output.format(
+                command=args,
+                output=combined_output,
+            )
+            return msg
+    def cmd_exit(self, args):
+        "Exit the application"
+        sys.exit()
+    def cmd_ls(self, args):
+        "List all known files and those included in the chat session"
+        files = self.coder.get_all_relative_files()
+        other_files = []
+        chat_files = []
+        for file in files:
+            abs_file_path = self.coder.abs_root_path(file)
+            if abs_file_path in self.coder.abs_fnames:
+                chat_files.append(file)
+            else:
+                other_files.append(file)
+        if not chat_files and not other_files:
+            self.io.tool_output("\nNo files in chat or git repo.")
+            return
+        if chat_files:
+            self.io.tool_output("Files in chat:\n")
+        for file in chat_files:
+            self.io.tool_output(f"  {file}")
+        if other_files:
+            self.io.tool_output("\nRepo files not in the chat:\n")
+        for file in other_files:
+            self.io.tool_output(f"  {file}")
+    def cmd_help(self, args):
+        "Show help about all commands"
+        commands = sorted(self.get_commands())
+        for cmd in commands:
+            cmd_method_name = f"cmd_{cmd[1:]}"
+            cmd_method = getattr(self, cmd_method_name, None)
+            if cmd_method:
+                description = cmd_method.__doc__
+                self.io.tool_output(f"{cmd} {description}")
+            else:
+                self.io.tool_output(f"{cmd} No description available.")
+    def cmd_voice(self, args):
+        "Record and transcribe voice input"
+        v = voice.Voice()
+        if not v.is_audio_available():
+            self.io.tool_error("Unable to import `sounddevice`, 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)
+        text = v.record_and_transcribe(history, language=self.voice_language)
+        if text:
+            self.io.add_to_input_history(text)
+            print()
+            self.io.user_input(text, log_only=False)
+            print()
+        return text
+def expand_subdir(file_path):
+    file_path = Path(file_path)
+    if file_path.is_file():
+        yield file_path
+        return
+    if file_path.is_dir():
+        for file in file_path.rglob("*"):
+            if file.is_file():
+                yield str(file)

testbed/Aider-AI__aider/aider/diffs.py ADDED Viewed

	@@ -0,0 +1,129 @@

+import difflib
+import sys
+from .dump import dump  # noqa: F401
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python diffs.py file1 file")
+        sys.exit(1)
+    file_orig, file_updated = sys.argv[1], sys.argv[2]
+    with open(file_orig, "r", encoding="utf-8") as f:
+        lines_orig = f.readlines()
+    with open(file_updated, "r", encoding="utf-8") as f:
+        lines_updated = f.readlines()
+    for i in range(len(file_updated)):
+        res = diff_partial_update(lines_orig, lines_updated[:i])
+        print(res)
+        input()
+def create_progress_bar(percentage):
+    block = "█"
+    empty = "░"
+    total_blocks = 30
+    filled_blocks = int(total_blocks * percentage // 100)
+    empty_blocks = total_blocks - filled_blocks
+    bar = block * filled_blocks + empty * empty_blocks
+    return bar
+def assert_newlines(lines):
+    if not lines:
+        return
+    for line in lines[:-1]:
+        assert line and line[-1] == "\n", line
+def diff_partial_update(lines_orig, lines_updated, final=False, fname=None):
+    """
+    Given only the first part of an updated file, show the diff while
+    ignoring the block of "deleted" lines that are past the end of the
+    partially complete update.
+    """
+    # dump(lines_orig)
+    # dump(lines_updated)
+    assert_newlines(lines_orig)
+    assert_newlines(lines_orig)
+    num_orig_lines = len(lines_orig)
+    if final:
+        last_non_deleted = num_orig_lines
+    else:
+        last_non_deleted = find_last_non_deleted(lines_orig, lines_updated)
+    # dump(last_non_deleted)
+    if last_non_deleted is None:
+        return ""
+    if num_orig_lines:
+        pct = last_non_deleted * 100 / num_orig_lines
+    else:
+        pct = 50
+    bar = create_progress_bar(pct)
+    bar = f" {last_non_deleted:3d} / {num_orig_lines:3d} lines [{bar}] {pct:3.0f}%\n"
+    lines_orig = lines_orig[:last_non_deleted]
+    if not final:
+        lines_updated = lines_updated[:-1] + [bar]
+    diff = difflib.unified_diff(lines_orig, lines_updated, n=5)
+    diff = list(diff)[2:]
+    diff = "".join(diff)
+    if not diff.endswith("\n"):
+        diff += "\n"
+    for i in range(3, 10):
+        backticks = "`" * i
+        if backticks not in diff:
+            break
+    show = f"{backticks}diff\n"
+    if fname:
+        show += f"--- {fname} original\n"
+        show += f"+++ {fname} updated\n"
+    show += diff
+    show += f"{backticks}\n\n"
+    # print(diff)
+    return show
+def find_last_non_deleted(lines_orig, lines_updated):
+    diff = list(difflib.ndiff(lines_orig, lines_updated))
+    num_orig = 0
+    last_non_deleted_orig = None
+    for line in diff:
+        # print(f"{num_orig:2d} {num_updated:2d} {line}", end="")
+        code = line[0]
+        if code == " ":
+            num_orig += 1
+            last_non_deleted_orig = num_orig
+        elif code == "-":
+            # line only in orig
+            num_orig += 1
+        elif code == "+":
+            # line only in updated
+            pass
+    return last_non_deleted_orig
+if __name__ == "__main__":
+    main()

testbed/Aider-AI__aider/aider/dump.py ADDED Viewed

	@@ -0,0 +1,29 @@

+import json
+import traceback
+def cvt(s):
+    if isinstance(s, str):
+        return s
+    try:
+        return json.dumps(s, indent=4)
+    except TypeError:
+        return str(s)
+def dump(*vals):
+    # http://docs.python.org/library/traceback.html
+    stack = traceback.extract_stack()
+    vars = stack[-2][3]
+    # strip away the call to dump()
+    vars = "(".join(vars.split("(")[1:])
+    vars = ")".join(vars.split(")")[:-1])
+    vals = [cvt(v) for v in vals]
+    has_newline = sum(1 for v in vals if "\n" in v)
+    if has_newline:
+        print("%s:" % vars)
+        print(", ".join(vals))
+    else:
+        print("%s:" % vars, ", ".join(vals))

testbed/Aider-AI__aider/aider/history.py ADDED Viewed

	@@ -0,0 +1,132 @@

+import argparse
+import json
+import tiktoken
+from aider import models, prompts
+from aider.dump import dump  # noqa: F401
+from aider.sendchat import simple_send_with_retries
+class ChatSummary:
+    def __init__(self, model=models.GPT35.name, max_tokens=1024):
+        self.tokenizer = tiktoken.encoding_for_model(model)
+        self.max_tokens = max_tokens
+    def too_big(self, messages):
+        sized = self.tokenize(messages)
+        total = sum(tokens for tokens, _msg in sized)
+        return total > self.max_tokens
+    def tokenize(self, messages):
+        sized = []
+        for msg in messages:
+            tokens = len(self.tokenizer.encode(json.dumps(msg)))
+            sized.append((tokens, msg))
+        return sized
+    def summarize(self, messages, depth=0):
+        sized = self.tokenize(messages)
+        total = sum(tokens for tokens, _msg in sized)
+        if total <= self.max_tokens and depth == 0:
+            return messages
+        min_split = 4
+        if len(messages) <= min_split or depth > 3:
+            return self.summarize_all(messages)
+        tail_tokens = 0
+        split_index = len(messages)
+        half_max_tokens = self.max_tokens // 2
+        # Iterate over the messages in reverse order
+        for i in range(len(sized) - 1, -1, -1):
+            tokens, _msg = sized[i]
+            if tail_tokens + tokens < half_max_tokens:
+                tail_tokens += tokens
+                split_index = i
+            else:
+                break
+        # Ensure the head ends with an assistant message
+        while messages[split_index - 1]["role"] != "assistant" and split_index > 1:
+            split_index -= 1
+        if split_index <= min_split:
+            return self.summarize_all(messages)
+        head = messages[:split_index]
+        tail = messages[split_index:]
+        summary = self.summarize_all(head)
+        tail_tokens = sum(tokens for tokens, msg in sized[split_index:])
+        summary_tokens = len(self.tokenizer.encode(json.dumps(summary)))
+        result = summary + tail
+        if summary_tokens + tail_tokens < self.max_tokens:
+            return result
+        return self.summarize(result, depth + 1)
+    def summarize_all(self, messages):
+        content = ""
+        for msg in messages:
+            role = msg["role"].upper()
+            if role not in ("USER", "ASSISTANT"):
+                continue
+            content += f"# {role}\n"
+            content += msg["content"]
+            if not content.endswith("\n"):
+                content += "\n"
+        messages = [
+            dict(role="system", content=prompts.summarize),
+            dict(role="user", content=content),
+        ]
+        summary = simple_send_with_retries(model=models.GPT35.name, messages=messages)
+        summary = prompts.summary_prefix + summary
+        return [dict(role="user", content=summary)]
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("filename", help="Markdown file to parse")
+    args = parser.parse_args()
+    with open(args.filename, "r") as f:
+        text = f.read()
+    messages = []
+    assistant = []
+    for line in text.splitlines(keepends=True):
+        if line.startswith("# "):
+            continue
+        if line.startswith(">"):
+            continue
+        if line.startswith("#### /"):
+            continue
+        if line.startswith("#### "):
+            if assistant:
+                assistant = "".join(assistant)
+                if assistant.strip():
+                    messages.append(dict(role="assistant", content=assistant))
+                assistant = []
+            content = line[5:]
+            if content.strip() and content.strip() != "<blank>":
+                messages.append(dict(role="user", content=line[5:]))
+            continue
+        assistant.append(line)
+    summarizer = ChatSummary(models.GPT35.name)
+    summary = summarizer.summarize(messages[-40:])
+    dump(summary)
+if __name__ == "__main__":
+    main()

testbed/Aider-AI__aider/aider/io.py ADDED Viewed

	@@ -0,0 +1,338 @@

+import os
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.lexers import PygmentsLexer
+from prompt_toolkit.shortcuts import CompleteStyle, PromptSession, prompt
+from prompt_toolkit.styles import Style
+from pygments.lexers import MarkdownLexer, guess_lexer_for_filename
+from pygments.token import Token
+from pygments.util import ClassNotFound
+from rich.console import Console
+from rich.text import Text
+from .dump import dump  # noqa: F401
+class AutoCompleter(Completer):
+    def __init__(self, root, rel_fnames, addable_rel_fnames, commands, encoding):
+        self.commands = commands
+        self.addable_rel_fnames = addable_rel_fnames
+        self.rel_fnames = rel_fnames
+        self.encoding = encoding
+        fname_to_rel_fnames = defaultdict(list)
+        for rel_fname in addable_rel_fnames:
+            fname = os.path.basename(rel_fname)
+            if fname != rel_fname:
+                fname_to_rel_fnames[fname].append(rel_fname)
+        self.fname_to_rel_fnames = fname_to_rel_fnames
+        self.words = set()
+        for rel_fname in addable_rel_fnames:
+            self.words.add(rel_fname)
+        for rel_fname in rel_fnames:
+            self.words.add(rel_fname)
+            fname = Path(root) / rel_fname
+            try:
+                with open(fname, "r", encoding=self.encoding) as f:
+                    content = f.read()
+            except FileNotFoundError:
+                continue
+            try:
+                lexer = guess_lexer_for_filename(fname, content)
+            except ClassNotFound:
+                continue
+            tokens = list(lexer.get_tokens(content))
+            self.words.update(token[1] for token in tokens if token[0] in Token.Name)
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        words = text.split()
+        if not words:
+            return
+        if text[0] == "/":
+            if len(words) == 1 and not text[-1].isspace():
+                candidates = self.commands.get_commands()
+                candidates = [(cmd, cmd) for cmd in candidates]
+            else:
+                for completion in self.commands.get_command_completions(words[0][1:], words[-1]):
+                    yield completion
+                return
+        else:
+            candidates = self.words
+            candidates.update(set(self.fname_to_rel_fnames))
+            candidates = [(word, f"`{word}`") for word in candidates]
+        last_word = words[-1]
+        for word_match, word_insert in candidates:
+            if word_match.lower().startswith(last_word.lower()):
+                rel_fnames = self.fname_to_rel_fnames.get(word_match, [])
+                if rel_fnames:
+                    for rel_fname in rel_fnames:
+                        yield Completion(
+                            f"`{rel_fname}`", start_position=-len(last_word), display=rel_fname
+                        )
+                else:
+                    yield Completion(
+                        word_insert, start_position=-len(last_word), display=word_match
+                    )
+class InputOutput:
+    num_error_outputs = 0
+    num_user_asks = 0
+    def __init__(
+        self,
+        pretty=True,
+        yes=False,
+        input_history_file=None,
+        chat_history_file=None,
+        input=None,
+        output=None,
+        user_input_color="blue",
+        tool_output_color=None,
+        tool_error_color="red",
+        encoding="utf-8",
+        dry_run=False,
+    ):
+        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.input = input
+        self.output = output
+        self.pretty = pretty
+        if self.output:
+            self.pretty = False
+        self.yes = yes
+        self.input_history_file = input_history_file
+        if chat_history_file is not None:
+            self.chat_history_file = Path(chat_history_file)
+        else:
+            self.chat_history_file = None
+        self.encoding = encoding
+        self.dry_run = dry_run
+        if pretty:
+            self.console = Console()
+        else:
+            self.console = Console(force_terminal=False, no_color=True)
+        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")
+    def read_text(self, filename):
+        try:
+            with open(str(filename), "r", encoding=self.encoding) as f:
+                return f.read()
+        except FileNotFoundError:
+            self.tool_error(f"{filename}: file not found error")
+            return
+        except UnicodeError as e:
+            self.tool_error(f"{filename}: {e}")
+            self.tool_error("Use --encoding to set the unicode encoding.")
+            return
+    def write_text(self, filename, content):
+        if self.dry_run:
+            return
+        with open(str(filename), "w", encoding=self.encoding) as f:
+            f.write(content)
+    def get_input(self, root, rel_fnames, addable_rel_fnames, commands):
+        if self.pretty:
+            style = dict(style=self.user_input_color) if self.user_input_color else dict()
+            self.console.rule(**style)
+        else:
+            print()
+        rel_fnames = list(rel_fnames)
+        show = " ".join(rel_fnames)
+        if len(show) > 10:
+            show += "\n"
+        show += "> "
+        inp = ""
+        multiline_input = False
+        if self.user_input_color:
+            style = Style.from_dict(
+                {
+                    "": self.user_input_color,
+                    "pygments.literal.string": f"bold italic {self.user_input_color}",
+                }
+            )
+        else:
+            style = None
+        while True:
+            completer_instance = AutoCompleter(
+                root, rel_fnames, addable_rel_fnames, commands, self.encoding
+            )
+            if multiline_input:
+                show = ". "
+            session_kwargs = {
+                "message": show,
+                "completer": completer_instance,
+                "reserve_space_for_menu": 4,
+                "complete_style": CompleteStyle.MULTI_COLUMN,
+                "input": self.input,
+                "output": self.output,
+                "lexer": PygmentsLexer(MarkdownLexer),
+            }
+            if style:
+                session_kwargs["style"] = style
+            if self.input_history_file is not None:
+                session_kwargs["history"] = FileHistory(self.input_history_file)
+            kb = KeyBindings()
+            @kb.add("escape", "c-m", eager=True)
+            def _(event):
+                event.current_buffer.insert_text("\n")
+            session = PromptSession(key_bindings=kb, **session_kwargs)
+            line = session.prompt()
+            if line and line[0] == "{" and not multiline_input:
+                multiline_input = True
+                inp += line[1:] + "\n"
+                continue
+            elif line and line[-1] == "}" and multiline_input:
+                inp += line[:-1] + "\n"
+                break
+            elif multiline_input:
+                inp += line + "\n"
+            else:
+                inp = line
+                break
+        print()
+        self.user_input(inp)
+        return inp
+    def add_to_input_history(self, inp):
+        if not self.input_history_file:
+            return
+        FileHistory(self.input_history_file).append_string(inp)
+    def get_input_history(self):
+        if not self.input_history_file:
+            return []
+        fh = FileHistory(self.input_history_file)
+        return fh.load_history_strings()
+    def user_input(self, inp, log_only=True):
+        if not log_only:
+            style = dict(style=self.user_input_color) if self.user_input_color else dict()
+            self.console.print(inp, **style)
+        prefix = "####"
+        if inp:
+            hist = inp.splitlines()
+        else:
+            hist = ["<blank>"]
+        hist = f"  \n{prefix} ".join(hist)
+        hist = f"""
+{prefix} {hist}"""
+        self.append_chat_history(hist, linebreak=True)
+    # OUTPUT
+    def ai_output(self, content):
+        hist = "\n" + content.strip() + "\n\n"
+        self.append_chat_history(hist)
+    def confirm_ask(self, question, default="y"):
+        self.num_user_asks += 1
+        if self.yes is True:
+            res = "yes"
+        elif self.yes is False:
+            res = "no"
+        else:
+            res = prompt(question + " ", default=default)
+        hist = f"{question.strip()} {res.strip()}"
+        self.append_chat_history(hist, linebreak=True, blockquote=True)
+        if self.yes in (True, False):
+            self.tool_output(hist)
+        if not res or not res.strip():
+            return
+        return res.strip().lower().startswith("y")
+    def prompt_ask(self, question, default=None):
+        self.num_user_asks += 1
+        if self.yes is True:
+            res = "yes"
+        elif self.yes is False:
+            res = "no"
+        else:
+            res = prompt(question + " ", default=default)
+        hist = f"{question.strip()} {res.strip()}"
+        self.append_chat_history(hist, linebreak=True, blockquote=True)
+        if self.yes in (True, False):
+            self.tool_output(hist)
+        return res
+    def tool_error(self, message):
+        self.num_error_outputs += 1
+        if message.strip():
+            hist = f"{message.strip()}"
+            self.append_chat_history(hist, linebreak=True, blockquote=True)
+        message = Text(message)
+        style = dict(style=self.tool_error_color) if self.tool_error_color else dict()
+        self.console.print(message, **style)
+    def tool_output(self, *messages, log_only=False):
+        if messages:
+            hist = " ".join(messages)
+            hist = f"{hist.strip()}"
+            self.append_chat_history(hist, linebreak=True, blockquote=True)
+        if not log_only:
+            messages = list(map(Text, messages))
+            style = dict(style=self.tool_output_color) if self.tool_output_color else dict()
+            self.console.print(*messages, **style)
+    def append_chat_history(self, text, linebreak=False, blockquote=False):
+        if blockquote:
+            text = text.strip()
+            text = "> " + text
+        if linebreak:
+            text = text.rstrip()
+            text = text + "  \n"
+        if not text.endswith("\n"):
+            text += "\n"
+        if self.chat_history_file is not None:
+            with self.chat_history_file.open("a", encoding=self.encoding) as f:
+                f.write(text)

testbed/Aider-AI__aider/aider/main.py ADDED Viewed

	@@ -0,0 +1,536 @@

+import os
+import sys
+from pathlib import Path
+import configargparse
+import git
+import openai
+from aider import __version__, models
+from aider.coders import Coder
+from aider.io import InputOutput
+from aider.repo import GitRepo
+from aider.versioncheck import check_version
+from .dump import dump  # noqa: F401
+def get_git_root():
+    """Try and guess the git repo, since the conf.yml can be at the repo root"""
+    try:
+        repo = git.Repo(search_parent_directories=True)
+        return repo.working_tree_dir
+    except git.InvalidGitRepositoryError:
+        return None
+def guessed_wrong_repo(io, git_root, fnames, git_dname):
+    """After we parse the args, we can determine the real repo. Did we guess wrong?"""
+    try:
+        check_repo = Path(GitRepo(io, fnames, git_dname).root).resolve()
+    except FileNotFoundError:
+        return
+    # we had no guess, rely on the "true" repo result
+    if not git_root:
+        return str(check_repo)
+    git_root = Path(git_root).resolve()
+    if check_repo == git_root:
+        return
+    return str(check_repo)
+def setup_git(git_root, io):
+    if git_root:
+        return git_root
+    if not io.confirm_ask("No git repo found, create one to track GPT's changes (recommended)?"):
+        return
+    git_root = str(Path.cwd().resolve())
+    check_gitignore(git_root, io, False)
+    repo = git.Repo.init(git_root)
+    global_git_config = git.GitConfigParser([str(Path.home() / ".gitconfig")], read_only=True)
+    with repo.config_writer() as git_config:
+        if not global_git_config.has_option("user", "name"):
+            git_config.set_value("user", "name", "Your Name")
+            io.tool_error('Update git name with: git config --global user.name "Your Name"')
+        if not global_git_config.has_option("user", "email"):
+            git_config.set_value("user", "email", "you@example.com")
+            io.tool_error('Update git email with: git config --global user.email "you@example.com"')
+    io.tool_output("Git repository created in the current working directory.")
+    return repo.working_tree_dir
+def check_gitignore(git_root, io, ask=True):
+    if not git_root:
+        return
+    pat = ".aider*"
+    gitignore_file = Path(git_root) / ".gitignore"
+    if gitignore_file.exists():
+        content = io.read_text(gitignore_file)
+        if pat in content.splitlines():
+            return
+    else:
+        content = ""
+    if ask and not io.confirm_ask(f"Add {pat} to .gitignore (recommended)?"):
+        return
+    if content and not content.endswith("\n"):
+        content += "\n"
+    content += pat + "\n"
+    io.write_text(gitignore_file, content)
+    io.tool_output(f"Added {pat} to .gitignore")
+def main(argv=None, input=None, output=None, force_git_root=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    if force_git_root:
+        git_root = force_git_root
+    else:
+        git_root = get_git_root()
+    conf_fname = Path(".aider.conf.yml")
+    default_config_files = [conf_fname.resolve()]  # CWD
+    if git_root:
+        git_conf = Path(git_root) / conf_fname  # git root
+        if git_conf not in default_config_files:
+            default_config_files.append(git_conf)
+    default_config_files.append(Path.home() / conf_fname)  # homedir
+    default_config_files = list(map(str, default_config_files))
+    parser = configargparse.ArgumentParser(
+        description="aider is GPT powered coding 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_",
+    )
+    ##########
+    core_group = parser.add_argument_group("Main")
+    core_group.add_argument(
+        "files",
+        metavar="FILE",
+        nargs="*",
+        help="the directory of a git repo, or a list of files to edit with GPT (optional)",
+    )
+    core_group.add_argument(
+        "--openai-api-key",
+        metavar="OPENAI_API_KEY",
+        help="Specify the OpenAI API key",
+        env_var="OPENAI_API_KEY",
+    )
+    core_group.add_argument(
+        "--model",
+        metavar="MODEL",
+        default=models.GPT4.name,
+        help=f"Specify the model to use for the main chat (default: {models.GPT4.name})",
+    )
+    core_group.add_argument(
+        "-3",
+        action="store_const",
+        dest="model",
+        const=models.GPT35_16k.name,
+        help=f"Use {models.GPT35_16k.name} model for the main chat (gpt-4 is better)",
+    )
+    core_group.add_argument(
+        "--voice-language",
+        metavar="VOICE_LANGUAGE",
+        default="en",
+        help="Specify the language for voice using ISO 639-1 code (default: auto)",
+    )
+    ##########
+    model_group = parser.add_argument_group("Advanced Model Settings")
+    model_group.add_argument(
+        "--openai-api-base",
+        metavar="OPENAI_API_BASE",
+        help="Specify the openai.api_base (default: https://api.openai.com/v1)",
+    )
+    model_group.add_argument(
+        "--openai-api-type",
+        metavar="OPENAI_API_TYPE",
+        help="Specify the openai.api_type",
+    )
+    model_group.add_argument(
+        "--openai-api-version",
+        metavar="OPENAI_API_VERSION",
+        help="Specify the openai.api_version",
+    )
+    model_group.add_argument(
+        "--openai-api-deployment-id",
+        metavar="OPENAI_API_DEPLOYMENT_ID",
+        help="Specify the deployment_id arg to be passed to openai.ChatCompletion.create()",
+    )
+    model_group.add_argument(
+        "--openai-api-engine",
+        metavar="OPENAI_API_ENGINE",
+        help="Specify the engine arg to be passed to openai.ChatCompletion.create()",
+    )
+    model_group.add_argument(
+        "--edit-format",
+        metavar="EDIT_FORMAT",
+        default=None,
+        help="Specify what edit format GPT should use (default depends on model)",
+    )
+    model_group.add_argument(
+        "--map-tokens",
+        type=int,
+        default=1024,
+        help="Max number of tokens to use for repo map, use 0 to disable (default: 1024)",
+    )
+    ##########
+    history_group = parser.add_argument_group("History Files")
+    default_input_history_file = (
+        os.path.join(git_root, ".aider.input.history") if git_root else ".aider.input.history"
+    )
+    default_chat_history_file = (
+        os.path.join(git_root, ".aider.chat.history.md") if git_root else ".aider.chat.history.md"
+    )
+    history_group.add_argument(
+        "--input-history-file",
+        metavar="INPUT_HISTORY_FILE",
+        default=default_input_history_file,
+        help=f"Specify the chat input history file (default: {default_input_history_file})",
+    )
+    history_group.add_argument(
+        "--chat-history-file",
+        metavar="CHAT_HISTORY_FILE",
+        default=default_chat_history_file,
+        help=f"Specify the chat history file (default: {default_chat_history_file})",
+    )
+    ##########
+    output_group = parser.add_argument_group("Output Settings")
+    output_group.add_argument(
+        "--dark-mode",
+        action="store_true",
+        help="Use colors suitable for a dark terminal background (default: False)",
+        default=False,
+    )
+    output_group.add_argument(
+        "--light-mode",
+        action="store_true",
+        help="Use colors suitable for a light terminal background (default: False)",
+        default=False,
+    )
+    output_group.add_argument(
+        "--pretty",
+        action="store_true",
+        default=True,
+        help="Enable pretty, colorized output (default: True)",
+    )
+    output_group.add_argument(
+        "--no-pretty",
+        action="store_false",
+        dest="pretty",
+        help="Disable pretty, colorized output",
+    )
+    output_group.add_argument(
+        "--no-stream",
+        action="store_false",
+        dest="stream",
+        default=True,
+        help="Disable streaming responses",
+    )
+    output_group.add_argument(
+        "--user-input-color",
+        default="#00cc00",
+        help="Set the color for user input (default: #00cc00)",
+    )
+    output_group.add_argument(
+        "--tool-output-color",
+        default=None,
+        help="Set the color for tool output (default: None)",
+    )
+    output_group.add_argument(
+        "--tool-error-color",
+        default="#FF2222",
+        help="Set the color for tool error messages (default: red)",
+    )
+    output_group.add_argument(
+        "--assistant-output-color",
+        default="#0088ff",
+        help="Set the color for assistant output (default: #0088ff)",
+    )
+    output_group.add_argument(
+        "--code-theme",
+        default="default",
+        help=(
+            "Set the markdown code theme (default: default, other options include monokai,"
+            " solarized-dark, solarized-light)"
+        ),
+    )
+    output_group.add_argument(
+        "--show-diffs",
+        action="store_true",
+        help="Show diffs when committing changes (default: False)",
+        default=False,
+    )
+    ##########
+    git_group = parser.add_argument_group("Git Settings")
+    git_group.add_argument(
+        "--no-git",
+        action="store_false",
+        dest="git",
+        default=True,
+        help="Do not look for a git repo",
+    )
+    git_group.add_argument(
+        "--auto-commits",
+        action="store_true",
+        dest="auto_commits",
+        default=True,
+        help="Enable auto commit of GPT changes (default: True)",
+    )
+    git_group.add_argument(
+        "--no-auto-commits",
+        action="store_false",
+        dest="auto_commits",
+        help="Disable auto commit of GPT changes (implies --no-dirty-commits)",
+    )
+    git_group.add_argument(
+        "--dirty-commits",
+        action="store_true",
+        dest="dirty_commits",
+        help="Enable commits when repo is found dirty",
+        default=True,
+    )
+    git_group.add_argument(
+        "--no-dirty-commits",
+        action="store_false",
+        dest="dirty_commits",
+        help="Disable commits when repo is found dirty",
+    )
+    git_group.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Perform a dry run without modifying files (default: False)",
+        default=False,
+    )
+    ##########
+    other_group = parser.add_argument_group("Other Settings")
+    other_group.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the version number and exit",
+    )
+    other_group.add_argument(
+        "--apply",
+        metavar="FILE",
+        help="Apply the changes from the given file instead of running the chat (debug)",
+    )
+    other_group.add_argument(
+        "--yes",
+        action="store_true",
+        help="Always say yes to every confirmation",
+        default=None,
+    )
+    other_group.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+        default=False,
+    )
+    other_group.add_argument(
+        "--show-repo-map",
+        action="store_true",
+        help="Print the repo map and exit (debug)",
+        default=False,
+    )
+    other_group.add_argument(
+        "--message",
+        "--msg",
+        "-m",
+        metavar="COMMAND",
+        help="Specify a single message to send GPT, process reply then exit (disables chat mode)",
+    )
+    other_group.add_argument(
+        "-c",
+        "--config",
+        is_config_file=True,
+        metavar="CONFIG_FILE",
+        help=(
+            "Specify the config file (default: search for .aider.conf.yml in git root, cwd"
+            " or home directory)"
+        ),
+    )
+    args = parser.parse_args(argv)
+    if args.dark_mode:
+        args.user_input_color = "#32FF32"
+        args.tool_error_color = "#FF3333"
+        args.assistant_output_color = "#00FFFF"
+        args.code_theme = "monokai"
+    if args.light_mode:
+        args.user_input_color = "green"
+        args.tool_error_color = "red"
+        args.assistant_output_color = "blue"
+        args.code_theme = "default"
+    io = InputOutput(
+        args.pretty,
+        args.yes,
+        args.input_history_file,
+        args.chat_history_file,
+        input=input,
+        output=output,
+        user_input_color=args.user_input_color,
+        tool_output_color=args.tool_output_color,
+        tool_error_color=args.tool_error_color,
+        dry_run=args.dry_run,
+    )
+    fnames = [str(Path(fn).resolve()) for fn in args.files]
+    if len(args.files) > 1:
+        good = True
+        for fname in args.files:
+            if Path(fname).is_dir():
+                io.tool_error(f"{fname} is a directory, not provided alone.")
+                good = False
+        if not good:
+            io.tool_error(
+                "Provide either a single directory of a git repo, or a list of one or more files."
+            )
+            return 1
+    git_dname = None
+    if len(args.files) == 1:
+        if Path(args.files[0]).is_dir():
+            if args.git:
+                git_dname = str(Path(args.files[0]).resolve())
+                fnames = []
+            else:
+                io.tool_error(f"{args.files[0]} is a directory, but --no-git selected.")
+                return 1
+    # We can't know the git repo for sure until after parsing the args.
+    # If we guessed wrong, reparse because that changes things like
+    # the location of the config.yml and history files.
+    if args.git and not force_git_root:
+        right_repo_root = guessed_wrong_repo(io, git_root, fnames, git_dname)
+        if right_repo_root:
+            return main(argv, input, output, right_repo_root)
+    io.tool_output(f"Aider v{__version__}")
+    check_version(io.tool_error)
+    if "VSCODE_GIT_IPC_HANDLE" in os.environ:
+        args.pretty = False
+        io.tool_output("VSCode terminal detected, pretty output has been disabled.")
+    if args.git:
+        git_root = setup_git(git_root, io)
+        check_gitignore(git_root, io)
+    def scrub_sensitive_info(text):
+        # Replace sensitive information with placeholder
+        return text.replace(args.openai_api_key, "***")
+    if args.verbose:
+        show = scrub_sensitive_info(parser.format_values())
+        io.tool_output(show)
+        io.tool_output("Option settings:")
+        for arg, val in sorted(vars(args).items()):
+            io.tool_output(f"  - {arg}: {scrub_sensitive_info(str(val))}")
+    io.tool_output(*sys.argv, log_only=True)
+    if not args.openai_api_key:
+        if os.name == "nt":
+            io.tool_error(
+                "No OpenAI API key provided. Use --openai-api-key or setx OPENAI_API_KEY."
+            )
+        else:
+            io.tool_error(
+                "No OpenAI API key provided. Use --openai-api-key or export OPENAI_API_KEY."
+            )
+        return 1
+    main_model = models.Model(args.model)
+    openai.api_key = args.openai_api_key
+    for attr in ("base", "type", "version", "deployment_id", "engine"):
+        arg_key = f"openai_api_{attr}"
+        val = getattr(args, arg_key)
+        if val is not None:
+            mod_key = f"api_{attr}"
+            setattr(openai, mod_key, val)
+            io.tool_output(f"Setting openai.{mod_key}={val}")
+    try:
+        coder = Coder.create(
+            main_model,
+            args.edit_format,
+            io,
+            ##
+            fnames=fnames,
+            git_dname=git_dname,
+            pretty=args.pretty,
+            show_diffs=args.show_diffs,
+            auto_commits=args.auto_commits,
+            dirty_commits=args.dirty_commits,
+            dry_run=args.dry_run,
+            map_tokens=args.map_tokens,
+            verbose=args.verbose,
+            assistant_output_color=args.assistant_output_color,
+            code_theme=args.code_theme,
+            stream=args.stream,
+            use_git=args.git,
+            voice_language=args.voice_language,
+        )
+    except ValueError as err:
+        io.tool_error(str(err))
+        return 1
+    if args.show_repo_map:
+        repo_map = coder.get_repo_map()
+        if repo_map:
+            io.tool_output(repo_map)
+        return
+    if args.apply:
+        content = io.read_text(args.apply)
+        if content is None:
+            return
+        coder.partial_response_content = content
+        coder.apply_updates()
+        return
+    io.tool_output("Use /help to see in-chat commands, run with --help to see cmd line args")
+    coder.dirty_commit()
+    if args.message:
+        io.tool_output()
+        coder.run(with_message=args.message)
+    else:
+        coder.run()
+if __name__ == "__main__":
+    status = main()
+    sys.exit(status)

testbed/Aider-AI__aider/aider/models.py ADDED Viewed

	@@ -0,0 +1,76 @@

+import re
+known_tokens = {
+    "gpt-3.5-turbo": 4,
+    "gpt-4": 8,
+}
+class Model:
+    always_available = False
+    use_repo_map = False
+    send_undo_reply = False
+    prompt_price = None
+    completion_price = None
+    def __init__(self, name):
+        self.name = name
+        tokens = None
+        match = re.search(r"-([0-9]+)k", name)
+        if match:
+            tokens = int(match.group(1))
+        else:
+            for m, t in known_tokens.items():
+                if name.startswith(m):
+                    tokens = t
+        if tokens is None:
+            raise ValueError(f"Unknown context window size for model: {name}")
+        self.max_context_tokens = tokens * 1024
+        if self.is_gpt4():
+            self.edit_format = "diff"
+            self.use_repo_map = True
+            self.send_undo_reply = True
+            if tokens == 8:
+                self.prompt_price = 0.03
+                self.completion_price = 0.06
+            elif tokens == 32:
+                self.prompt_price = 0.06
+                self.completion_price = 0.12
+            return
+        if self.is_gpt35():
+            self.edit_format = "whole"
+            self.always_available = True
+            if tokens == 4:
+                self.prompt_price = 0.0015
+                self.completion_price = 0.002
+            elif tokens == 16:
+                self.prompt_price = 0.003
+                self.completion_price = 0.004
+            return
+        raise ValueError(f"Unsupported model: {name}")
+    def is_gpt4(self):
+        return self.name.startswith("gpt-4")
+    def is_gpt35(self):
+        return self.name.startswith("gpt-3.5-turbo")
+    def __str__(self):
+        return self.name
+GPT4 = Model("gpt-4")
+GPT35 = Model("gpt-3.5-turbo")
+GPT35_16k = Model("gpt-3.5-turbo-16k")

testbed/Aider-AI__aider/aider/prompts.py ADDED Viewed

	@@ -0,0 +1,44 @@

+# flake8: noqa: E501
+# COMMIT
+commit_system = """You are an expert software engineer.
+Review the provided context and diffs which are about to be committed to a git repo.
+Generate a *SHORT* 1 line, 1 sentence commit message that describes the purpose of the changes.
+The commit message MUST be in the past tense.
+It must describe the changes *which have been made* in the diffs!
+Reply with JUST the commit message, without quotes, comments, questions, etc!
+"""
+# COMMANDS
+undo_command_reply = "I did `git reset --hard HEAD~1` to discard the last edits."
+added_files = "I added these *read-write* files: {fnames}"
+run_output = """I ran this command:
+{command}
+And got this output:
+{output}
+"""
+# CHAT HISTORY
+summarize = """*Briefly* summarize this partial conversation about programming.
+Include less detail about older parts and more detail about the most recent messages.
+Start a new paragraph every time the topic changes!
+This is only part of a longer conversation so *DO NOT* conclude the summary with language like "Finally, ...". Because the conversation continues after the summary.
+The summary *MUST* include the function names, libraries, packages that are being discussed.
+The summary *MUST* include the filenames that are being referenced by the assistant inside the ```...``` fenced code blocks!
+The summaries *MUST NOT* include ```...``` fenced code blocks!
+Phrase the summary with the USER in first person, telling the ASSISTANT about the conversation.
+Write *as* the user.
+The user should refer to the assistant as *you*.
+Start the summary with "I asked you...".
+"""
+summary_prefix = "I spoke to you previously about a number of things.\n"

testbed/Aider-AI__aider/aider/repo.py ADDED Viewed

	@@ -0,0 +1,194 @@

+import os
+from pathlib import Path, PurePosixPath
+import git
+from aider import models, prompts, utils
+from aider.sendchat import simple_send_with_retries
+from .dump import dump  # noqa: F401
+class GitRepo:
+    repo = None
+    def __init__(self, io, fnames, git_dname):
+        self.io = io
+        if git_dname:
+            check_fnames = [git_dname]
+        elif fnames:
+            check_fnames = fnames
+        else:
+            check_fnames = ["."]
+        repo_paths = []
+        for fname in check_fnames:
+            fname = Path(fname)
+            fname = fname.resolve()
+            if not fname.exists() and fname.parent.exists():
+                fname = fname.parent
+            try:
+                repo_path = git.Repo(fname, search_parent_directories=True).working_dir
+                repo_path = utils.safe_abs_path(repo_path)
+                repo_paths.append(repo_path)
+            except git.exc.InvalidGitRepositoryError:
+                pass
+        num_repos = len(set(repo_paths))
+        if num_repos == 0:
+            raise FileNotFoundError
+        if num_repos > 1:
+            self.io.tool_error("Files are in different git repos.")
+            raise FileNotFoundError
+        # https://github.com/gitpython-developers/GitPython/issues/427
+        self.repo = git.Repo(repo_paths.pop(), odbt=git.GitDB)
+        self.root = utils.safe_abs_path(self.repo.working_tree_dir)
+    def add_new_files(self, fnames):
+        cur_files = [str(Path(fn).resolve()) for fn in self.get_tracked_files()]
+        for fname in fnames:
+            if str(Path(fname).resolve()) in cur_files:
+                continue
+            if not Path(fname).exists():
+                continue
+            self.io.tool_output(f"Adding {fname} to git")
+            self.repo.git.add(fname)
+    def commit(self, context=None, prefix=None, message=None):
+        if not self.repo.is_dirty():
+            return
+        if message:
+            commit_message = message
+        else:
+            diffs = self.get_diffs(False)
+            commit_message = self.get_commit_message(diffs, context)
+        if not commit_message:
+            commit_message = "(no commit message provided)"
+        if prefix:
+            commit_message = prefix + commit_message
+        full_commit_message = commit_message
+        if context:
+            full_commit_message += "\n\n# Aider chat conversation:\n\n" + context
+        self.repo.git.commit("-a", "-m", full_commit_message, "--no-verify")
+        commit_hash = self.repo.head.commit.hexsha[:7]
+        self.io.tool_output(f"Commit {commit_hash} {commit_message}")
+        return commit_hash, commit_message
+    def get_rel_repo_dir(self):
+        try:
+            return os.path.relpath(self.repo.git_dir, os.getcwd())
+        except ValueError:
+            return self.repo.git_dir
+    def get_commit_message(self, diffs, context):
+        if len(diffs) >= 4 * 1024 * 4:
+            self.io.tool_error(
+                f"Diff is too large for {models.GPT35.name} to generate a commit message."
+            )
+            return
+        diffs = "# Diffs:\n" + diffs
+        content = ""
+        if context:
+            content += context + "\n"
+        content += diffs
+        messages = [
+            dict(role="system", content=prompts.commit_system),
+            dict(role="user", content=content),
+        ]
+        for model in [models.GPT35.name, models.GPT35_16k.name]:
+            commit_message = simple_send_with_retries(model, messages)
+            if commit_message:
+                break
+        if not commit_message:
+            self.io.tool_error("Failed to generate commit message!")
+            return
+        commit_message = commit_message.strip()
+        if commit_message and commit_message[0] == '"' and commit_message[-1] == '"':
+            commit_message = commit_message[1:-1].strip()
+        return commit_message
+    def get_diffs(self, pretty, *args):
+        args = list(args)
+        # if args are specified, just add --pretty if needed
+        if args:
+            if pretty:
+                args = ["--color"] + args
+            return self.repo.git.diff(*args)
+        # otherwise, we always want diffs of index and working dir
+        try:
+            commits = self.repo.iter_commits(self.repo.active_branch)
+            current_branch_has_commits = any(commits)
+        except git.exc.GitCommandError:
+            current_branch_has_commits = False
+        if pretty:
+            args = ["--color"]
+        if current_branch_has_commits:
+            # if there is a HEAD, just diff against it to pick up index + working
+            args += ["HEAD"]
+            return self.repo.git.diff(*args)
+        # diffs in the index
+        diffs = self.repo.git.diff(*(args + ["--cached"]))
+        # plus, diffs in the working dir
+        diffs += self.repo.git.diff(*args)
+        return diffs
+    def show_diffs(self, pretty):
+        diffs = self.get_diffs(pretty)
+        print(diffs)
+    def get_tracked_files(self):
+        if not self.repo:
+            return []
+        try:
+            commit = self.repo.head.commit
+        except ValueError:
+            commit = None
+        files = []
+        if commit:
+            for blob in commit.tree.traverse():
+                if blob.type == "blob":  # blob is a file
+                    files.append(blob.path)
+        # Add staged files
+        index = self.repo.index
+        staged_files = [path for path, _ in index.entries.keys()]
+        files.extend(staged_files)
+        # convert to appropriate os.sep, since git always normalizes to /
+        res = set(
+            str(Path(PurePosixPath((Path(self.root) / path).relative_to(self.root))))
+            for path in files
+        )
+        return res
+    def is_dirty(self):
+        return self.repo.is_dirty()

testbed/Aider-AI__aider/aider/repomap.py ADDED Viewed

	@@ -0,0 +1,471 @@

+import colorsys
+import json
+import os
+import random
+import subprocess
+import sys
+import tempfile
+from collections import Counter, defaultdict
+from pathlib import Path
+import networkx as nx
+import tiktoken
+from diskcache import Cache
+from pygments.lexers import guess_lexer_for_filename
+from pygments.token import Token
+from pygments.util import ClassNotFound
+from tqdm import tqdm
+from aider import models
+from .dump import dump  # noqa: F402
+def to_tree(tags):
+    if not tags:
+        return ""
+    tags = sorted(tags)
+    output = ""
+    last = [None] * len(tags[0])
+    tab = "\t"
+    for tag in tags:
+        tag = list(tag)
+        for i in range(len(last) + 1):
+            if i == len(last):
+                break
+            if last[i] != tag[i]:
+                break
+        num_common = i
+        indent = tab * num_common
+        rest = tag[num_common:]
+        for item in rest:
+            output += indent + item + "\n"
+            indent += tab
+        last = tag
+    return output
+def fname_to_components(fname, with_colon):
+    path_components = fname.split(os.sep)
+    res = [pc + os.sep for pc in path_components[:-1]]
+    if with_colon:
+        res.append(path_components[-1] + ":")
+    else:
+        res.append(path_components[-1])
+    return res
+class RepoMap:
+    CACHE_VERSION = 1
+    ctags_cmd = [
+        "ctags",
+        "--fields=+S",
+        "--extras=-F",
+        "--output-format=json",
+        "--output-encoding=utf-8",
+    ]
+    IDENT_CACHE_DIR = f".aider.ident.cache.v{CACHE_VERSION}"
+    TAGS_CACHE_DIR = f".aider.tags.cache.v{CACHE_VERSION}"
+    ctags_disabled_reason = "ctags not initialized"
+    cache_missing = False
+    def __init__(
+        self,
+        map_tokens=1024,
+        root=None,
+        main_model=models.GPT4,
+        io=None,
+        repo_content_prefix=None,
+        verbose=False,
+    ):
+        self.io = io
+        self.verbose = verbose
+        if not root:
+            root = os.getcwd()
+        self.root = root
+        self.load_ident_cache()
+        self.load_tags_cache()
+        self.max_map_tokens = map_tokens
+        self.has_ctags = self.check_for_ctags()
+        if map_tokens > 0 and self.has_ctags:
+            self.use_ctags = True
+        else:
+            self.use_ctags = False
+        self.tokenizer = tiktoken.encoding_for_model(main_model.name)
+        self.repo_content_prefix = repo_content_prefix
+    def get_repo_map(self, chat_files, other_files):
+        res = self.choose_files_listing(chat_files, other_files)
+        if not res:
+            return
+        files_listing, ctags_msg = res
+        if chat_files:
+            other = "other "
+        else:
+            other = ""
+        if self.repo_content_prefix:
+            repo_content = self.repo_content_prefix.format(
+                other=other,
+                ctags_msg=ctags_msg,
+            )
+        else:
+            repo_content = ""
+        repo_content += files_listing
+        return repo_content
+    def choose_files_listing(self, chat_files, other_files):
+        if self.max_map_tokens <= 0:
+            return
+        if not other_files:
+            return
+        if self.use_ctags:
+            files_listing = self.get_ranked_tags_map(chat_files, other_files)
+            if files_listing:
+                num_tokens = self.token_count(files_listing)
+                if self.verbose:
+                    self.io.tool_output(f"ctags map: {num_tokens/1024:.1f} k-tokens")
+                ctags_msg = " with selected ctags info"
+                return files_listing, ctags_msg
+        files_listing = self.get_simple_files_map(other_files)
+        ctags_msg = ""
+        num_tokens = self.token_count(files_listing)
+        if self.verbose:
+            self.io.tool_output(f"simple map: {num_tokens/1024:.1f} k-tokens")
+        if num_tokens < self.max_map_tokens:
+            return files_listing, ctags_msg
+    def get_simple_files_map(self, other_files):
+        fnames = []
+        for fname in other_files:
+            fname = self.get_rel_fname(fname)
+            fname = fname_to_components(fname, False)
+            fnames.append(fname)
+        return to_tree(fnames)
+    def token_count(self, string):
+        return len(self.tokenizer.encode(string))
+    def get_rel_fname(self, fname):
+        return os.path.relpath(fname, self.root)
+    def split_path(self, path):
+        path = os.path.relpath(path, self.root)
+        return [path + ":"]
+    def run_ctags(self, filename):
+        # Check if the file is in the cache and if the modification time has not changed
+        file_mtime = self.get_mtime(filename)
+        if file_mtime is None:
+            return []
+        cache_key = filename
+        if cache_key in self.TAGS_CACHE and self.TAGS_CACHE[cache_key]["mtime"] == file_mtime:
+            return self.TAGS_CACHE[cache_key]["data"]
+        cmd = self.ctags_cmd + [
+            f"--input-encoding={self.io.encoding}",
+            filename,
+        ]
+        output = subprocess.check_output(cmd, stderr=subprocess.PIPE).decode("utf-8")
+        output_lines = output.splitlines()
+        data = []
+        for line in output_lines:
+            try:
+                data.append(json.loads(line))
+            except json.decoder.JSONDecodeError as err:
+                self.io.tool_error(f"Error parsing ctags output: {err}")
+                self.io.tool_error(repr(line))
+        # Update the cache
+        self.TAGS_CACHE[cache_key] = {"mtime": file_mtime, "data": data}
+        self.save_tags_cache()
+        return data
+    def check_for_ctags(self):
+        try:
+            executable = self.ctags_cmd[0]
+            cmd = [executable, "--version"]
+            output = subprocess.check_output(cmd, stderr=subprocess.PIPE).decode("utf-8")
+            output = output.lower()
+            cmd = " ".join(cmd)
+            if "universal ctags" not in output:
+                self.ctags_disabled_reason = f"{cmd} does not claim to be universal ctags"
+                return
+            if "+json" not in output:
+                self.ctags_disabled_reason = f"{cmd} does not list +json support"
+                return
+            with tempfile.TemporaryDirectory() as tempdir:
+                hello_py = os.path.join(tempdir, "hello.py")
+                with open(hello_py, "w", encoding="utf-8") as f:
+                    f.write("def hello():\n    print('Hello, world!')\n")
+                self.run_ctags(hello_py)
+        except FileNotFoundError:
+            self.ctags_disabled_reason = f"{executable} executable not found"
+            return
+        except Exception as err:
+            self.ctags_disabled_reason = f"error running universal-ctags: {err}"
+            return
+        return True
+    def load_tags_cache(self):
+        path = Path(self.root) / self.TAGS_CACHE_DIR
+        if not path.exists():
+            self.cache_missing = True
+        self.TAGS_CACHE = Cache(path)
+    def save_tags_cache(self):
+        pass
+    def load_ident_cache(self):
+        path = Path(self.root) / self.IDENT_CACHE_DIR
+        if not path.exists():
+            self.cache_missing = True
+        self.IDENT_CACHE = Cache(path)
+    def save_ident_cache(self):
+        pass
+    def get_mtime(self, fname):
+        try:
+            return os.path.getmtime(fname)
+        except FileNotFoundError:
+            self.io.tool_error(f"File not found error: {fname}")
+    def get_name_identifiers(self, fname, uniq=True):
+        file_mtime = self.get_mtime(fname)
+        if file_mtime is None:
+            return set()
+        cache_key = fname
+        if cache_key in self.IDENT_CACHE and self.IDENT_CACHE[cache_key]["mtime"] == file_mtime:
+            idents = self.IDENT_CACHE[cache_key]["data"]
+        else:
+            idents = self.get_name_identifiers_uncached(fname)
+            self.IDENT_CACHE[cache_key] = {"mtime": file_mtime, "data": idents}
+            self.save_ident_cache()
+        if uniq:
+            idents = set(idents)
+        return idents
+    def get_name_identifiers_uncached(self, fname):
+        content = self.io.read_text(fname)
+        if content is None:
+            return list()
+        try:
+            lexer = guess_lexer_for_filename(fname, content)
+        except ClassNotFound:
+            return list()
+        # lexer.get_tokens_unprocessed() returns (char position in file, token type, token string)
+        tokens = list(lexer.get_tokens_unprocessed(content))
+        res = [token[2] for token in tokens if token[1] in Token.Name]
+        return res
+    def get_ranked_tags(self, chat_fnames, other_fnames):
+        defines = defaultdict(set)
+        references = defaultdict(list)
+        definitions = defaultdict(set)
+        personalization = dict()
+        fnames = set(chat_fnames).union(set(other_fnames))
+        chat_rel_fnames = set()
+        fnames = sorted(fnames)
+        if self.cache_missing:
+            fnames = tqdm(fnames)
+        self.cache_missing = False
+        for fname in fnames:
+            if not Path(fname).is_file():
+                self.io.tool_error(f"Repo-map can't include {fname}")
+                continue
+            # dump(fname)
+            rel_fname = os.path.relpath(fname, self.root)
+            if fname in chat_fnames:
+                personalization[rel_fname] = 1.0
+                chat_rel_fnames.add(rel_fname)
+            data = self.run_ctags(fname)
+            for tag in data:
+                ident = tag["name"]
+                defines[ident].add(rel_fname)
+                scope = tag.get("scope")
+                kind = tag.get("kind")
+                name = tag.get("name")
+                signature = tag.get("signature")
+                last = name
+                if signature:
+                    last += " " + signature
+                res = [rel_fname]
+                if scope:
+                    res.append(scope)
+                res += [kind, last]
+                key = (rel_fname, ident)
+                definitions[key].add(tuple(res))
+                # definitions[key].add((rel_fname,))
+            idents = self.get_name_identifiers(fname, uniq=False)
+            for ident in idents:
+                # dump("ref", fname, ident)
+                references[ident].append(rel_fname)
+        idents = set(defines.keys()).intersection(set(references.keys()))
+        G = nx.MultiDiGraph()
+        for ident in idents:
+            definers = defines[ident]
+            for referencer, num_refs in Counter(references[ident]).items():
+                for definer in definers:
+                    if referencer == definer:
+                        continue
+                    G.add_edge(referencer, definer, weight=num_refs, ident=ident)
+        if personalization:
+            pers_args = dict(personalization=personalization, dangling=personalization)
+        else:
+            pers_args = dict()
+        try:
+            ranked = nx.pagerank(G, weight="weight", **pers_args)
+        except ZeroDivisionError:
+            return []
+        # distribute the rank from each source node, across all of its out edges
+        ranked_definitions = defaultdict(float)
+        for src in G.nodes:
+            src_rank = ranked[src]
+            total_weight = sum(data["weight"] for _src, _dst, data in G.out_edges(src, data=True))
+            # dump(src, src_rank, total_weight)
+            for _src, dst, data in G.out_edges(src, data=True):
+                data["rank"] = src_rank * data["weight"] / total_weight
+                ident = data["ident"]
+                ranked_definitions[(dst, ident)] += data["rank"]
+        ranked_tags = []
+        ranked_definitions = sorted(ranked_definitions.items(), reverse=True, key=lambda x: x[1])
+        for (fname, ident), rank in ranked_definitions:
+            # print(f"{rank:.03f} {fname} {ident}")
+            if fname in chat_rel_fnames:
+                continue
+            ranked_tags += list(definitions.get((fname, ident), []))
+        rel_other_fnames_without_tags = set(
+            os.path.relpath(fname, self.root) for fname in other_fnames
+        )
+        fnames_already_included = set(rt[0] for rt in ranked_tags)
+        top_rank = sorted([(rank, node) for (node, rank) in ranked.items()], reverse=True)
+        for rank, fname in top_rank:
+            if fname in rel_other_fnames_without_tags:
+                rel_other_fnames_without_tags.remove(fname)
+            if fname not in fnames_already_included:
+                ranked_tags.append((fname,))
+        for fname in rel_other_fnames_without_tags:
+            ranked_tags.append((fname,))
+        return ranked_tags
+    def get_ranked_tags_map(self, chat_fnames, other_fnames=None):
+        if not other_fnames:
+            other_fnames = list()
+        ranked_tags = self.get_ranked_tags(chat_fnames, other_fnames)
+        num_tags = len(ranked_tags)
+        lower_bound = 0
+        upper_bound = num_tags
+        best_tree = None
+        while lower_bound <= upper_bound:
+            middle = (lower_bound + upper_bound) // 2
+            tree = to_tree(ranked_tags[:middle])
+            num_tokens = self.token_count(tree)
+            # dump(middle, num_tokens)
+            if num_tokens < self.max_map_tokens:
+                best_tree = tree
+                lower_bound = middle + 1
+            else:
+                upper_bound = middle - 1
+        return best_tree
+def find_py_files(directory):
+    if not os.path.isdir(directory):
+        return [directory]
+    py_files = []
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".py"):
+                py_files.append(os.path.join(root, file))
+    return py_files
+def get_random_color():
+    hue = random.random()
+    r, g, b = [int(x * 255) for x in colorsys.hsv_to_rgb(hue, 1, 0.75)]
+    res = f"#{r:02x}{g:02x}{b:02x}"
+    return res
+if __name__ == "__main__":
+    fnames = sys.argv[1:]
+    chat_fnames = []
+    other_fnames = []
+    for dname in sys.argv[1:]:
+        if ".venv" in dname:
+            other_fnames += find_py_files(dname)
+        else:
+            chat_fnames += find_py_files(dname)
+    root = os.path.commonpath(chat_fnames)
+    rm = RepoMap(root=root)
+    repo_map = rm.get_ranked_tags_map(chat_fnames, other_fnames)
+    dump(len(repo_map))
+    print(repo_map)

testbed/Aider-AI__aider/aider/sendchat.py ADDED Viewed

	@@ -0,0 +1,79 @@

+import hashlib
+import json
+import backoff
+import openai
+import requests
+# from diskcache import Cache
+from openai.error import (
+    APIConnectionError,
+    APIError,
+    RateLimitError,
+    ServiceUnavailableError,
+    Timeout,
+)
+CACHE_PATH = "~/.aider.send.cache.v1"
+CACHE = None
+# CACHE = Cache(CACHE_PATH)
+@backoff.on_exception(
+    backoff.expo,
+    (
+        Timeout,
+        APIError,
+        ServiceUnavailableError,
+        RateLimitError,
+        APIConnectionError,
+        requests.exceptions.ConnectionError,
+    ),
+    max_tries=10,
+    on_backoff=lambda details: print(
+        f"{details.get('exception','Exception')}\nRetry in {details['wait']:.1f} seconds."
+    ),
+)
+def send_with_retries(model, messages, functions, stream):
+    kwargs = dict(
+        model=model,
+        messages=messages,
+        temperature=0,
+        stream=stream,
+    )
+    if functions is not None:
+        kwargs["functions"] = functions
+    # we are abusing the openai object to stash these values
+    if hasattr(openai, "api_deployment_id"):
+        kwargs["deployment_id"] = openai.api_deployment_id
+    if hasattr(openai, "api_engine"):
+        kwargs["engine"] = openai.api_engine
+    key = json.dumps(kwargs, sort_keys=True).encode()
+    # Generate SHA1 hash of kwargs and append it to chat_completion_call_hashes
+    hash_object = hashlib.sha1(key)
+    if not stream and CACHE is not None and key in CACHE:
+        return hash_object, CACHE[key]
+    res = openai.ChatCompletion.create(**kwargs)
+    if not stream and CACHE is not None:
+        CACHE[key] = res
+    return hash_object, res
+def simple_send_with_retries(model, messages):
+    try:
+        _hash, response = send_with_retries(
+            model=model,
+            messages=messages,
+            functions=None,
+            stream=False,
+        )
+        return response.choices[0].message.content
+    except (AttributeError, openai.error.InvalidRequestError):
+        return

testbed/Aider-AI__aider/aider/utils.py ADDED Viewed

	@@ -0,0 +1,27 @@

+from pathlib import Path
+from .dump import dump  # noqa: F401
+def safe_abs_path(res):
+    "Gives an abs path, which safely returns a full (not 8.3) windows path"
+    res = Path(res).resolve()
+    return str(res)
+def show_messages(messages, title=None, functions=None):
+    if title:
+        print(title.upper(), "*" * 50)
+    for msg in messages:
+        role = msg["role"].upper()
+        content = msg.get("content")
+        if content:
+            for line in content.splitlines():
+                print(role, line)
+        content = msg.get("function_call")
+        if content:
+            print(role, content)
+    if functions:
+        dump(functions)

testbed/Aider-AI__aider/aider/versioncheck.py ADDED Viewed

	@@ -0,0 +1,27 @@

+import sys
+import packaging.version
+import requests
+import aider
+def check_version(print_cmd):
+    try:
+        response = requests.get("https://pypi.org/pypi/aider-chat/json")
+        data = response.json()
+        latest_version = data["info"]["version"]
+        current_version = aider.__version__
+        if packaging.version.parse(latest_version) <= packaging.version.parse(current_version):
+            return
+        print_cmd(f"Newer version v{latest_version} is available. To upgrade, run:")
+        py = sys.executable
+        print_cmd(f"{py} -m pip install --upgrade aider-chat")
+    except Exception as err:
+        print_cmd(f"Error checking pypi for new version: {err}")
+if __name__ == "__main__":
+    check_version(print)

testbed/Aider-AI__aider/aider/voice.py ADDED Viewed

	@@ -0,0 +1,90 @@

+import os
+import queue
+import tempfile
+import time
+import numpy as np
+import openai
+from prompt_toolkit.shortcuts import prompt
+try:
+    import sounddevice as sd
+except OSError:
+    sd = None
+import soundfile as sf
+from .dump import dump  # noqa: F401
+class Voice:
+    max_rms = 0
+    min_rms = 1e5
+    pct = 0
+    threshold = 0.15
+    def is_audio_available(self):
+        return sd is not None
+    def callback(self, indata, frames, time, status):
+        """This is called (from a separate thread) for each audio block."""
+        rms = np.sqrt(np.mean(indata**2))
+        self.max_rms = max(self.max_rms, rms)
+        self.min_rms = min(self.min_rms, rms)
+        rng = self.max_rms - self.min_rms
+        if rng > 0.001:
+            self.pct = (rms - self.min_rms) / rng
+        else:
+            self.pct = 0.5
+        self.q.put(indata.copy())
+    def get_prompt(self):
+        num = 10
+        if np.isnan(self.pct) or self.pct < self.threshold:
+            cnt = 0
+        else:
+            cnt = int(self.pct * 10)
+        bar = "░" * cnt + "█" * (num - cnt)
+        bar = bar[:num]
+        dur = time.time() - self.start_time
+        return f"Recording, press ENTER when done... {dur:.1f}sec {bar}"
+    def record_and_transcribe(self, history=None, language=None):
+        try:
+            return self.raw_record_and_transcribe(history, language)
+        except KeyboardInterrupt:
+            return
+    def raw_record_and_transcribe(self, history, language):
+        self.q = queue.Queue()
+        filename = tempfile.mktemp(suffix=".wav")
+        sample_rate = 16000  # 16kHz
+        self.start_time = time.time()
+        with sd.InputStream(samplerate=sample_rate, channels=1, callback=self.callback):
+            prompt(self.get_prompt, refresh_interval=0.1)
+        with sf.SoundFile(filename, mode="x", samplerate=sample_rate, channels=1) as file:
+            while not self.q.empty():
+                file.write(self.q.get())
+        with open(filename, "rb") as fh:
+            transcript = openai.Audio.transcribe("whisper-1", fh, prompt=history, language=language)
+        text = transcript["text"]
+        return text
+if __name__ == "__main__":
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("Please set the OPENAI_API_KEY environment variable.")
+    print(Voice().record_and_transcribe())

testbed/Aider-AI__aider/assets/benchmarks.svg ADDED Viewed

testbed/Aider-AI__aider/assets/css/style.scss ADDED Viewed

	@@ -0,0 +1,67 @@

+---
+---
+@import "{{ site.theme }}";
+.btn {
+  display: inline-block;
+  width: auto;
+}
+.btn + .btn {
+  margin-top: 0;
+  margin-left: 0.75rem;
+}
+.chat-transcript {
+    font-family: 'Courier New', Courier, monospace;
+    background-color: #000;
+    color: #0f0;
+    padding: 1em 1em 1em 1em;
+    border-radius: 5px;
+}
+.chat-transcript blockquote {
+    padding: 0;
+    margin-left: 0;
+    color: #819198;
+    border-left: none
+}
+.chat-transcript blockquote>:first-child {
+    margin-top: 0
+}
+.chat-transcript blockquote>:last-child {
+    margin-bottom: 0
+}
+.chat-transcript li,
+.chat-transcript p {
+    color: #00FFFF;
+}
+.chat-transcript h1 {
+    display: none;
+}
+.chat-transcript h4 {
+    color: #32FF32;
+    border-top: 1px solid #32FF32;
+    padding-top: 10px;
+}
+.chat-transcript h4::before {
+    content: '> ';
+}
+.chat-transcript blockquote p {
+    color: #ffffff;
+}
+.chat-transcript::before {
+    content: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="90" height="25"><circle cx="7" cy="15" r="7" fill="%23f92672"/><circle cx="27" cy="15" r="7" fill="%23f4bf75"/><circle cx="47" cy="15" r="7" fill="%23a6e22e"/></svg>');
+    display: block;
+    margin-bottom: 0;
+    position: relative;
+    top: -0.5em;
+}

testbed/Aider-AI__aider/assets/screencast.svg ADDED Viewed

testbed/Aider-AI__aider/benchmark/__init__.py ADDED Viewed

File without changes

testbed/Aider-AI__aider/benchmark/benchmark.py ADDED Viewed

	@@ -0,0 +1,696 @@

+#!/usr/bin/env python
+import datetime
+import json
+import os
+import random
+import re
+import shutil
+import subprocess
+import time
+from collections import defaultdict
+from json.decoder import JSONDecodeError
+from pathlib import Path
+from types import SimpleNamespace
+from typing import List
+import git
+import lox
+import matplotlib.pyplot as plt
+import numpy as np
+import openai
+import pandas as pd
+import prompts
+import typer
+from imgcat import imgcat
+from rich.console import Console
+from aider import models
+from aider.coders import Coder
+from aider.dump import dump  # noqa: F401
+from aider.io import InputOutput
+BENCHMARK_DNAME = Path(os.environ["AIDER_BENCHMARK_DIR"])
+ORIGINAL_DNAME = BENCHMARK_DNAME / "exercism-python"
+app = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
+def show_stats(dirnames):
+    raw_rows = []
+    for dirname in dirnames:
+        row = summarize_results(dirname)
+        raw_rows.append(row)
+    return
+    repeats = []
+    seen = dict()
+    rows = []
+    for row in raw_rows:
+        if not row:
+            continue
+        if row.model == "gpt-3.5-turbo":
+            row.model = "gpt-3.5-turbo-0613"
+        if row.edit_format == "diff-func-string":
+            row.edit_format = "diff-func"
+        if (
+            row.model == "gpt-3.5-turbo-0613"
+            and row.edit_format == "whole"
+            and "repeat" not in row.dir_name
+        ):
+            # remember this row, so we can update it with the repeat_avg
+            repeat_row = len(rows)
+        pieces = row.model.split("-")
+        row.model = "-".join(pieces[:3])
+        if pieces[3:]:
+            row.model += "\n-" + "-".join(pieces[3:])
+        if row.completed_tests < 133:
+            print(f"Warning: {row.dir_name} is incomplete: {row.completed_tests}")
+        if "repeat" in row.dir_name:
+            repeats.append(vars(row))
+            continue
+        kind = (row.model, row.edit_format)
+        if kind in seen:
+            dump(row.dir_name)
+            dump(seen[kind])
+            return
+        seen[kind] = row.dir_name
+        rows.append(vars(row))
+    if repeats:
+        extra = rows[repeat_row]
+        dump(extra)
+        repeats.append(extra)
+        repeats = pd.DataFrame.from_records(repeats)
+        repeat_max = repeats["pass_rate_2"].max()
+        repeat_min = repeats["pass_rate_2"].min()
+        repeat_avg = repeats["pass_rate_2"].mean()
+        repeat_lo = repeat_avg - repeat_min
+        repeat_hi = repeat_max - repeat_avg
+        dump(repeat_max)
+        dump(repeat_min)
+        dump(repeat_avg)
+        # use the average in the main bar
+        rows[repeat_row]["pass_rate_2"] = repeat_avg
+    df = pd.DataFrame.from_records(rows)
+    df.sort_values(by=["model", "edit_format"], inplace=True)
+    tries = [df.groupby(["model", "edit_format"])["pass_rate_2"].mean()]
+    if True:
+        tries += [df.groupby(["model", "edit_format"])["pass_rate_1"].mean()]
+    plt.rcParams["hatch.linewidth"] = 0.5
+    plt.rcParams["hatch.color"] = "#444444"
+    from matplotlib import rc
+    rc("font", **{"family": "sans-serif", "sans-serif": ["Helvetica"], "size": 10})
+    fig, ax = plt.subplots(figsize=(6, 4))
+    ax.grid(axis="y", zorder=0, lw=0.2)
+    zorder = 1
+    for grouped in tries:
+        zorder += 1
+        df = grouped.unstack()
+        num_models, num_formats = df.shape
+        pos = np.array(range(num_models))
+        width = 0.8 / num_formats
+        formats = df.columns
+        models = df.index
+        for i, fmt in enumerate(formats):
+            if zorder > 1:
+                edge = dict(
+                    edgecolor="#ffffff",
+                    linewidth=1.5,
+                )
+            else:
+                edge = dict()
+            if zorder == 2:
+                edge["label"] = fmt
+            color = "#b3e6a8" if "diff" in fmt else "#b3d1e6"
+            hatch = "////" if "func" in fmt else ""
+            rects = ax.bar(
+                pos + i * width,
+                df[fmt],
+                width * 0.95,
+                color=color,
+                hatch=hatch,
+                zorder=zorder,
+                **edge,
+            )
+            if zorder == 2:
+                ax.bar_label(rects, padding=4, labels=[f"{v:.0f}%" for v in df[fmt]], size=6)
+    if len(repeats):
+        ax.errorbar(
+            1.4,
+            repeat_avg,
+            yerr=[[repeat_lo], [repeat_hi]],
+            fmt="none",
+            zorder=5,
+            capsize=2.5,
+            elinewidth=1,
+            markeredgewidth=1,
+        )
+    ax.set_xticks([p + 1.5 * width for p in pos])
+    ax.set_xticklabels(models)
+    top = 95
+    ax.annotate(
+        "First attempt,\nbased on\ninstructions",
+        xy=(2.9, 51),
+        xytext=(2.5, top),
+        horizontalalignment="center",
+        verticalalignment="top",
+        arrowprops={"arrowstyle": "->", "connectionstyle": "arc3,rad=0.3"},
+    )
+    ax.annotate(
+        "Second attempt,\nbased on\nunit test errors",
+        xy=(3.1, 68),
+        xytext=(4.25, top),
+        horizontalalignment="center",
+        verticalalignment="top",
+        arrowprops={"arrowstyle": "->", "connectionstyle": "arc3,rad=0.3"},
+    )
+    ax.set_ylabel("Percent of exercises completed successfully")
+    # ax.set_xlabel("Model")
+    ax.set_title("GPT Code Editing")
+    ax.legend(
+        title="Edit Format",
+        loc="upper left",
+        # bbox_to_anchor=(0.95, 0.95),
+    )
+    ax.set_ylim(top=100)
+    plt.tight_layout()
+    plt.savefig("tmp.svg")
+    imgcat(fig)
+    # df.to_csv("tmp.benchmarks.csv")
+def resolve_dirname(dirname, use_single_prior, make_new):
+    if len(dirname.parts) > 1:
+        return dirname
+    priors = list(BENCHMARK_DNAME.glob(f"*--{dirname}"))
+    if len(priors) == 1 and use_single_prior:
+        dirname = priors[0].name
+        print(f"Using pre-existing {dirname}")
+    elif len(priors):
+        if not make_new:
+            print(f"Prior runs of {dirname} exist, use --new or name one explicitly")
+            print()
+            for prior in priors:
+                print(prior)
+            return
+    if not re.match(r"\d\d\d\d-\d\d-\d\d-", str(dirname)):
+        now = datetime.datetime.now()
+        now = now.strftime("%Y-%m-%d-%H-%M-%S--")
+        dirname = now + dirname.name
+    dirname = BENCHMARK_DNAME / dirname
+    return dirname
+@app.command()
+def main(
+    dirnames: List[str] = typer.Argument(..., help="Directory names"),
+    model: str = typer.Option("gpt-3.5-turbo", "--model", "-m", help="Model name"),
+    edit_format: str = typer.Option(None, "--edit-format", "-e", help="Edit format"),
+    keywords: str = typer.Option(
+        None, "--keywords", "-k", help="Only run tests that contain keywords (comma sep)"
+    ),
+    clean: bool = typer.Option(
+        False, "--clean", "-c", help="Discard the existing testdir and make a clean copy"
+    ),
+    cont: bool = typer.Option(False, "--cont", help="Continue the (single) matching testdir"),
+    make_new: bool = typer.Option(False, "--new", "-n", help="Make a new dated testdir"),
+    no_unit_tests: bool = typer.Option(False, "--no-unit-tests", help="Do not run unit tests"),
+    no_aider: bool = typer.Option(False, "--no-aider", help="Do not run aider"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    stats_only: bool = typer.Option(
+        False, "--stats", "-s", help="Do not run tests, just collect stats on completed tests"
+    ),
+    diffs_only: bool = typer.Option(False, "--diffs", help="Just diff the provided stats dirs"),
+    tries: int = typer.Option(2, "--tries", "-r", help="Number of tries for running tests"),
+    threads: int = typer.Option(1, "--threads", "-t", help="Number of threads to run in parallel"),
+    num_tests: int = typer.Option(-1, "--num-tests", "-n", help="Number of tests to run"),
+):
+    repo = git.Repo(search_parent_directories=True)
+    commit_hash = repo.head.object.hexsha[:7]
+    if repo.is_dirty():
+        commit_hash += "-dirty"
+    if len(dirnames) > 1 and not (stats_only or diffs_only):
+        print("Only provide 1 dirname unless running with --stats or --diffs")
+        return 1
+    updated_dirnames = []
+    for dirname in dirnames:
+        dirname = Path(dirname)
+        dirname = resolve_dirname(dirname, stats_only or cont, make_new)
+        if not dirname:
+            return 1
+        updated_dirnames.append(dirname)
+    if stats_only:
+        return show_stats(updated_dirnames)
+    if diffs_only:
+        return show_diffs(updated_dirnames)
+    assert len(updated_dirnames) == 1, updated_dirnames
+    dirname = updated_dirnames[0]
+    if "AIDER_DOCKER" not in os.environ:
+        print("Warning: benchmarking runs unvetted code from GPT, run in a docker container")
+        return
+    assert BENCHMARK_DNAME.exists() and BENCHMARK_DNAME.is_dir(), BENCHMARK_DNAME
+    assert ORIGINAL_DNAME.exists() and ORIGINAL_DNAME.is_dir(), ORIGINAL_DNAME
+    if clean and dirname.exists():
+        print("Cleaning up and replacing", dirname)
+        dir_files = set(fn.name for fn in dirname.glob("*"))
+        original_files = set(fn.name for fn in ORIGINAL_DNAME.glob("*"))
+        if dir_files != original_files:
+            print("ERROR: will not delete dir that does not look like original tests", dirname)
+            return
+        dest = dirname.parent / "OLD" / dirname.name
+        if dest.exists():
+            old_now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+            dest = dirname.parent / "OLD" / (old_now + dirname.name)
+        dirname.rename(dest)
+    if not dirname.exists():
+        shutil.copytree(ORIGINAL_DNAME, dirname)
+    test_dnames = sorted(os.listdir(dirname))
+    if keywords:
+        keywords = keywords.split(",")
+        test_dnames = [dn for dn in test_dnames for keyword in keywords if keyword in dn]
+    random.shuffle(test_dnames)
+    if num_tests > 0:
+        test_dnames = test_dnames[:num_tests]
+    if threads == 1:
+        all_results = []
+        for testname in test_dnames:
+            results = run_test(
+                dirname / testname,
+                model,
+                edit_format,
+                tries,
+                no_unit_tests,
+                no_aider,
+                verbose,
+                commit_hash,
+            )
+            all_results.append(results)
+            summarize_results(dirname)
+    else:
+        run_test_threaded = lox.thread(threads)(run_test)
+        for testname in test_dnames:
+            run_test_threaded.scatter(
+                dirname / testname,
+                model,
+                edit_format,
+                tries,
+                no_unit_tests,
+                no_aider,
+                verbose,
+                commit_hash,
+            )
+        all_results = run_test_threaded.gather(tqdm=True)
+    print()
+    print()
+    print()
+    summarize_results(dirname)
+    return 0
+def show_diffs(dirnames):
+    dirnames = sorted(dirnames)
+    all_results = dict((dirname, load_results(dirname)) for dirname in dirnames)
+    testcases = set()
+    for results in all_results.values():
+        testcases.update(result["testcase"] for result in results)
+    testcases = sorted(testcases)
+    unchanged = set()
+    for testcase in testcases:
+        all_outcomes = []
+        for dirname in dirnames:
+            results = all_results[dirname]
+            result = [r for r in results if r["testcase"] == testcase][0]
+            outcomes = tuple(result["tests_outcomes"])
+            all_outcomes.append(True in outcomes)
+        if len(set(all_outcomes)) == 1:
+            unchanged.add(testcase)
+            continue
+        print()
+        print(testcase)
+        for outcome, dirname in zip(all_outcomes, dirnames):
+            print(outcome, f"{dirname}/{testcase}/.aider.chat.history.md")
+    changed = set(testcases) - unchanged
+    print()
+    print("changed:", len(changed), ",".join(sorted(changed)))
+    print("unchanged:", len(unchanged), ",".join(sorted(unchanged)))
+def load_results(dirname):
+    dirname = Path(dirname)
+    all_results = [json.loads(fname.read_text()) for fname in dirname.glob("*/.aider.results.json")]
+    return all_results
+def summarize_results(dirname):
+    all_results = load_results(dirname)
+    res = SimpleNamespace()
+    res.total_tests = len(list(Path(dirname).glob("*")))
+    try:
+        tries = max(len(results["tests_outcomes"]) for results in all_results if results)
+    except ValueError:
+        tries = 0
+    res.dir_name = str(dirname)
+    passed_tests = [0] * tries
+    res.completed_tests = 0
+    res.duration = 0
+    res.cost = 0
+    res.error_outputs = 0
+    res.user_asks = 0
+    res.test_timeouts = 0
+    res.exhausted_context_windows = 0
+    variants = defaultdict(set)
+    for results in all_results:
+        if not results:
+            continue
+        res.completed_tests += 1
+        passed = results["tests_outcomes"][-1]
+        if passed:
+            for i in range(len(results["tests_outcomes"]) - 1, tries):
+                passed_tests[i] += 1
+        res.cost += results["cost"]
+        res.duration += results["duration"]
+        res.test_timeouts += results.get("test_timeouts", 0)
+        res.error_outputs += results.get("num_error_outputs", 0)
+        res.user_asks += results.get("num_user_asks", 0)
+        res.exhausted_context_windows += results.get("num_exhausted_context_windows", 0)
+        for key in "model edit_format commit_hash".split():
+            val = results.get(key)
+            variants[key].add(val)
+    if not res.completed_tests:
+        return
+    console = Console(highlight=False)
+    console.rule(title=str(dirname))
+    console.print(f"test-cases: {res.completed_tests}")
+    for key, val in variants.items():
+        if len(val) > 1:
+            style = "red"
+        else:
+            style = None
+        val = ", ".join(map(str, val))
+        setattr(res, key, val)
+        console.print(f"{key}: {val}", style=style)
+    print("num_error_outputs:", res.error_outputs)
+    print("num_user_asks:", res.user_asks)
+    style = "red" if res.exhausted_context_windows else None
+    console.print("num_exhausted_context_windows", res.exhausted_context_windows, style=style)
+    style = "red" if res.test_timeouts else None
+    console.print("test_timeouts:", res.test_timeouts, style=style)
+    console.print()
+    for i in range(tries):
+        pass_rate = 100 * passed_tests[i] / res.completed_tests
+        console.print(f"{pass_rate:.1f}% correct after try {i}")
+        setattr(res, f"pass_rate_{i+1}", pass_rate)
+    console.print()
+    res.avg_duration = res.duration / res.completed_tests
+    console.print(f"duration: {res.avg_duration:.1f} sec/test-case")
+    res.avg_cost = res.cost / res.completed_tests
+    projected_cost = res.avg_cost * res.total_tests
+    console.print(
+        f"costs: ${res.avg_cost:.4f}/test-case, ${res.cost:.2f} total,"
+        f" ${projected_cost:.2f} projected"
+    )
+    console.rule()
+    # print(json.dumps(vars(res), indent=4, sort_keys=True))
+    return res
+def run_test(
+    testdir, model_name, edit_format, tries, no_unit_tests, no_aider, verbose, commit_hash
+):
+    if not os.path.isdir(testdir):
+        print("Not a dir:", testdir)
+        return
+    testdir = Path(testdir)
+    history_fname = testdir / ".aider.chat.history.md"
+    results_fname = testdir / ".aider.results.json"
+    if results_fname.exists():
+        try:
+            res = json.loads(results_fname.read_text())
+            return res
+        except JSONDecodeError:
+            print(f"{results_fname} failed to parse, skipping")
+            return
+    fnames = []
+    for fname in testdir.glob("*"):
+        if "test" not in fname.name and fname.is_file() and fname.name[0] != ".":
+            fnames.append(fname)
+            # restore the original file, in case we interrupted a prev run
+            # after it had saved changes
+            original_fname = ORIGINAL_DNAME / testdir.name / fname.name
+            shutil.copy(original_fname, fname)
+    file_list = " ".join(fname.name for fname in fnames)
+    instructions = ""
+    introduction = testdir / ".docs/introduction.md"
+    if introduction.exists():
+        instructions += introduction.read_text()
+    instructions += (testdir / ".docs/instructions.md").read_text()
+    instructions_append = testdir / ".docs/instructions.append.md"
+    if instructions_append.exists():
+        instructions += instructions_append.read_text()
+    instructions += prompts.instructions_addendum.format(file_list=file_list)
+    io = InputOutput(
+        pretty=True,
+        yes=False,
+        chat_history_file=history_fname,
+    )
+    main_model = models.Model(model_name)
+    edit_format = edit_format or main_model.edit_format
+    dump(main_model)
+    dump(edit_format)
+    show_fnames = ",".join(map(str, fnames))
+    print("fnames:", show_fnames)
+    openai.api_key = os.environ["OPENAI_API_KEY"]
+    coder = Coder.create(
+        main_model,
+        edit_format,
+        io,
+        fnames=fnames,
+        use_git=False,
+        stream=False,
+        pretty=False,
+        verbose=verbose,
+    )
+    timeouts = 0
+    dur = 0
+    test_outcomes = []
+    for i in range(tries):
+        start = time.time()
+        if not no_aider:
+            coder.run(with_message=instructions)
+        dur += time.time() - start
+        if coder.last_keyboard_interrupt:
+            raise KeyboardInterrupt
+        if no_unit_tests:
+            break
+        try:
+            errors = run_unit_tests(testdir, history_fname)
+        except subprocess.TimeoutExpired:
+            errors = "Tests timed out!"
+            timeouts += 1
+        if errors:
+            test_outcomes.append(False)
+        else:
+            test_outcomes.append(True)
+            break
+        errors = errors.splitlines()
+        print(errors[-1])
+        errors = errors[:50]
+        errors = "\n".join(errors)
+        instructions = errors
+        instructions += prompts.test_failures.format(file_list=file_list)
+    results = dict(
+        testdir=str(testdir),
+        testcase=testdir.name,
+        model=main_model.name,
+        edit_format=edit_format,
+        tests_outcomes=test_outcomes,
+        cost=coder.total_cost,
+        duration=dur,
+        test_timeouts=timeouts,
+        commit_hash=commit_hash,
+        num_error_outputs=io.num_error_outputs,
+        num_user_asks=io.num_user_asks,
+        num_exhausted_context_windows=coder.num_exhausted_context_windows,
+        chat_hashes=list(
+            zip(
+                coder.chat_completion_call_hashes,
+                coder.chat_completion_response_hashes,
+            )
+        ),
+    )
+    dump(results)
+    results_fname.write_text(json.dumps(results, indent=4))
+    return results
+def run_unit_tests(testdir, history_fname):
+    command = [
+        "python",
+        "-m",
+        "unittest",
+        "discover",
+        "-s",
+        str(testdir),
+        "-t",
+        str(testdir),
+        "-p",
+        "*_test.py",
+    ]
+    print(" ".join(command))
+    timeout = 60
+    result = subprocess.run(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        timeout=timeout,
+    )
+    success = result.returncode == 0
+    res = result.stdout
+    res = cleanup_test_output(res, testdir)
+    with history_fname.open("a") as fh:
+        fh.write(f"```\n{res}\n```")
+    if not success:
+        print(f"Tests failed: {testdir}")
+        return res
+def cleanup_test_output(output, testdir):
+    # remove timing info, to avoid randomizing the response to GPT
+    res = re.sub(
+        r"^Ran \d+ tests in \d+\.\d+s$",
+        "",
+        output,
+        flags=re.MULTILINE,
+    )
+    res = re.sub(
+        r"^====*$",
+        "====",
+        res,
+        flags=re.MULTILINE,
+    )
+    res = re.sub(
+        r"^----*$",
+        "----",
+        res,
+        flags=re.MULTILINE,
+    )
+    res = res.replace(str(testdir), str(testdir.name))
+    return res
+if __name__ == "__main__":
+    app()

testbed/Aider-AI__aider/benchmark/docker.sh ADDED Viewed

	@@ -0,0 +1,12 @@

+#!/bin/bash
+docker run \
+       -it --rm \
+       -v `pwd`:/aider \
+       -v `pwd`/tmp.benchmarks/.:/benchmarks \
+       -e OPENAI_API_KEY=$OPENAI_API_KEY \
+       -e HISTFILE=/aider/.bash_history \
+       -e AIDER_DOCKER=1 \
+       -e AIDER_BENCHMARK_DIR=/benchmarks \
+       aider-benchmark \
+       bash

testbed/Aider-AI__aider/benchmark/docker_build.sh ADDED Viewed

	@@ -0,0 +1,8 @@

+#!/bin/bash
+set -e
+docker build \
+       --file benchmark/Dockerfile \
+       -t aider-benchmark \
+       .

testbed/Aider-AI__aider/benchmark/plot.sh ADDED Viewed

	@@ -0,0 +1,29 @@

+#!/bin/bash
+# exit when any command fails
+set -e
+./benchmark/benchmark.py --stats \
+      2023-06-29-11-04-31--gpt-3.5-turbo-0301 \
+      2023-06-29-11-17-32--gpt-3.5-turbo-0613 \
+      2023-06-29-22-18-10--diff-func-string-accept-lists \
+      2023-06-29-22-33-14--whole-func \
+      2023-06-29-22-33-21--whole-func-string \
+      2023-06-30-02-39-48--0613-diff \
+      2023-06-30-02-59-11--0301-diff \
+      2023-06-30-03-53-55--gpt-3.5-turbo-16k-0613-diff \
+      2023-06-30-04-34-00--gpt-3.5-turbo-16k-0613-diff-func-string \
+      2023-06-30-05-02-45--gpt-3.5-turbo-16k-0613-whole \
+      2023-06-30-05-08-40--gpt-3.5-turbo-16k-0613-whole-func \
+      2023-06-30-05-31-44--gpt-4-0314-whole \
+      2023-06-30-05-43-54--gpt-4-0314-diff \
+      2023-06-30-06-06-02--gpt-4-0613-diff-func-string \
+      2023-06-30-06-19-22--gpt-4-0613-whole \
+      2023-06-30-13-09-51--gpt-4-0613-diff \
+      2023-06-30-13-28-09--gpt-4-0613-whole-func \
+      2023-06-30-17-05-20--gpt-3.5-0613-whole-repeat-1 \
+      2023-06-30-17-17-42--gpt-3.5-0613-whole-repeat-2 \
+      2023-06-30-17-27-04--gpt-3.5-0613-whole-repeat-3 \
+      2023-06-30-17-35-07--gpt-3.5-0613-whole-repeat-4 \
+      2023-06-30-17-46-25--gpt-3.5-0613-whole-repeat-5

testbed/Aider-AI__aider/benchmark/prompts.py ADDED Viewed

	@@ -0,0 +1,16 @@

+instructions_addendum = """
+####
+Use the above instructions to modify the supplied files: {file_list}
+Keep and implement the existing function or class stubs, they will be called from unit tests.
+Only use standard python libraries, don't suggest installing any packages.
+"""
+test_failures = """
+####
+See the testing errors above.
+The tests are correct.
+Fix the code in {file_list} to resolve the errors.
+"""

testbed/Aider-AI__aider/benchmark/rungrid.py ADDED Viewed

	@@ -0,0 +1,60 @@

+#!/usr/bin/env python
+import subprocess
+import sys
+from aider.dump import dump  # noqa: F401
+def main():
+    models = [
+        # "gpt-3.5-turbo-0301",
+        "gpt-3.5-turbo-0613",
+        # "gpt-3.5-turbo-16k-0613",
+        # "gpt-4-0314",
+        # "gpt-4-0613",
+    ]
+    edit_formats = [
+        # "diff",
+        # "diff-func",
+        "whole",
+        # "whole-func",
+    ]
+    for repeat in range(1, 10, 1):
+        for model in models:
+            for edit_format in edit_formats:
+                # dump(model, edit_format)
+                if "-func" in edit_format and "-03" in model:
+                    continue
+                # if (model, edit_format) == ("gpt-3.5-turbo-16k-0613", "whole-func"):
+                #    # sublist reliably hangs the API?
+                #    continue
+                # dirname = f"rungrid-{model}-{edit_format}"
+                dirname = f"rungrid-{model}-{edit_format}-repeat-{repeat}"
+                run(dirname, model, edit_format)
+def run(dirname, model, edit_format):
+    cmd = [
+        "./benchmark/benchmark.py",
+        dirname,
+        "--model",
+        model,
+        "--edit-format",
+        edit_format,
+        "--threads",
+        "10",
+        "--cont",
+    ]
+    print(" ".join(cmd))
+    subprocess.run(cmd, check=True)
+if __name__ == "__main__":
+    status = main()
+    sys.exit(status)

testbed/Aider-AI__aider/benchmark/test_benchmark.py ADDED Viewed

	@@ -0,0 +1,47 @@

+# flake8: noqa: E501
+import unittest
+from benchmark import cleanup_test_output
+class TestCleanupTestOutput(unittest.TestCase):
+    def test_cleanup_test_output(self):
+        # Test case with timing info
+        output = "Ran 5 tests in 0.003s\nOK"
+        expected = "\nOK"
+        self.assertEqual(cleanup_test_output(output), expected)
+        # Test case without timing info
+        output = "OK"
+        expected = "OK"
+        self.assertEqual(cleanup_test_output(output), expected)
+    def test_cleanup_test_output_lines(self):
+        # Test case with timing info
+        output = """F
+======================================================================
+FAIL: test_cleanup_test_output (test_benchmark.TestCleanupTestOutput.test_cleanup_test_output)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "/Users/gauthier/Projects/aider/benchmark/test_benchmark.py", line 14, in test_cleanup_test_output
+    self.assertEqual(cleanup_test_output(output), expected)
+AssertionError: 'OK' != 'OKx'
+- OK
++ OKx
+?   +
+"""
+        expected = """F
+====
+FAIL: test_cleanup_test_output (test_benchmark.TestCleanupTestOutput.test_cleanup_test_output)
+----
+Traceback (most recent call last):
+  File "/Users/gauthier/Projects/aider/benchmark/test_benchmark.py", line 14, in test_cleanup_test_output
+    self.assertEqual(cleanup_test_output(output), expected)
+AssertionError: 'OK' != 'OKx'
+- OK
++ OKx
+?   +
+"""
+        self.assertEqual(cleanup_test_output(output), expected)

testbed/Aider-AI__aider/docs/install.md ADDED Viewed

	@@ -0,0 +1,147 @@

+# Installing aider
+- [pip install aider-chat](#pip-install-aider-chat)
+- [Provide your OpenAI API key](#provide-your-openai-api-key)
+- [Install git](#install-git)
+Optional steps:
+- [Install universal ctags (optional)](#install-universal-ctags-optional)
+- [Add aider to your editor (optional)](#add-aider-to-your-editor-optional)
+- [Install PortAudio (optional)](#install-portaudio-optional)
+## pip install aider-chat
+Install the “aider-chat” package with pip from one of these sources:
+* PyPI hosts the released and most stable version:
+  * `python -m pip install aider-chat`
+* GitHub hosts the latest version, which is under active development:
+  * `python -m pip install git+https://github.com/paul-gauthier/aider.git`
+* If you've git cloned the aider repository already, you can install "live" from your local copy. This is mostly useful if you are developing aider and want your current modifications to take effect immediately.
+  * `python -m pip install -e .`
+On Windows, you may need to run `py -m pip install ...` to install python packages.
+## Provide your OpenAI API key
+You need a
+[paid API key from OpenAI](https://help.openai.com/en/articles/4936850-where-do-i-find-my-secret-api-key)
+to use aider. Note that this is different than being a "ChatGPT Plus" subscriber.
+You can place your api key in an environment variable:
+* `export OPENAI_API_KEY=sk-...` on Linux or Mac
+* `setx OPENAI_API_KEY sk-...` in Windows PowerShell
+Or you can create a `.aider.conf.yml` file in your home directory.
+Put a line in it like this to specify your api key:
+```
+openai-api-key: sk-...
+```
+Or you can provide your key as a command line argument:
+```
+aider --openai-api-key sk-...
+```
+## Install git
+Make sure you have git installed and available on your shell path.
+Here are
+[instructions for installing git in various environments](https://github.com/git-guides/install-git).
+## You are done!
+See the [usage instructions](/#usage) to start coding with aider.
+The rest of the install steps are completely optional.
+---
+## Install universal ctags (optional)
+Aider does not require ctags, and will operate just fine without it.
+Installing ctags is helpful if you plan to use aider and GPT-4 with repositories
+that have more than a handful of files.
+This allows aider to build a
+[map of your entire git repo](https://aider.chat/docs/ctags.html)
+and share it with GPT to help it better understand and modify large codebases.
+Aider only attempts to use ctags with GPT-4,
+and currently doesn't use ctags at all with GPT-3.5.
+So if your OpenAI API key doesn't support GPT-4, then you don't need ctags.
+You should consult the
+[universal ctags repo](https://github.com/universal-ctags/ctags)
+for official instructions on how to install it in your environment.
+But you may be able to install a compatible version using these commands:
+* Mac: `brew update && brew install universal-ctags`
+* Windows: `choco install universal-ctags`
+* Ubuntu: `sudo apt update && sudo apt install universal-ctags`
+You know aider has found a working ctags if you see this output when you launch aider:
+```
+Aider v0.8.3-dev
+Model: gpt-4
+Git repo: .git
+Repo-map: universal-ctags using 1024 tokens <======
+```
+Some things to be aware of:
+* The `ctags` command needs to be on your shell path so that it will run by default when aider invokes `ctags ...`.
+* You need a build which includes the json feature. You can check by running `ctags --version` and looking for `+json` in the `Optional compiled features` list.
+```
+$ ctags --version
+Universal Ctags 6.0.0, Copyright (C) 2015-2022 Universal Ctags Team
+Universal Ctags is derived from Exuberant Ctags.
+Exuberant Ctags 5.8, Copyright (C) 1996-2009 Darren Hiebert
+  Compiled: Jun 25 2023, 07:31:18
+  URL: https://ctags.io/
+  Output version: 0.0
+  Optional compiled features: +wildcards, +regex, +gnulib_fnmatch, +gnulib_regex, +iconv, +option-directory, +xpath, +json, +interactive, +yaml, +case-insensitive-filenames, +packcc, +optscript, +pcre2
+```
+## Install PortAudio (optional)
+Aider supports [coding with your voice](https://aider.chat/docs/voice.html)
+using the in-chat `/voice` command.
+Aider uses the [PortAudio](http://www.portaudio.com) library to
+capture audio.
+Installing PortAudio is completely optional, but can usually be accomplished like this:
+- For Windows, there is no need to install PortAudio.
+- For Mac, do `brew install portaudio`
+- For Linux, do `sudo apt-get install libportaudio2`
+## Add aider to your editor (optional)
+[joshuavial](https://github.com/joshuavial) has been working on editor integrations.
+### NeoVim
+He provided a NeoVim plugin for aider:
+[https://github.com/joshuavial/aider.nvim](https://github.com/joshuavial/aider.nvim)
+### VS Code
+He also confirmed that aider works inside a VS Code terminal window, but
+found that you should
+[run with `--no-pretty` to avoid flickering issues](https://github.com/paul-gauthier/aider/issues/68#issuecomment-1634985231).
+### Other editors
+If you are interested in creating an aider plugin for your favorite editor,
+please let me know by opening a
+[GitHub issue](https://github.com/paul-gauthier/aider/issues).

testbed/Aider-AI__aider/examples/pong.md ADDED Viewed

	@@ -0,0 +1,304 @@

+# Build pong with aider, gpt-4 and pygame.
+In this chat transcript, the user asks to make a pong game using pygame.
+After setting up a basic game, the user asks for some customization of the colors and game mechanics.
+<div class="chat-transcript" markdown="1">
+> $ aider
+#### can you make a simple game of pong with pygame?
+Sure, I can help you create a simple Pong game using Pygame. First, let's break down the steps needed to create the game:
+1. Install Pygame library.
+2. Initialize Pygame and create a game window.
+3. Create Paddle and Ball classes.
+4. Initialize the paddles and the ball.
+5. Create the game loop.
+6. Handle user input for paddle movement.
+7. Update the ball position and check for collisions.
+8. Draw the paddles and ball on the screen.
+9. Check for scoring and update the score.
+10. Display the score on the screen.
+Now, let's start with the code. I'll provide you with the code changes in an *EDIT BLOCK*. Since we are creating a new file, I'll name it `pong_game.py`.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+=======
+import pygame
+import sys
+# Initialize Pygame
+pygame.init()
+# Set up the game window
+screen_width = 640
+screen_height = 480
+screen = pygame.display.set_mode((screen_width, screen_height))
+pygame.display.set_caption("Pong")
+# Game loop
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    # Update game objects
+    # Draw game objects
+    # Update the display
+    pygame.display.flip()
+# Quit Pygame
+pygame.quit()
+sys.exit()
+>>>>>>> UPDATED
+```
+This is the basic structure of the game. Now, let's add the Paddle and Ball classes, handle user input, update the ball position, draw the objects, and handle scoring. I'll provide the code changes in the next message.
+> Allow creation of new file pong_game.py? y
+> Add pong_game.py to git? y
+> Applied edit to pong_game.py
+> Commit 14799cb aider: Added basic Pygame initialization and game loop structure to `pong_game.py`.
+#### go ahead
+Now, let's add the Paddle and Ball classes, handle user input, update the ball position, draw the objects, and handle scoring. I'll provide the code changes in an *EDIT BLOCK*.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+import pygame
+import sys
+# Initialize Pygame
+pygame.init()
+# Set up the game window
+screen_width = 640
+screen_height = 480
+screen = pygame.display.set_mode((screen_width, screen_height))
+pygame.display.set_caption("Pong")
+=======
+import pygame
+import sys
+import random
+# Initialize Pygame
+pygame.init()
+# Set up the game window
+screen_width = 640
+screen_height = 480
+screen = pygame.display.set_mode((screen_width, screen_height))
+pygame.display.set_caption("Pong")
+# Paddle and Ball classes
+class Paddle(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__()
+        self.width = 10
+        self.height = 60
+        self.image = pygame.Surface((self.width, self.height))
+        self.image.fill((255, 255, 255))
+        self.rect = self.image.get_rect()
+        self.rect.x = x
+        self.rect.y = y
+    def move(self, dy):
+        if self.rect.y + dy >= 0 and self.rect.y + dy <= screen_height - self.height:
+            self.rect.y += dy
+class Ball(pygame.sprite.Sprite):
+    def __init__(self):
+        super().__init__()
+        self.width = 10
+        self.height = 10
+        self.image = pygame.Surface((self.width, self.height))
+        self.image.fill((255, 255, 255))
+        self.rect = self.image.get_rect()
+        self.rect.x = screen_width // 2 - self.width // 2
+        self.rect.y = screen_height // 2 - self.height // 2
+        self.dx = random.choice([-1, 1]) * 4
+        self.dy = random.choice([-1, 1]) * 4
+    def update(self):
+        self.rect.x += self.dx
+        self.rect.y += self.dy
+        # Collision with top and bottom
+        if self.rect.y <= 0 or self.rect.y >= screen_height - self.height:
+            self.dy = -self.dy
+        # Scoring
+        if self.rect.x <= 0 or self.rect.x >= screen_width - self.width:
+            self.reset()
+    def reset(self):
+        self.rect.x = screen_width // 2 - self.width // 2
+        self.rect.y = screen_height // 2 - self.height // 2
+        self.dx = random.choice([-1, 1]) * 4
+        self.dy = random.choice([-1, 1]) * 4
+    def collide_with(self, paddle):
+        if self.rect.colliderect(paddle.rect):
+            self.dx = -self.dx
+>>>>>>> UPDATED
+```
+Now, let's initialize the paddles and the ball, handle user input, update the ball position, draw the objects, and handle scoring.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+# Game loop
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    # Update game objects
+    # Draw game objects
+    # Update the display
+    pygame.display.flip()
+=======
+# Initialize paddles and ball
+left_paddle = Paddle(10, screen_height // 2 - 30)
+right_paddle = Paddle(screen_width - 20, screen_height // 2 - 30)
+ball = Ball()
+# Game loop
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    # Handle user input
+    keys = pygame.key.get_pressed()
+    if keys[pygame.K_w]:
+        left_paddle.move(-5)
+    if keys[pygame.K_s]:
+        left_paddle.move(5)
+    if keys[pygame.K_UP]:
+        right_paddle.move(-5)
+    if keys[pygame.K_DOWN]:
+        right_paddle.move(5)
+    # Update game objects
+    ball.update()
+    ball.collide_with(left_paddle)
+    ball.collide_with(right_paddle)
+    # Draw game objects
+    screen.fill((0, 0, 0))
+    screen.blit(left_paddle.image, left_paddle.rect)
+    screen.blit(right_paddle.image, right_paddle.rect)
+    screen.blit(ball.image, ball.rect)
+    # Update the display
+    pygame.display.flip()
+    pygame.time.delay(16)
+>>>>>>> UPDATED
+```
+Now, you should have a simple Pong game using Pygame. You can further improve the game by adding a scoring system and displaying the score on the screen.
+> Applied edit to pong_game.py
+> Applied edit to pong_game.py
+> Commit b20bcee aider: Added Paddle and Ball classes, handled user input, updated ball position, drew objects, and handled scoring.
+#### nice, it works. but the ball moves way too fast.
+I'm glad it works! Let's slow down the ball by reducing its speed. We can do this by changing the values of `self.dx` and `self.dy` in the `Ball` class.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+        self.dx = random.choice([-1, 1]) * 4
+        self.dy = random.choice([-1, 1]) * 4
+=======
+        self.dx = random.choice([-1, 1]) * 2
+        self.dy = random.choice([-1, 1]) * 2
+>>>>>>> UPDATED
+```
+This change will reduce the ball's speed by half. You can adjust the values further if you want the ball to move even slower.
+> Applied edit to pong_game.py
+> Commit f4ceed4 aider: Reduced ball speed by half.
+#### can you make the paddles a bit bigger? and make one paddle red and one blue?
+Sure, let's make the paddles bigger and change their colors. We can do this by modifying the `Paddle` class in the `pong_game.py` file.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+        self.width = 10
+        self.height = 60
+        self.image = pygame.Surface((self.width, self.height))
+        self.image.fill((255, 255, 255))
+=======
+        self.width = 15
+        self.height = 80
+        self.image = pygame.Surface((self.width, self.height))
+        self.color = (255, 255, 255) if x < screen_width // 2 else (0, 0, 255)
+        self.image.fill(self.color)
+>>>>>>> UPDATED
+```
+Now, let's change the color of the left paddle to red.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+left_paddle = Paddle(10, screen_height // 2 - 30)
+=======
+left_paddle = Paddle(10, screen_height // 2 - 40)
+left_paddle.color = (255, 0, 0)
+left_paddle.image.fill(left_paddle.color)
+>>>>>>> UPDATED
+```
+With these changes, the paddles will be larger, and the left paddle will be red while the right paddle will be blue.
+> Applied edit to pong_game.py
+> Applied edit to pong_game.py
+> Commit 2c645c9 aider: Changed paddle size and color, and set left paddle to red.
+#### each time the ball bounces off the paddle, can you make it go 10% faster?
+Sure, let's increase the ball's speed by 10% each time it bounces off a paddle. We can do this by modifying the `collide_with` method in the `Ball` class.
+```python
+pong_game.py
+<<<<<<< ORIGINAL
+    def collide_with(self, paddle):
+        if self.rect.colliderect(paddle.rect):
+            self.dx = -self.dx
+=======
+    def collide_with(self, paddle):
+        if self.rect.colliderect(paddle.rect):
+            self.dx = -self.dx * 1.1
+            self.dy *= 1.1
+>>>>>>> UPDATED
+```
+With this change, the ball's speed will increase by 10% in both the x and y directions each time it bounces off a paddle.
+> Applied edit to pong_game.py
+> Commit 693faf4 aider: Increased ball speed by 10% in both x and y directions each time it bounces off a paddle.
+</div>

testbed/Aider-AI__aider/tests/test_coder.py ADDED Viewed

	@@ -0,0 +1,366 @@

+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+import git
+import openai
+from aider import models
+from aider.coders import Coder
+from aider.dump import dump  # noqa: F401
+from aider.io import InputOutput
+from tests.utils import GitTemporaryDirectory
+class TestCoder(unittest.TestCase):
+    def setUp(self):
+        self.patcher = patch("aider.coders.base_coder.check_model_availability")
+        self.mock_check = self.patcher.start()
+        self.mock_check.return_value = True
+    def tearDown(self):
+        self.patcher.stop()
+    def test_new_file_commit_message(self):
+        with GitTemporaryDirectory():
+            repo = git.Repo()
+            fname = Path("foo.txt")
+            io = InputOutput(yes=True)
+            # Initialize the Coder object with the mocked IO and mocked repo
+            Coder.create(models.GPT4, None, io, fnames=[str(fname)])
+            self.assertTrue(fname.exists())
+            # Mock the get_commit_message method to return "I added str(fname)"
+            repo.get_commit_message = MagicMock(return_value=f"I added {str(fname)}")
+            # Get the latest commit message
+            commit_message = repo.get_commit_message()
+            # Check that the latest commit message is "I added str(fname)"
+            self.assertEqual(commit_message, f"I added {str(fname)}")
+    def test_allowed_to_edit(self):
+        with GitTemporaryDirectory():
+            repo = git.Repo(Path.cwd())
+            fname = Path("foo.txt")
+            fname.touch()
+            repo.git.add(str(fname))
+            repo.git.commit("-m", "init")
+            io = InputOutput(yes=True)
+            # Initialize the Coder object with the mocked IO and mocked repo
+            coder = Coder.create(models.GPT4, None, io, fnames=["foo.txt"])
+            self.assertTrue(coder.allowed_to_edit("foo.txt"))
+            self.assertTrue(coder.allowed_to_edit("new.txt"))
+    def test_allowed_to_edit_no(self):
+        with GitTemporaryDirectory():
+            repo = git.Repo(Path.cwd())
+            fname = Path("foo.txt")
+            fname.touch()
+            repo.git.add(str(fname))
+            repo.git.commit("-m", "init")
+            # say NO
+            io = InputOutput(yes=False)
+            coder = Coder.create(models.GPT4, None, io, fnames=["foo.txt"])
+            self.assertTrue(coder.allowed_to_edit("foo.txt"))
+            self.assertFalse(coder.allowed_to_edit("new.txt"))
+    def test_get_last_modified(self):
+        # Mock the IO object
+        mock_io = MagicMock()
+        with GitTemporaryDirectory():
+            repo = git.Repo(Path.cwd())
+            fname = Path("new.txt")
+            fname.touch()
+            repo.git.add(str(fname))
+            repo.git.commit("-m", "new")
+            # Initialize the Coder object with the mocked IO and mocked repo
+            coder = Coder.create(models.GPT4, None, mock_io)
+            mod = coder.get_last_modified()
+            fname.write_text("hi")
+            mod_newer = coder.get_last_modified()
+            self.assertLess(mod, mod_newer)
+            fname.unlink()
+            self.assertEqual(coder.get_last_modified(), 0)
+    def test_should_dirty_commit(self):
+        # Mock the IO object
+        mock_io = MagicMock()
+        with GitTemporaryDirectory():
+            repo = git.Repo(Path.cwd())
+            fname = Path("new.txt")
+            fname.touch()
+            repo.git.add(str(fname))
+            repo.git.commit("-m", "new")
+            # Initialize the Coder object with the mocked IO and mocked repo
+            coder = Coder.create(models.GPT4, None, mock_io)
+            fname.write_text("hi")
+            self.assertTrue(coder.should_dirty_commit("hi"))
+            self.assertFalse(coder.should_dirty_commit("/exit"))
+            self.assertFalse(coder.should_dirty_commit("/help"))
+    def test_check_for_file_mentions(self):
+        # Mock the IO object
+        mock_io = MagicMock()
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, mock_io)
+        # Mock the git repo
+        mock = MagicMock()
+        mock.return_value = set(["file1.txt", "file2.py"])
+        coder.repo.get_tracked_files = mock
+        # Call the check_for_file_mentions method
+        coder.check_for_file_mentions("Please check file1.txt and file2.py")
+        # Check if coder.abs_fnames contains both files
+        expected_files = set(
+            map(
+                str,
+                [
+                    Path(coder.root) / "file1.txt",
+                    Path(coder.root) / "file2.py",
+                ],
+            )
+        )
+        self.assertEqual(coder.abs_fnames, expected_files)
+    def test_get_files_content(self):
+        tempdir = Path(tempfile.mkdtemp())
+        file1 = tempdir / "file1.txt"
+        file2 = tempdir / "file2.txt"
+        file1.touch()
+        file2.touch()
+        files = [file1, file2]
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, io=InputOutput(), fnames=files)
+        content = coder.get_files_content().splitlines()
+        self.assertIn("file1.txt", content)
+        self.assertIn("file2.txt", content)
+    def test_check_for_filename_mentions_of_longer_paths(self):
+        # Mock the IO object
+        mock_io = MagicMock()
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, mock_io)
+        mock = MagicMock()
+        mock.return_value = set(["file1.txt", "file2.py"])
+        coder.repo.get_tracked_files = mock
+        # Call the check_for_file_mentions method
+        coder.check_for_file_mentions("Please check file1.txt and file2.py")
+        # Check if coder.abs_fnames contains both files
+        expected_files = set(
+            map(
+                str,
+                [
+                    Path(coder.root) / "file1.txt",
+                    Path(coder.root) / "file2.py",
+                ],
+            )
+        )
+        self.assertEqual(coder.abs_fnames, expected_files)
+    def test_check_for_ambiguous_filename_mentions_of_longer_paths(self):
+        with GitTemporaryDirectory():
+            io = InputOutput(pretty=False, yes=True)
+            coder = Coder.create(models.GPT4, None, io)
+            fname = Path("file1.txt")
+            fname.touch()
+            other_fname = Path("other") / "file1.txt"
+            other_fname.parent.mkdir(parents=True, exist_ok=True)
+            other_fname.touch()
+            mock = MagicMock()
+            mock.return_value = set([str(fname), str(other_fname)])
+            coder.repo.get_tracked_files = mock
+            # Call the check_for_file_mentions method
+            coder.check_for_file_mentions(f"Please check {fname}!")
+            self.assertEqual(coder.abs_fnames, set([str(fname.resolve())]))
+    def test_check_for_subdir_mention(self):
+        with GitTemporaryDirectory():
+            io = InputOutput(pretty=False, yes=True)
+            coder = Coder.create(models.GPT4, None, io)
+            fname = Path("other") / "file1.txt"
+            fname.parent.mkdir(parents=True, exist_ok=True)
+            fname.touch()
+            mock = MagicMock()
+            mock.return_value = set([str(fname)])
+            coder.repo.get_tracked_files = mock
+            dump(fname)
+            # Call the check_for_file_mentions method
+            coder.check_for_file_mentions(f"Please check `{fname}`")
+            self.assertEqual(coder.abs_fnames, set([str(fname.resolve())]))
+    def test_run_with_file_deletion(self):
+        # Create a few temporary files
+        tempdir = Path(tempfile.mkdtemp())
+        file1 = tempdir / "file1.txt"
+        file2 = tempdir / "file2.txt"
+        file1.touch()
+        file2.touch()
+        files = [file1, file2]
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, io=InputOutput(), fnames=files)
+        def mock_send(*args, **kwargs):
+            coder.partial_response_content = "ok"
+            coder.partial_response_function_call = dict()
+        coder.send = MagicMock(side_effect=mock_send)
+        # Call the run method with a message
+        coder.run(with_message="hi")
+        self.assertEqual(len(coder.abs_fnames), 2)
+        file1.unlink()
+        # Call the run method again with a message
+        coder.run(with_message="hi")
+        self.assertEqual(len(coder.abs_fnames), 1)
+    def test_run_with_file_unicode_error(self):
+        # Create a few temporary files
+        _, file1 = tempfile.mkstemp()
+        _, file2 = tempfile.mkstemp()
+        files = [file1, file2]
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, io=InputOutput(), fnames=files)
+        def mock_send(*args, **kwargs):
+            coder.partial_response_content = "ok"
+            coder.partial_response_function_call = dict()
+        coder.send = MagicMock(side_effect=mock_send)
+        # Call the run method with a message
+        coder.run(with_message="hi")
+        self.assertEqual(len(coder.abs_fnames), 2)
+        # Write some non-UTF8 text into the file
+        with open(file1, "wb") as f:
+            f.write(b"\x80abc")
+        # Call the run method again with a message
+        coder.run(with_message="hi")
+        self.assertEqual(len(coder.abs_fnames), 1)
+    def test_choose_fence(self):
+        # Create a few temporary files
+        _, file1 = tempfile.mkstemp()
+        with open(file1, "wb") as f:
+            f.write(b"this contains ``` backticks")
+        files = [file1]
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, io=InputOutput(), fnames=files)
+        def mock_send(*args, **kwargs):
+            coder.partial_response_content = "ok"
+            coder.partial_response_function_call = dict()
+        coder.send = MagicMock(side_effect=mock_send)
+        # Call the run method with a message
+        coder.run(with_message="hi")
+        self.assertNotEqual(coder.fence[0], "```")
+    def test_run_with_file_utf_unicode_error(self):
+        "make sure that we honor InputOutput(encoding) and don't just assume utf-8"
+        # Create a few temporary files
+        _, file1 = tempfile.mkstemp()
+        _, file2 = tempfile.mkstemp()
+        files = [file1, file2]
+        encoding = "utf-16"
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(
+            models.GPT4,
+            None,
+            io=InputOutput(encoding=encoding),
+            fnames=files,
+        )
+        def mock_send(*args, **kwargs):
+            coder.partial_response_content = "ok"
+            coder.partial_response_function_call = dict()
+        coder.send = MagicMock(side_effect=mock_send)
+        # Call the run method with a message
+        coder.run(with_message="hi")
+        self.assertEqual(len(coder.abs_fnames), 2)
+        some_content_which_will_error_if_read_with_encoding_utf8 = "ÅÍÎÏ".encode(encoding)
+        with open(file1, "wb") as f:
+            f.write(some_content_which_will_error_if_read_with_encoding_utf8)
+        coder.run(with_message="hi")
+        # both files should still be here
+        self.assertEqual(len(coder.abs_fnames), 2)
+    @patch("aider.coders.base_coder.openai.ChatCompletion.create")
+    def test_run_with_invalid_request_error(self, mock_chat_completion_create):
+        # Mock the IO object
+        mock_io = MagicMock()
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, None, mock_io)
+        # Set up the mock to raise InvalidRequestError
+        mock_chat_completion_create.side_effect = openai.error.InvalidRequestError(
+            "Invalid request", "param"
+        )
+        # Call the run method and assert that InvalidRequestError is raised
+        with self.assertRaises(openai.error.InvalidRequestError):
+            coder.run(with_message="hi")
+    if __name__ == "__main__":
+        unittest.main()

testbed/Aider-AI__aider/tests/test_editblock.py ADDED Viewed

	@@ -0,0 +1,350 @@

+# flake8: noqa: E501
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+from aider import models
+from aider.coders import Coder
+from aider.coders import editblock_coder as eb
+from aider.dump import dump  # noqa: F401
+from aider.io import InputOutput
+class TestUtils(unittest.TestCase):
+    def setUp(self):
+        self.patcher = patch("aider.coders.base_coder.check_model_availability")
+        self.mock_check = self.patcher.start()
+        self.mock_check.return_value = True
+    def tearDown(self):
+        self.patcher.stop()
+    # fuzzy logic disabled v0.11.2-dev
+    def __test_replace_most_similar_chunk(self):
+        whole = "This is a sample text.\nAnother line of text.\nYet another line.\n"
+        part = "This is a sample text\n"
+        replace = "This is a replaced text.\n"
+        expected_output = "This is a replaced text.\nAnother line of text.\nYet another line.\n"
+        result = eb.replace_most_similar_chunk(whole, part, replace)
+        self.assertEqual(result, expected_output)
+    # fuzzy logic disabled v0.11.2-dev
+    def __test_replace_most_similar_chunk_not_perfect_match(self):
+        whole = "This is a sample text.\nAnother line of text.\nYet another line.\n"
+        part = "This was a sample text.\nAnother line of txt\n"
+        replace = "This is a replaced text.\nModified line of text.\n"
+        expected_output = "This is a replaced text.\nModified line of text.\nYet another line.\n"
+        result = eb.replace_most_similar_chunk(whole, part, replace)
+        self.assertEqual(result, expected_output)
+    def test_strip_quoted_wrapping(self):
+        input_text = (
+            "filename.ext\n```\nWe just want this content\nNot the filename and triple quotes\n```"
+        )
+        expected_output = "We just want this content\nNot the filename and triple quotes\n"
+        result = eb.strip_quoted_wrapping(input_text, "filename.ext")
+        self.assertEqual(result, expected_output)
+    def test_strip_quoted_wrapping_no_filename(self):
+        input_text = "```\nWe just want this content\nNot the triple quotes\n```"
+        expected_output = "We just want this content\nNot the triple quotes\n"
+        result = eb.strip_quoted_wrapping(input_text)
+        self.assertEqual(result, expected_output)
+    def test_strip_quoted_wrapping_no_wrapping(self):
+        input_text = "We just want this content\nNot the triple quotes\n"
+        expected_output = "We just want this content\nNot the triple quotes\n"
+        result = eb.strip_quoted_wrapping(input_text)
+        self.assertEqual(result, expected_output)
+    def test_find_original_update_blocks(self):
+        edit = """
+Here's the change:
+```text
+foo.txt
+<<<<<<< HEAD
+Two
+=======
+Tooooo
+>>>>>>> updated
+```
+Hope you like it!
+"""
+        edits = list(eb.find_original_update_blocks(edit))
+        self.assertEqual(edits, [("foo.txt", "Two\n", "Tooooo\n")])
+    def test_find_original_update_blocks_quote_below_filename(self):
+        edit = """
+Here's the change:
+foo.txt
+```text
+<<<<<<< HEAD
+Two
+=======
+Tooooo
+>>>>>>> updated
+```
+Hope you like it!
+"""
+        edits = list(eb.find_original_update_blocks(edit))
+        self.assertEqual(edits, [("foo.txt", "Two\n", "Tooooo\n")])
+    def test_find_original_update_blocks_unclosed(self):
+        edit = """
+Here's the change:
+```text
+foo.txt
+<<<<<<< HEAD
+Two
+=======
+Tooooo
+oops!
+"""
+        with self.assertRaises(ValueError) as cm:
+            list(eb.find_original_update_blocks(edit))
+        self.assertIn("Incomplete", str(cm.exception))
+    def test_find_original_update_blocks_missing_filename(self):
+        edit = """
+Here's the change:
+```text
+<<<<<<< HEAD
+Two
+=======
+Tooooo
+oops!
+"""
+        with self.assertRaises(ValueError) as cm:
+            list(eb.find_original_update_blocks(edit))
+        self.assertIn("filename", str(cm.exception))
+    def test_find_original_update_blocks_no_final_newline(self):
+        edit = """
+aider/coder.py
+<<<<<<< HEAD
+            self.console.print("[red]^C again to quit")
+=======
+            self.io.tool_error("^C again to quit")
+>>>>>>> updated
+aider/coder.py
+<<<<<<< HEAD
+            self.io.tool_error("Malformed ORIGINAL/UPDATE blocks, retrying...")
+            self.io.tool_error(err)
+=======
+            self.io.tool_error("Malformed ORIGINAL/UPDATE blocks, retrying...")
+            self.io.tool_error(str(err))
+>>>>>>> updated
+aider/coder.py
+<<<<<<< HEAD
+            self.console.print("[red]Unable to get commit message from gpt-3.5-turbo. Use /commit to try again.\n")
+=======
+            self.io.tool_error("Unable to get commit message from gpt-3.5-turbo. Use /commit to try again.")
+>>>>>>> updated
+aider/coder.py
+<<<<<<< HEAD
+            self.console.print("[red]Skipped commmit.")
+=======
+            self.io.tool_error("Skipped commmit.")
+>>>>>>> updated"""
+        # Should not raise a ValueError
+        list(eb.find_original_update_blocks(edit))
+    def test_incomplete_edit_block_missing_filename(self):
+        edit = """
+No problem! Here are the changes to patch `subprocess.check_output` instead of `subprocess.run` in both tests:
+```python
+tests/test_repomap.py
+<<<<<<< HEAD
+    def test_check_for_ctags_failure(self):
+        with patch("subprocess.run") as mock_run:
+            mock_run.side_effect = Exception("ctags not found")
+=======
+    def test_check_for_ctags_failure(self):
+        with patch("subprocess.check_output") as mock_check_output:
+            mock_check_output.side_effect = Exception("ctags not found")
+>>>>>>> updated
+<<<<<<< HEAD
+    def test_check_for_ctags_success(self):
+        with patch("subprocess.run") as mock_run:
+            mock_run.return_value = CompletedProcess(args=["ctags", "--version"], returncode=0, stdout='''{
+  "_type": "tag",
+  "name": "status",
+  "path": "aider/main.py",
+  "pattern": "/^    status = main()$/",
+  "kind": "variable"
+}''')
+=======
+    def test_check_for_ctags_success(self):
+        with patch("subprocess.check_output") as mock_check_output:
+            mock_check_output.return_value = '''{
+  "_type": "tag",
+  "name": "status",
+  "path": "aider/main.py",
+  "pattern": "/^    status = main()$/",
+  "kind": "variable"
+}'''
+>>>>>>> updated
+```
+These changes replace the `subprocess.run` patches with `subprocess.check_output` patches in both `test_check_for_ctags_failure` and `test_check_for_ctags_success` tests.
+"""
+        edit_blocks = list(eb.find_original_update_blocks(edit))
+        self.assertEqual(len(edit_blocks), 2)  # 2 edits
+        self.assertEqual(edit_blocks[0][0], "tests/test_repomap.py")
+        self.assertEqual(edit_blocks[1][0], "tests/test_repomap.py")
+    def test_replace_part_with_missing_varied_leading_whitespace(self):
+        whole = """
+    line1
+    line2
+        line3
+    line4
+"""
+        part = "line2\n    line3\n"
+        replace = "new_line2\n    new_line3\n"
+        expected_output = """
+    line1
+    new_line2
+        new_line3
+    line4
+"""
+        result = eb.replace_most_similar_chunk(whole, part, replace)
+        self.assertEqual(result, expected_output)
+    def test_replace_part_with_missing_leading_whitespace(self):
+        whole = "    line1\n    line2\n    line3\n"
+        part = "line1\nline2\n"
+        replace = "new_line1\nnew_line2\n"
+        expected_output = "    new_line1\n    new_line2\n    line3\n"
+        result = eb.replace_most_similar_chunk(whole, part, replace)
+        self.assertEqual(result, expected_output)
+    def test_replace_part_with_just_some_missing_leading_whitespace(self):
+        whole = "    line1\n    line2\n    line3\n"
+        part = " line1\n line2\n"
+        replace = " new_line1\n     new_line2\n"
+        expected_output = "    new_line1\n        new_line2\n    line3\n"
+        result = eb.replace_most_similar_chunk(whole, part, replace)
+        self.assertEqual(result, expected_output)
+    def test_replace_part_with_missing_leading_whitespace_including_blank_line(self):
+        """
+        The part has leading whitespace on all lines, so should be ignored.
+        But it has a *blank* line with no whitespace at all, which was causing a
+        bug per issue #25. Test case to repro and confirm fix.
+        """
+        whole = "    line1\n    line2\n    line3\n"
+        part = "\n  line1\n  line2\n"
+        replace = "  new_line1\n  new_line2\n"
+        expected_output = "    new_line1\n    new_line2\n    line3\n"
+        result = eb.replace_most_similar_chunk(whole, part, replace)
+        self.assertEqual(result, expected_output)
+    def test_full_edit(self):
+        # Create a few temporary files
+        _, file1 = tempfile.mkstemp()
+        with open(file1, "w", encoding="utf-8") as f:
+            f.write("one\ntwo\nthree\n")
+        files = [file1]
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(models.GPT4, "diff", io=InputOutput(), fnames=files)
+        def mock_send(*args, **kwargs):
+            coder.partial_response_content = f"""
+Do this:
+{Path(file1).name}
+<<<<<<< HEAD
+two
+=======
+new
+>>>>>>> updated
+"""
+            coder.partial_response_function_call = dict()
+        coder.send = MagicMock(side_effect=mock_send)
+        # Call the run method with a message
+        coder.run(with_message="hi")
+        content = Path(file1).read_text(encoding="utf-8")
+        self.assertEqual(content, "one\nnew\nthree\n")
+    def test_full_edit_dry_run(self):
+        # Create a few temporary files
+        _, file1 = tempfile.mkstemp()
+        orig_content = "one\ntwo\nthree\n"
+        with open(file1, "w", encoding="utf-8") as f:
+            f.write(orig_content)
+        files = [file1]
+        # Initialize the Coder object with the mocked IO and mocked repo
+        coder = Coder.create(
+            models.GPT4,
+            "diff",
+            io=InputOutput(dry_run=True),
+            fnames=files,
+            dry_run=True,
+        )
+        def mock_send(*args, **kwargs):
+            coder.partial_response_content = f"""
+Do this:
+{Path(file1).name}
+<<<<<<< HEAD
+two
+=======
+new
+>>>>>>> updated
+"""
+            coder.partial_response_function_call = dict()
+        coder.send = MagicMock(side_effect=mock_send)
+        # Call the run method with a message
+        coder.run(with_message="hi")
+        content = Path(file1).read_text(encoding="utf-8")
+        self.assertEqual(content, orig_content)
+if __name__ == "__main__":
+    unittest.main()

testbed/Aider-AI__aider/tests/test_io.py ADDED Viewed

	@@ -0,0 +1,24 @@

+import os
+import unittest
+from unittest.mock import patch
+from aider.io import AutoCompleter, InputOutput
+class TestInputOutput(unittest.TestCase):
+    def test_no_color_environment_variable(self):
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            io = InputOutput()
+            self.assertFalse(io.pretty)
+    def test_autocompleter_with_non_existent_file(self):
+        root = ""
+        rel_fnames = ["non_existent_file.txt"]
+        addable_rel_fnames = []
+        commands = None
+        autocompleter = AutoCompleter(root, rel_fnames, addable_rel_fnames, commands, "utf-8")
+        self.assertEqual(autocompleter.words, set(rel_fnames))
+if __name__ == "__main__":
+    unittest.main()

testbed/Aider-AI__aider/tests/test_main.py ADDED Viewed

	@@ -0,0 +1,180 @@

+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from unittest import TestCase
+from unittest.mock import patch
+import git
+from prompt_toolkit.input import DummyInput
+from prompt_toolkit.output import DummyOutput
+from aider.dump import dump  # noqa: F401
+from aider.io import InputOutput
+from aider.main import check_gitignore, main, setup_git
+from tests.utils import make_repo
+class TestMain(TestCase):
+    def setUp(self):
+        os.environ["OPENAI_API_KEY"] = "deadbeef"
+        self.original_cwd = os.getcwd()
+        self.tempdir = tempfile.mkdtemp()
+        os.chdir(self.tempdir)
+        self.patcher = patch("aider.coders.base_coder.check_model_availability")
+        self.mock_check = self.patcher.start()
+        self.mock_check.return_value = True
+    def tearDown(self):
+        os.chdir(self.original_cwd)
+        shutil.rmtree(self.tempdir, ignore_errors=True)
+        self.patcher.stop()
+    def test_main_with_empty_dir_no_files_on_command(self):
+        main(["--no-git"], input=DummyInput(), output=DummyOutput())
+    def test_main_with_empty_dir_new_file(self):
+        main(["foo.txt", "--yes", "--no-git"], input=DummyInput(), output=DummyOutput())
+        self.assertTrue(os.path.exists("foo.txt"))
+    @patch("aider.repo.GitRepo.get_commit_message", return_value="mock commit message")
+    def test_main_with_empty_git_dir_new_file(self, _):
+        make_repo()
+        main(["--yes", "foo.txt"], input=DummyInput(), output=DummyOutput())
+        self.assertTrue(os.path.exists("foo.txt"))
+    @patch("aider.repo.GitRepo.get_commit_message", return_value="mock commit message")
+    def test_main_with_empty_git_dir_new_files(self, _):
+        make_repo()
+        main(["--yes", "foo.txt", "bar.txt"], input=DummyInput(), output=DummyOutput())
+        self.assertTrue(os.path.exists("foo.txt"))
+        self.assertTrue(os.path.exists("bar.txt"))
+    def test_main_with_dname_and_fname(self):
+        subdir = Path("subdir")
+        subdir.mkdir()
+        make_repo(str(subdir))
+        res = main(["subdir", "foo.txt"], input=DummyInput(), output=DummyOutput())
+        self.assertNotEqual(res, None)
+    @patch("aider.repo.GitRepo.get_commit_message", return_value="mock commit message")
+    def test_main_with_subdir_repo_fnames(self, _):
+        subdir = Path("subdir")
+        subdir.mkdir()
+        make_repo(str(subdir))
+        main(
+            ["--yes", str(subdir / "foo.txt"), str(subdir / "bar.txt")],
+            input=DummyInput(),
+            output=DummyOutput(),
+        )
+        self.assertTrue((subdir / "foo.txt").exists())
+        self.assertTrue((subdir / "bar.txt").exists())
+    def test_main_with_git_config_yml(self):
+        make_repo()
+        Path(".aider.conf.yml").write_text("no-auto-commits: true\n")
+        with patch("aider.main.Coder.create") as MockCoder:
+            main(["--yes"], input=DummyInput(), output=DummyOutput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["auto_commits"] is False
+        Path(".aider.conf.yml").write_text("auto-commits: true\n")
+        with patch("aider.main.Coder.create") as MockCoder:
+            main([], input=DummyInput(), output=DummyOutput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["auto_commits"] is True
+    def test_main_with_empty_git_dir_new_subdir_file(self):
+        make_repo()
+        subdir = Path("subdir")
+        subdir.mkdir()
+        fname = subdir / "foo.txt"
+        fname.touch()
+        subprocess.run(["git", "add", str(subdir)])
+        subprocess.run(["git", "commit", "-m", "added"])
+        # This will throw a git error on windows if get_tracked_files doesn't
+        # properly convert git/posix/paths to git\posix\paths.
+        # Because aider will try and `git add` a file that's already in the repo.
+        main(["--yes", str(fname)], input=DummyInput(), output=DummyOutput())
+    def test_setup_git(self):
+        io = InputOutput(pretty=False, yes=True)
+        git_root = setup_git(None, io)
+        git_root = Path(git_root).resolve()
+        self.assertEqual(git_root, Path(self.tempdir).resolve())
+        self.assertTrue(git.Repo(self.tempdir))
+        gitignore = Path.cwd() / ".gitignore"
+        self.assertTrue(gitignore.exists())
+        self.assertEqual(".aider*", gitignore.read_text().splitlines()[0])
+    def test_check_gitignore(self):
+        make_repo()
+        io = InputOutput(pretty=False, yes=True)
+        cwd = Path.cwd()
+        gitignore = cwd / ".gitignore"
+        self.assertFalse(gitignore.exists())
+        check_gitignore(cwd, io)
+        self.assertTrue(gitignore.exists())
+        self.assertEqual(".aider*", gitignore.read_text().splitlines()[0])
+        gitignore.write_text("one\ntwo\n")
+        check_gitignore(cwd, io)
+        self.assertEqual("one\ntwo\n.aider*\n", gitignore.read_text())
+    def test_main_git_ignore(self):
+        cwd = Path().cwd()
+        self.assertFalse((cwd / ".git").exists())
+        self.assertFalse((cwd / ".gitignore").exists())
+        with patch("aider.main.Coder.create"):
+            main(["--yes"], input=DummyInput())
+        self.assertTrue((cwd / ".git").exists())
+        self.assertTrue((cwd / ".gitignore").exists())
+    def test_main_args(self):
+        with patch("aider.main.Coder.create") as MockCoder:
+            # --yes will just ok the git repo without blocking on input
+            # following calls to main will see the new repo already
+            main(["--no-auto-commits", "--yes"], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["auto_commits"] is False
+        with patch("aider.main.Coder.create") as MockCoder:
+            main(["--auto-commits"], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["auto_commits"] is True
+        with patch("aider.main.Coder.create") as MockCoder:
+            main([], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["dirty_commits"] is True
+            assert kwargs["auto_commits"] is True
+            assert kwargs["pretty"] is True
+        with patch("aider.main.Coder.create") as MockCoder:
+            main(["--no-pretty"], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["pretty"] is False
+        with patch("aider.main.Coder.create") as MockCoder:
+            main(["--pretty"], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["pretty"] is True
+        with patch("aider.main.Coder.create") as MockCoder:
+            main(["--no-dirty-commits"], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["dirty_commits"] is False
+        with patch("aider.main.Coder.create") as MockCoder:
+            main(["--dirty-commits"], input=DummyInput())
+            _, kwargs = MockCoder.call_args
+            assert kwargs["dirty_commits"] is True

testbed/Aider-AI__aider/tests/test_repo.py ADDED Viewed

	@@ -0,0 +1,196 @@

+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+import git
+from aider.dump import dump  # noqa: F401
+from aider.io import InputOutput
+from aider.repo import GitRepo
+from tests.utils import GitTemporaryDirectory
+class TestRepo(unittest.TestCase):
+    def test_diffs_empty_repo(self):
+        with GitTemporaryDirectory():
+            repo = git.Repo()
+            # Add a change to the index
+            fname = Path("foo.txt")
+            fname.write_text("index\n")
+            repo.git.add(str(fname))
+            # Make a change in the working dir
+            fname.write_text("workingdir\n")
+            git_repo = GitRepo(InputOutput(), None, ".")
+            diffs = git_repo.get_diffs(False)
+            self.assertIn("index", diffs)
+            self.assertIn("workingdir", diffs)
+    def test_diffs_nonempty_repo(self):
+        with GitTemporaryDirectory():
+            repo = git.Repo()
+            fname = Path("foo.txt")
+            fname.touch()
+            repo.git.add(str(fname))
+            fname2 = Path("bar.txt")
+            fname2.touch()
+            repo.git.add(str(fname2))
+            repo.git.commit("-m", "initial")
+            fname.write_text("index\n")
+            repo.git.add(str(fname))
+            fname2.write_text("workingdir\n")
+            git_repo = GitRepo(InputOutput(), None, ".")
+            diffs = git_repo.get_diffs(False)
+            self.assertIn("index", diffs)
+            self.assertIn("workingdir", diffs)
+    def test_diffs_between_commits(self):
+        with GitTemporaryDirectory():
+            repo = git.Repo()
+            fname = Path("foo.txt")
+            fname.write_text("one\n")
+            repo.git.add(str(fname))
+            repo.git.commit("-m", "initial")
+            fname.write_text("two\n")
+            repo.git.add(str(fname))
+            repo.git.commit("-m", "second")
+            git_repo = GitRepo(InputOutput(), None, ".")
+            diffs = git_repo.get_diffs(False, ["HEAD~1", "HEAD"])
+            dump(diffs)
+            self.assertIn("two", diffs)
+    @patch("aider.repo.simple_send_with_retries")
+    def test_get_commit_message(self, mock_send):
+        mock_send.return_value = "a good commit message"
+        repo = GitRepo(InputOutput(), None, None)
+        # Call the get_commit_message method with dummy diff and context
+        result = repo.get_commit_message("dummy diff", "dummy context")
+        # Assert that the returned message is the expected one
+        self.assertEqual(result, "a good commit message")
+    @patch("aider.repo.simple_send_with_retries")
+    def test_get_commit_message_strip_quotes(self, mock_send):
+        mock_send.return_value = '"a good commit message"'
+        repo = GitRepo(InputOutput(), None, None)
+        # Call the get_commit_message method with dummy diff and context
+        result = repo.get_commit_message("dummy diff", "dummy context")
+        # Assert that the returned message is the expected one
+        self.assertEqual(result, "a good commit message")
+    @patch("aider.repo.simple_send_with_retries")
+    def test_get_commit_message_no_strip_unmatched_quotes(self, mock_send):
+        mock_send.return_value = 'a good "commit message"'
+        repo = GitRepo(InputOutput(), None, None)
+        # Call the get_commit_message method with dummy diff and context
+        result = repo.get_commit_message("dummy diff", "dummy context")
+        # Assert that the returned message is the expected one
+        self.assertEqual(result, 'a good "commit message"')
+    def test_get_tracked_files(self):
+        # Create a temporary directory
+        tempdir = Path(tempfile.mkdtemp())
+        # Initialize a git repository in the temporary directory and set user name and email
+        repo = git.Repo.init(tempdir)
+        repo.config_writer().set_value("user", "name", "Test User").release()
+        repo.config_writer().set_value("user", "email", "testuser@example.com").release()
+        # Create three empty files and add them to the git repository
+        filenames = ["README.md", "subdir/fänny.md", "systemüber/blick.md", 'file"with"quotes.txt']
+        created_files = []
+        for filename in filenames:
+            file_path = tempdir / filename
+            try:
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                file_path.touch()
+                repo.git.add(str(file_path))
+                created_files.append(Path(filename))
+            except OSError:
+                # windows won't allow files with quotes, that's ok
+                self.assertIn('"', filename)
+                self.assertEqual(os.name, "nt")
+        self.assertTrue(len(created_files) >= 3)
+        repo.git.commit("-m", "added")
+        tracked_files = GitRepo(InputOutput(), [tempdir], None).get_tracked_files()
+        # On windows, paths will come back \like\this, so normalize them back to Paths
+        tracked_files = [Path(fn) for fn in tracked_files]
+        # Assert that coder.get_tracked_files() returns the three filenames
+        self.assertEqual(set(tracked_files), set(created_files))
+    def test_get_tracked_files_with_new_staged_file(self):
+        with GitTemporaryDirectory():
+            # new repo
+            raw_repo = git.Repo()
+            # add it, but no commits at all in the raw_repo yet
+            fname = Path("new.txt")
+            fname.touch()
+            raw_repo.git.add(str(fname))
+            git_repo = GitRepo(InputOutput(), None, None)
+            # better be there
+            fnames = git_repo.get_tracked_files()
+            self.assertIn(str(fname), fnames)
+            # commit it, better still be there
+            raw_repo.git.commit("-m", "new")
+            fnames = git_repo.get_tracked_files()
+            self.assertIn(str(fname), fnames)
+            # new file, added but not committed
+            fname2 = Path("new2.txt")
+            fname2.touch()
+            raw_repo.git.add(str(fname2))
+            # both should be there
+            fnames = git_repo.get_tracked_files()
+            self.assertIn(str(fname), fnames)
+            self.assertIn(str(fname2), fnames)
+    def test_get_tracked_files_from_subdir(self):
+        with GitTemporaryDirectory():
+            # new repo
+            raw_repo = git.Repo()
+            # add it, but no commits at all in the raw_repo yet
+            fname = Path("subdir/new.txt")
+            fname.parent.mkdir()
+            fname.touch()
+            raw_repo.git.add(str(fname))
+            os.chdir(fname.parent)
+            git_repo = GitRepo(InputOutput(), None, None)
+            # better be there
+            fnames = git_repo.get_tracked_files()
+            self.assertIn(str(fname), fnames)
+            # commit it, better still be there
+            raw_repo.git.commit("-m", "new")
+            fnames = git_repo.get_tracked_files()
+            self.assertIn(str(fname), fnames)