aider-ce 0.88.20__py3-none-any.whl

aider/website/docs/usage/conventions.md

@@ -0,0 +1,119 @@
+---
+parent: Usage
+nav_order: 800
+description: Tell aider to follow your coding conventions when it works on your code.
+---
+# Specifying coding conventions
+
+Sometimes you want GPT to be aware of certain coding guidelines,
+like whether to provide type hints, which libraries or packages
+to prefer, etc.
+
+The easiest way to do that with aider is to simply create
+a small markdown file and include it in the chat.
+
+For example, say we want our python code to:
+
+```
+- Prefer httpx over requests for making http requests.
+- Use types everywhere possible.
+```
+
+We would simply create a file like `CONVENTIONS.md` with those lines
+and then we can add it to the aider chat, along with the file(s)
+that we want to edit.
+
+It's best to load the conventions file with `/read CONVENTIONS.md` 
+or `aider --read CONVENTIONS.md`. 
+This way it is marked as read-only, and cached if prompt caching
+is enabled.
+
+## Community contributed conventions
+
+You can check the [aider conventions repository](https://github.com/Aider-AI/conventions)
+to find or contribute conventions files.
+
+## Always load conventions
+
+You can also configure aider to always load your conventions file
+in the [`.aider.conf.yml` config file](https://aider.chat/docs/config/aider_conf.html):
+
+
+```yaml
+# alone
+read: CONVENTIONS.md
+
+# multiple files
+read: [CONVENTIONS.md, anotherfile.txt]
+```
+
+
+## Example
+
+See below for an example of how the conventions can affect the code
+that aider writes.
+
+<div class="chat-transcript" markdown="1">
+> $ aider --read CONVENTIONS.md useragent.py  
+>  
+> Aider v0.24.2-dev  
+> Added CONVENTIONS.md to the chat.  
+> Added useragent.py to the chat.  
+
+#### write a function that uses httpbin to check the user agent on the request. return the ua.  
+
+To fulfill your request, I will:
+
+1. Add an import for `httpx`.
+2. Write a function named `check_user_agent` that makes a GET request to `httpbin.org/user-agent` and returns the user agent string.
+
+Here is the diff for the `useragent.py` file:
+
+```diff
+--- useragent.py
++++ useragent.py
+@@ ... @@
++import httpx
++
++def check_user_agent() -> str:
++    response = httpx.get('https://httpbin.org/user-agent')
++    return response.json()['user-agent']
+```
+
+This function uses `httpx` to make a GET request to `httpbin.org/user-agent`, which returns a JSON response containing the user agent of the HTTP client. The function then extracts the user agent string from the JSON response and returns it.
+
+> Applied edit to useragent.py  
+</div>
+
+GPT correctly used `httpx` and provided type hints.
+See below for the transcript of this same
+coding task conducted *without*
+using `CONVENTIONS.md`.
+In this case, GPT used `requests` and skipped types,
+which is perhaps more typical in small python scripts.
+
+<div class="chat-transcript" markdown="1">
+> $ aider useragent.py  
+>  
+> Aider v0.24.2-dev  
+> Added useragent.py to the chat.  
+
+
+#### write a function that uses httpbin to check the user agent on the request. return the ua.  
+
+```diff
+--- /dev/null
++++ useragent.py
+@@ ... @@
++import requests
++
++def check_user_agent():
++    response = requests.get('https://httpbin.org/user-agent')
++    user_agent = response.json().get('user-agent')
++    return user_agent
+```
+
+> Applied edit to useragent.py  
+</div>
+
+

aider/website/docs/usage/copypaste.md

@@ -0,0 +1,121 @@
+---
+title: Copy/paste with web chat
+#highlight_image: /assets/browser.jpg
+parent: Usage
+nav_order: 850
+description: Aider works with LLM web chat UIs
+---
+
+# Copy/paste with web chat
+
+<div class="video-container">
+  <video controls loop poster="/assets/copypaste.jpg">
+    <source src="/assets/copypaste.mp4" type="video/mp4">
+    <a href="/assets/copypaste.mp4">Aider browser UI demo video</a>
+  </video>
+</div>
+
+<style>
+.video-container {
+  position: relative;
+  padding-bottom: 66.34%; /* 2160 / 3256 = 0.6634 */
+  height: 0;
+  overflow: hidden;
+}
+
+.video-container video {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+</style>
+
+## Working with an LLM web chat
+
+[Aider can connect to most LLMs via API](https://aider.chat/docs/llms.html) and works best that way.
+But there are times when you may want to work with an LLM via its web chat interface:
+
+- Workplace policies may limit your LLM usage to a proprietary web chat system.
+- The web chat LLM may have access to unique context or may have been specially fine tuned for your task.
+- It may be cost prohibitive to use some models via API.
+- There may not be an API available.
+
+Aider has features for working with an LLM via its web chat interface.
+This allows you to use the web chat LLM as the "big brain code architect"
+while running aider with a smaller, cheaper LLM to actually make changes
+to your local files.
+
+For this "file editor" part of the process 
+you can run aider with many open source, free or very inexpensive LLMs.
+For example, the demo video above shows aider using DeepSeek to apply the changes
+that o1-preview is suggesting in the web chat.
+
+### Copy aider's code context to your clipboard, paste into the web UI
+
+The `/copy-context <instructions>` command can be used in chat to copy aider's code context to your clipboard.
+It will include:
+
+- All the files which have been added to the chat via `/add`.
+- Any read only files which have been added via `/read`.
+- Aider's [repository map](https://aider.chat/docs/repomap.html) that brings in code context related to the above files from elsewhere in your git repo.
+- Some instructions to the LLM that ask it to output change instructions concisely.
+- If you include `<instructions>`, they will be copied too.
+
+You can paste the context into your browser, and start interacting with the LLM web chat to
+ask for code changes.
+
+### Paste the LLM's reply back into aider to edit your files
+
+Once the LLM has replied, you can use the "copy response" button in the web UI to copy
+the LLM's response.
+Back in aider, you can run `/paste` and aider will edit your files
+to implement the changes suggested by the LLM.
+
+You can use a cheap, efficient model like GPT-4o Mini, DeepSeek or Qwen to do these edits.
+This works best if you run aider with `--edit-format editor-diff` or `--edit-format editor-whole`.
+
+### Copy/paste mode
+
+Aider has a `--copy-paste` mode that streamlines this entire process:
+
+- Whenever you `/add` or `/read` files, aider will automatically copy the entire, updated
+code context to your clipboard. 
+You'll see "Copied code context to clipboard" whenever this happens.
+- When you copy the LLM reply to your clipboard outside aider, aider will automatically notice
+and load it into the aider chat. 
+Just press ENTER to send the message
+and aider will apply the LLMs changes to your local files.
+- Aider will automatically select the best edit format for this copy/paste functionality. 
+Depending on the LLM you have aider use, it will be either `editor-whole` or `editor-diff`.
+
+## Terms of service
+
+Be sure to review the Terms Of Service of any LLM web chat service you use with
+these features.
+These features are not intended to be used in violation of any service's Terms Of Service (TOS).
+
+Aider's web chat features have been designed to be compliant with the 
+terms of service of most LLM web chats.
+
+There are 4 copy/paste steps involved when coding with an LLM web chat:
+
+1. Copy code and context from aider.
+2. Paste the code and context into the LLM web chat.
+3. Copy the reply from the LLM web chat.
+4. Paste the LLM reply into aider.
+
+Most LLM web chat TOS prohibit automating steps (2) and (3) where code
+is copied from and pasted into the web chat.
+Aider's `--copy-paste` mode leaves those as 100% manual steps for the user to complete.
+It simply streamlines steps (1) and (4) that are interactions with aider,
+and which should not be under the scope of an LLM web chat TOS.
+
+If you are concerned that
+the automatic interactions with aider in steps (1) and (4) may be problematic with respect to
+your LLM web chat provider's TOS, you can forego `--copy-paste` mode.
+Instead, manually use the `/copy-context` and `/paste` commands if that
+will keep you in compliance.
+
+Again, do not use these features in violation of any service's Terms Of Service.

aider/website/docs/usage/images-urls.md

@@ -0,0 +1,48 @@
+---
+parent: Usage
+nav_order: 700
+description: Add images and web pages to the aider coding chat.
+---
+
+# Images & web pages
+
+You can add images and URLs to the aider chat.
+
+## Images
+
+Aider supports working with image files for many vision-capable models
+like GPT-4o and Claude 3.7 Sonnet.
+Adding images to a chat can be helpful in many situations:
+
+- Add screenshots of web pages or UIs that you want aider to build or modify.
+- Show aider a mockup of a UI you want to build.
+- Screenshot an error message that is otherwise hard to copy & paste as text.
+- Etc.
+
+You can add images to the chat just like you would
+add any other file:
+
+- Use `/add <image-filename>` from within the chat
+- Use `/paste` to paste an image from your clipboard into the chat.
+- Launch aider with image filenames on the command line: `aider <image-filename>` along with any other command line arguments you need.
+
+## Web pages
+
+Aider can scrape the text from URLs and add it to the chat.
+This can be helpful to:
+
+- Include documentation pages for less popular APIs.
+- Include the latest docs for libraries or packages that are newer than the model's training cutoff date.
+- Etc.
+
+To add URLs to the chat:
+
+- Use `/web <url>`
+- Just paste the URL into the chat and aider will ask if you want to add it.
+
+You can also scrape web pages from the command line to see the markdown version that aider produces:
+
+
+```
+python -m aider.scrape https://aider.chat/docs/usage/tips.html
+```

aider/website/docs/usage/lint-test.md

@@ -0,0 +1,118 @@
+---
+parent: Usage
+nav_order: 900
+description: Automatically fix linting and testing errors.
+---
+
+# Linting and testing
+
+Aider can automatically lint and test your code
+every time it makes changes.
+This helps identify and repair any problems introduced
+by the AI edits.
+
+## Linting
+
+Aider comes with built in linters for 
+[most popular languages](/docs/languages.html)
+and will automatically lint code in these languages.
+
+Or you can specify your favorite linter
+with the `--lint-cmd <cmd>` switch.
+The lint command should accept the filenames
+of the files to lint. 
+If there are linting errors, aider expects the
+command to print them on stdout/stderr
+and return a non-zero exit code.
+This is how most linters normally operate.
+
+By default, aider will lint any files which it edits.
+You can disable this with the `--no-auto-lint` switch.
+
+### Per-language linters
+
+To specify different linters based on the code language, use `--lint "language: cmd"`.
+
+### Code formatting "linters"
+
+Many people use code formatters as linters, to format and pretty their code.
+These tools sometimes return non-zero exit codes if they make changes, which will
+confuse aider into thinking there's an actual lint error that needs to be fixed.
+
+You can use formatters by wrapping them in a shell script like this and setting
+the script as your linter.
+
+```bash
+#!/bin/bash
+
+# Run it twice.
+#
+# First attempt may reformat/modify files, and therefore exit with non-zero status.
+#
+# Second attempt will not do anything and exit 0 unless there's a real problem beyond
+# the code formatting that was completed.
+
+pre-commit run --files "$@" >/dev/null \
+    || pre-commit run --files "$@"
+```
+
+## Testing
+
+You can run tests with `/test <test-command>`.
+Aider will run the test command without any arguments.
+If there are test errors, aider expects the
+command to print them on stdout/stderr
+and return a non-zero exit code.
+
+Aider will try and fix any errors
+if the command returns a non-zero exit code.
+
+You can configure aider to run your test suite
+after each time the AI edits your code
+using the `--test-cmd <test-command>` and
+`--auto-test` switch.
+
+
+
+## Compiled languages
+
+If you want to have aider compile code after each edit, you
+can use the lint and test commands to achieve this.
+
+- You might want to recompile each file which was modified
+to check for compile errors.
+To do this,
+provide a `--lint-cmd` which both lints and compiles the file.
+You could create a small shell script for this.
+- You might want to rebuild the entire project after files
+are edited to check for build errors.
+To do this,
+provide a `--test-cmd` which both builds and tests the project.
+You could create a small shell script for this.
+Or you may be able to do something as simple as
+`--test-cmd "dotnet build && dotnet test"`.
+
+## Manually running code
+
+You can use the `/run` command in the chat to run your code
+and optionally share the output with aider.
+This can be useful to share error messages or to show aider
+the code's output before asking for changes or corrections.
+
+<div class="chat-transcript" markdown="1">
+> Aider v0.43.5-dev  
+
+#### /run python myscript.py
+
+```
+Traceback (most recent call last):  
+ File "myscript.py", line 22, in \<module\ 
+   raise ValueError("something bad happened")  
+ValueError: something bad happened  
+```
+
+> Add the output to the chat? y  
+
+</div>
+
+

aider/website/docs/usage/modes.md

@@ -0,0 +1,211 @@
+---
+parent: Usage
+nav_order: 60
+description: Using the code, architect, ask and help chat modes.
+---
+
+# Chat modes
+
+Aider has a few different chat modes:
+
+- `code` - Aider will make changes to your code to satisfy your requests.
+- `ask` - Aider will discuss your code and answer questions about it, but never make changes.
+- `architect` - Like code mode, aider will change your files. An architect model will propose changes and an editor model will translate that proposal into specific file edits.
+- `help` - Aider will answer questions about aider: usage, configuration, troubleshooting, etc.
+
+By default, aider starts in "code" mode. As you are talking, you can
+send individual messages in a specific mode using 
+`/code`, `/architect`, `/ask`, and `/help` commands:
+Using these `/`-commands applies just to that particular message.
+Your next message will go back to the active mode (usually "code" mode by default).
+
+You can switch the active mode in a sticky way
+with the `/chat-mode <mode>` command:
+
+```
+/chat-mode code
+/chat-mode architect
+/chat-mode ask
+/chat-mode help
+```
+
+Or you can switch between coding modes using these commands without arguments:
+
+```
+/code
+/architect
+/ask
+```
+
+Or you can launch aider in one of the modes with the `--chat-mode <mode>` switch.
+There is also a special shortcut `--architect` to launch in `--chat-mode architect`.
+
+The aider prompt will indicate the active mode:
+
+```
+> This is code mode.
+ask> This is ask mode.
+architect> This is architect mode.
+```
+
+
+## Ask/code workflow
+
+A recommended workflow is to bounce back and forth between `/ask` and `/code` modes.
+
+Use ask mode to discuss what you want to do, get suggestions or options from aider
+and provide feedback on the approach.
+Once aider understands the mission, switch to code mode to have it start editing
+your files.
+All the conversation and decision making from ask mode will
+help ensure that the correct code changes are performed.
+
+You can be very terse when you finally switch from ask to code mode.
+Saying something as simple as "go ahead" in code mode will
+have aider execute on the plan you've been discussing.
+
+Here's an example with two ask mode messages to agree on the plan, 
+followed by two terse code mode messages to edit the code.
+
+````
+─────────────────────────────────────────────────────────────────────────────────────
+Aider v0.79.0
+Model: gemini/gemini-2.5-pro-exp-03-25 with diff-fenced edit format
+
+> /ask What's the best thing to print if we're making a quick little demo program?
+
+It sounds like you'd like to write a "Hello, world!" program. That's a very
+popular phrase to use for small demo programs.
+
+> /ask Yes, that's the idea. What are some more creative options?
+
+1. "Greetings, Earthlings!"
+2. "Beep boop, I am a computer!"
+3. "To code, or not to code, that is the question."
+4. "I think, therefore I print."
+5. "01001000 01101001!" (Binary for "Hi!")
+
+> do 4
+
+hello.py
+>>>>>>> SEARCH
+=======
+def main():
+    print("I think, therefore I print.")
+<<<<<<< REPLACE
+
+> ALL CAPS!
+
+hello.py
+>>>>>>> SEARCH
+    print("I think, therefore I print.")
+=======
+    print("I THINK, THEREFORE I PRINT!")
+<<<<<<< REPLACE
+
+````
+
+You can think of this ask/code workflow as a more fluid version of
+architect mode, but working just with one model the whole time.
+
+## Architect mode and the editor model
+
+When you are in architect mode, aider sends your requests to two models:
+
+1. First, it sends your request to the main model which will act as an architect
+to propose how to solve your coding request.
+The main model is configured with `/model` or `--model`.
+
+2. Aider then sends another request to an "editor model",
+asking it to turn the architect's proposal into specific file editing instructions.
+Aider has built in defaults to select an editor model based on your main model.
+Or, you can choose a specific editor model with `--editor-model <model>`.
+
+Certain LLMs aren't able to propose coding solutions *and*
+specify detailed file edits all in one go.
+For these models, architect mode can produce better results than code mode
+by pairing them
+with an editor model that is responsible for generating the file editing instructions.
+But this uses two LLM requests,
+which can take longer and increase costs.
+
+Architect mode is especially useful with OpenAI's o1 models, which are strong at
+reasoning but less capable at editing files.
+Pairing an o1 architect with an editor model like GPT-4o or Sonnet will
+give the best results.
+
+But architect mode can also be helpful when you use the same model
+as both the architect and the editor.
+Allowing the model two requests to solve the problem and edit the files
+can sometimes provide better results.
+
+The editor model uses one of aider's edit formats to let the LLM
+edit source files.
+Aider will pick a suitable edit format by default,
+but you can customize it with `--editor-edit-format <format>`.
+The 
+["editor-diff" and "editor-whole" edit formats](/docs/more/edit-formats.html#editor-diff-and-editor-whole)
+are the recommended edit formats when using architect mode.
+See this article on 
+[aider's architect/editor mode](/2024/09/26/architect.html)
+for more details.
+
+
+## Examples
+
+<div class="chat-transcript" markdown="1">
+
+
+> Aider v0.47.1-dev  
+> Models: claude-3-5-sonnet-20240620 with diff edit format  
+> Git repo: .git with 298 files  
+> Repo-map: using 1024 tokens  
+> Use /help to see in-chat commands, run with --help to see cmd line args  
+
+#### /ask What is this repo?
+
+This is collection of python functions that compute various math functions.
+
+#### /help How do I use aider with ollama?
+
+Run `aider --model ollama/<ollama-model>`.
+See these docs for more info: https://aider.chat/docs/llms/ollama.html
+
+#### /code Add a function to calculate the factorial of a number
+
+Certainly! I'll add a function to calculate the factorial of a number. Here's the change:
+
+```python
+def factorial(n):
+    if n == 0 or n == 1:
+        return 1
+    else:
+        return n * factorial(n - 1)
+
+# Example usage
+print(factorial(5))  # Output: 120
+```
+
+This function uses recursion to calculate the factorial. It's been added to your code.
+
+#### /architect Can we make this simpler?
+
+Yes, you could replace the `factorial()` function with a call to the `math.factorial()`
+builtin. 
+This way you don't have to maintain a custom factorial implementation,
+and the builtin function is well optimized.
+
+```python
+<<<<<<< SEARCH
+def factorial(n):
+    if n == 0 or n == 1:
+        return 1
+    else:
+        return n * factorial(n - 1)
+=======
+from math import factorial
+>>>>>>> REPLACE
+```
+
+</div>
+