chatmcp-cli 0.1.0__py3-none-any.whl

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

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

aider/website/docs/recordings/index.md

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

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

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

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

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

aider/website/docs/repomap.md

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

aider/website/docs/scripting.md

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

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

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

aider/website/docs/troubleshooting/edit-errors.md

@@ -0,0 +1,76 @@
+---
+parent: Troubleshooting
+nav_order: 10
+---
+
+# File editing problems
+
+Sometimes the LLM will reply with some code changes
+that don't get applied to your local files.
+In these cases, aider might say something like "Failed to apply edit to *filename*"
+or other error messages.
+
+This usually happens because the LLM is disobeying the system prompts
+and trying to make edits in a format that aider doesn't expect.
+Aider makes every effort to get the LLM
+to conform, and works hard to deal with
+LLM edits that are "almost" correctly formatted.
+
+But sometimes the LLM just won't cooperate.
+In these cases, here are some things you might try.
+
+## Don't add too many files
+
+Many LLMs now have very large context windows,
+but filling them with irrelevant code or conversation 
+can confuse the model.
+Above about 25k tokens of context, most models start to become distracted and become less likely
+to conform to their system prompt.
+
+- Don't add too many files to the chat, *just* add the files you think need to be edited.
+Aider also sends the LLM a [map of your entire git repo](https://aider.chat/docs/repomap.html), so other relevant code will be included automatically.
+- Use `/drop` to remove files from the chat session which aren't needed for the task at hand. This will reduce distractions and may help the LLM produce properly formatted edits.
+- Use `/clear` to remove the conversation history, again to help the LLM focus.
+- Use `/tokens` to see how many tokens you are using for each message.
+
+## Use a more capable model
+
+If possible try using GPT-4o, o3-mini, Claude 3.7 Sonnet, DeepSeek V3 or DeepSeek R1.
+They are the strong and capable models.
+
+Weaker models
+are more prone to
+disobeying the system prompt instructions.
+Most local models are just barely capable of working with aider,
+so editing errors are probably unavoidable.
+
+## Local models: context window and quantization
+
+Be especially careful about the
+[Ollama context window](https://aider.chat/docs/llms/ollama.html#setting-the-context-window-size)
+when working with local models.
+It defaults to be very small and silently discards data if you exceed it.
+
+Local models which have been quantized are more likely to have editing problems
+because they are not capable enough to follow aider's system prompts.
+
+## Try the whole edit format
+
+Run aider with `--edit-format whole` if were using a different edit format.
+You can see which edit format it is using in the announce lines:
+
+```
+Aider v0.50.2-dev
+Models: claude-3-5-sonnet-20240620 with ♾️ diff edit format
+```
+
+## Try architect mode
+
+Run aider with `--architect` or `/chat-mode architect` to enable [architect mode](../usage/modes.md#architect-mode-and-the-editor-model).
+This mode first proposes changes, then uses a separate model to handle the file edits.
+This two-step process often produces more reliable edits, especially with models that have trouble
+following edit format instructions.
+
+## More help
+
+{% include help.md %}

aider/website/docs/troubleshooting/imports.md

@@ -0,0 +1,62 @@
+---
+parent: Troubleshooting
+nav_order: 28
+---
+
+# Dependency versions
+
+Aider expects to be installed with the
+correct versions of all of its required dependencies.
+
+If you've been linked to this doc from a GitHub issue, 
+or if aider is reporting `ImportErrors`
+it is likely that your
+aider install is using incorrect dependencies.
+
+
+## Avoid package conflicts
+
+If you are using aider to work on a python project, sometimes your project will require
+specific versions of python packages which conflict with the versions that aider
+requires.
+If this happens, you may see errors like these when running pip installs:
+
+```
+aider-chat 0.23.0 requires somepackage==X.Y.Z, but you have somepackage U.W.V which is incompatible.
+```
+
+## Install with aider-install, uv or pipx
+
+If you are having dependency problems you should consider
+[installing aider using aider-install, uv or pipx](/docs/install.html).
+This will ensure that aider is installed in its own python environment,
+with the correct set of dependencies.
+
+## Package managers like Homebrew, AUR, ports
+
+Package managers often install aider with the wrong dependencies, leading
+to import errors and other problems.
+
+It is recommended to
+[install aider using aider-install, uv or pipx](/docs/install.html).
+
+
+## Dependency versions matter
+
+Aider pins its dependencies and is tested to work with those specific versions.
+If you are installing aider directly with pip
+you should be careful about upgrading or downgrading the python packages that
+aider uses.
+
+In particular, be careful with the packages with pinned versions 
+noted at the end of
+[aider's requirements.in file](https://github.com/Aider-AI/aider/blob/main/requirements/requirements.in).
+These versions are pinned because aider is known not to work with the
+latest versions of these libraries.
+
+Also be wary of upgrading `litellm`, as it changes versions frequently
+and sometimes introduces bugs or backwards incompatible changes.
+
+## Replit
+
+{% include replit-pipx.md %}

aider/website/docs/troubleshooting/models-and-keys.md

@@ -0,0 +1,54 @@
+---
+parent: Troubleshooting
+nav_order: 28
+---
+
+# Models and API keys
+
+Aider needs to know which LLM model you would like to work with and which keys
+to provide when accessing it via API.
+
+## Defaults
+
+If you don't explicitly name a model, aider will try to select a model
+for you to work with.
+
+First, aider will check which 
+[keys you have provided via the environment, config files, or command line arguments](https://aider.chat/docs/config/api-keys.html).
+Based on the available keys, aider will select the best model to use.
+
+## OpenRouter
+
+If you have not provided any keys, aider will offer to help you connect to 
+[OpenRouter](http://openrouter.ai)
+which provides both free and paid access to most popular LLMs.
+Once connected, aider will select the best model available on OpenRouter
+based on whether you have a free or paid account there.
+
+## Specifying model & key
+
+You can also tell aider which LLM to use and provide an API key.
+The easiest way is to use the `--model` and `--api-key`
+command line arguments, like this:
+
+```
+# Work with DeepSeek via DeepSeek's API
+aider --model deepseek --api-key deepseek=your-key-goes-here
+
+# Work with Claude 3.7 Sonnet via Anthropic's API
+aider --model sonnet --api-key anthropic=your-key-goes-here
+
+# Work with o3-mini via OpenAI's API
+aider --model o3-mini --api-key openai=your-key-goes-here
+
+# Work with Sonnet via OpenRouter's API
+aider --model openrouter/anthropic/claude-3.7-sonnet --api-key openrouter=your-key-goes-here
+
+# Work with DeepSeek Chat V3 via OpenRouter's API
+aider --model openrouter/deepseek/deepseek-chat --api-key openrouter=your-key-goes-here
+```
+
+For more information, see the documentation sections:
+
+- [Connecting to LLMs](https://aider.chat/docs/llms.html)
+- [Configuring API keys](https://aider.chat/docs/config/api-keys.html)