chatmcp-cli 0.1.0__py3-none-any.whl

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

aider/website/docs/usage/not-code.md

@@ -0,0 +1,179 @@
+---
+parent: Usage
+nav_order: 901
+description: Use aider to edit configuration files, documentation, and other text-based formats.
+---
+
+
+# Editing config & text files
+
+Aider isn't just for code, it can be very helpful when editing
+almost any text file.
+You can use aider to make changes to your shell & ssh settings, 
+Dockerfiles
+or pretty much any configuration or documentation file.
+
+Here are some practical examples of modifying common config/text files:
+
+## Shell Configuration
+
+<div class="chat-transcript" markdown="1">
+$ aider .bashrc
+
+Added .bashrc to the chat.
+
+
+#### Add an alias 'll' that lists all files, with all details in human readable format. And update PATH to include uv installed tools.
+
+```
++ alias ll='ls -alh'
++ export PATH="$PATH:$HOME/.local/bin:$PATH"
+```
+</div>
+
+## SSH Configurations
+
+<div class="chat-transcript" markdown="1">
+$ aider ~/.ssh/config
+
+Added config to the chat.
+
+#### Create a Host entry 'my-server' using bastion.example.com as JumpHost
+
+```
++ Host my-server
++     HostName 192.168.1.100
++     User deploy
++     Port 2222
++     IdentityFile ~/.ssh/deploy_key
++     ProxyJump bastion.example.com
+```
+</div>
+
+## Docker Setup
+
+<div class="chat-transcript" markdown="1">
+$ aider Dockerfile docker-compose.yml
+
+Added Dockerfile and docker-compose.yml to the chat.
+
+#### Set non-root user and enable healthchecks
+
+```
++ USER appuser
++ HEALTHCHECK --interval=30s --timeout=3s \
++   CMD curl -f http://localhost:8000/health || exit 1
+```
+
+#### Expose port 5432 and add volume for postgres data
+
+```
+  services:
+    postgres:
+      image: postgres:15
++     ports:
++       - "5432:5432"
++     volumes:
++       - pgdata:/var/lib/postgresql/data
+```
+</div>
+
+## Git Configuration
+
+<div class="chat-transcript" markdown="1">
+$ aider .gitconfig
+
+Added .gitconfig to the chat.
+
+#### Set default push behavior to current branch and enable color UI
+
+```
++ [push]
++     default = current
++ [color]
++     ui = auto
+```
+</div>
+
+## System Configuration
+<div class="chat-transcript" markdown="1">
+$ aider /etc/hosts  # May need sudo
+
+Added hosts to the chat.
+
+#### Block tracking domains by pointing them to 127.0.0.1
+
+```
++ 127.0.0.1   ads.example.com
++ 127.0.0.1   track.analytics.co
+```
+</div>
+
+
+## Editor Configs
+<div class="chat-transcript" markdown="1">
+$ aider .vimrc
+
+Added .vimrc to the chat.
+
+#### Enable line numbers and set 4-space tabs for Python
+
+```
++ set number
++ autocmd FileType python set tabstop=4 shiftwidth=4 expandtab
+```
+</div>
+
+## VSCode Configuration
+<div class="chat-transcript" markdown="1">
+$ aider settings.json
+
+Added settings.json to the chat.
+
+#### Enable auto-format on save and set default formatter
+
+```
++ "editor.formatOnSave": true,
++ "editor.defaultFormatter": "esbenp.prettier-vscode"
+```
+</div>
+
+## Markdown Documentation
+<div class="chat-transcript" markdown="1">
+$ aider README.md
+
+Added README.md to the chat.
+
+
+#### Add installation section with brew and pip options
+
+```
++ ## Installation
++ ```
++ # Homebrew
++ brew install cool-app-10k
++ 
++ # PyPI
++ pipx install cool-app-10k
++ ```
+```
+</div>
+
+## XML Configuration
+<div class="chat-transcript" markdown="1">
+$ aider pom.xml
+
+Added pom.xml to the chat.
+#### Add JUnit 5 dependency with test scope
+
+```
++ <dependency>
++     <groupId>org.junit.jupiter</groupId>
++     <artifactId>junit-jupiter-api</artifactId>
++     <version>5.9.2</version>
++     <scope>test</scope>
++ </dependency>
+```
+</div>
+
+

aider/website/docs/usage/notifications.md

@@ -0,0 +1,87 @@
+---
+title: Notifications
+highlight_image: /assets/notifications.jpg
+parent: Usage
+nav_order: 760
+description: Aider can notify you when it's waiting for your input.
+---
+
+# Notifications
+
+Aider can notify you when it's done working and is
+waiting for your input. 
+This is especially useful for long-running operations or when you're multitasking.
+
+## Usage
+
+Enable notifications with the `--notifications` flag:
+
+```bash
+aider --notifications
+```
+
+When enabled, aider will notify you when the LLM has finished generating a response and is waiting for your input.
+
+## OS-Specific Notifications
+
+Aider automatically detects your operating system and uses an appropriate notification method:
+
+- **macOS**: Uses `terminal-notifier` if available, falling back to AppleScript notifications
+- **Linux**: Uses `notify-send` or `zenity` if available
+- **Windows**: Uses PowerShell to display a message box
+
+## Custom Notification Commands
+
+You can specify a custom notification command with `--notifications-command`:
+
+```bash
+aider --notifications-command "your-custom-command"
+```
+
+For example, on macOS you might use:
+
+```bash
+aider --notifications-command "say 'Aider is ready'"
+```
+
+### Remote Notifications
+
+For remote notifications you could use [Apprise](https://github.com/caronc/apprise),
+which is a cross-platform Python library for sending notifications to various services.
+
+We can use Apprise to send notifications to Slack
+
+```bash
+aider --notifications-command "apprise -b 'Aider is ready' 'slack://your-slack-webhook-token'"
+```
+
+or Discord
+```bash
+aider --notifications-command "apprise -b 'Aider is ready' 'discord://your-discord-webhook-token'"
+```
+
+or even to your phone via Pushbullet
+```bash
+aider --notifications-command "apprise -b 'Aider is ready' 'pbul://your-pushbullet-access-token'"
+```
+
+Check more how to use and configure Apprise on their GitHub page.
+
+## Configuration
+
+You can add these settings to your configuration file:
+
+```yaml
+# Enable notifications
+notifications: true
+
+# Optional custom notification command
+notifications_command: "your-custom-command"
+```
+
+Or in your `.env` file:
+
+```
+AIDER_NOTIFICATIONS=true
+AIDER_NOTIFICATIONS_COMMAND=your-custom-command
+```