chatmcp-cli 0.1.0__py3-none-any.whl

aider/website/docs/usage/tips.md

@@ -0,0 +1,79 @@
+---
+parent: Usage
+nav_order: 25
+description: Tips for AI pair programming with aider.
+---
+
+# Tips
+
+## Just add the files that need to be changed to the chat
+
+Take a moment and think about which files will need to be changed.
+Aider can often figure out which files to edit all by itself, but the most efficient approach is for you to add the files to the chat.
+
+## Don't add lots of files to the chat
+
+Just add the files you think need to be edited.
+Too much irrelevant code will distract and confuse the LLM.
+Aider uses a [map of your entire git repo](https://aider.chat/docs/repomap.html)
+so is usually aware of relevant classes/functions/methods elsewhere in your code base.
+It's ok to add 1-2 highly relevant files that don't need to be edited,
+but be selective.
+
+## Break your goal down into bite sized steps
+
+Do them one at a time. 
+Adjust the files added to the chat as you go: `/drop` files that don't need any more changes, `/add` files that need changes for the next step.
+
+## For complex changes, discuss a plan first
+
+Use the [`/ask` command](modes.html) to make a plan with aider.
+Once you are happy with the approach, just say "go ahead" without the `/ask` prefix.
+
+## If aider gets stuck
+
+- Use `/clear` to discard the chat history and make a fresh start.
+- Can you `/drop` any extra files?
+- Use `/ask` to discuss a plan before aider starts editing code.
+- Use the [`/model` command](commands.html) to switch to a different model and try again. Switching between GPT-4o and Sonnet will often get past problems.
+- If aider is hopelessly stuck,
+just code the next step yourself and try having aider code some more after that.
+Take turns and pair program with aider.
+
+## Creating new files
+
+If you want aider to create a new file, add it to the repository first with `/add <file>`.
+This way aider knows this file exists and will write to it. 
+Otherwise, aider might write the changes to an existing file.
+This can happen even if you ask for a new file, as LLMs tend to focus a lot
+on the existing information in their contexts.
+
+## Fixing bugs and errors
+
+If your code is throwing an error, 
+use the [`/run` command](commands.html)
+to share the error output with the aider.
+Or just paste the errors into the chat. Let the aider figure out how to fix the bug.
+
+If test are failing, use the [`/test` command](lint-test.html)
+to run tests and
+share the error output with the aider.
+
+## Providing docs
+
+LLMs know about a lot of standard tools and libraries, but may get some of the fine details wrong about API versions and function arguments.
+
+You can provide up-to-date documentation in a few ways:
+
+- Paste doc snippets into the chat.
+- Include a URL to docs in your chat message
+and aider will scrape and read it. For example: `Add a submit button like this https://ui.shadcn.com/docs/components/button`. 
+- Use the [`/read` command](commands.html) to read doc files into the chat from anywhere on your filesystem.
+- If you have coding conventions or standing instructions you want aider to follow, consider using a [conventions file](conventions.html).
+
+## Interrupting & inputting
+
+Use Control-C to interrupt aider if it isn't providing a useful response. The partial response remains in the conversation, so you can refer to it when you reply with more information or direction.
+
+{% include multi-line.md %}
+

aider/website/docs/usage/tutorials.md

@@ -0,0 +1,30 @@
+---
+parent: Usage
+nav_order: 75
+description: Intro and tutorial videos made by aider users.
+---
+
+# Tutorial videos
+
+Here are some tutorial videos made by aider users:
+
+- [Using Architect/Editor mode](https://www.youtube.com/watch?v=OPXslklVBZc) -- AICodeKing
+- [Using aider to incrementally build a non-trivial app](https://youtu.be/QlUt06XLbJE) -- IndyDevDan
+- [Aider and Replit on mobile with your voice](https://x.com/itsPaulAi/status/1830987090617831810) -- Paul Couvert
+- [Aider is the OG AI Coding King (Mermaid Diagram AI Agent)](https://www.youtube.com/watch?v=ag-KxYS8Vuw) -- IndyDevDan
+- [Installing aider in replit and making a Trello clone](https://x.com/itspaulai/status/1828834199597633724) -- Paul Couvert
+- [Step-by-Step Development Environment Setup for AI-Assisted Coding](https://www.youtube.com/watch?v=DnBVgfe6ZQM) -- Coding the Future With AI
+- [Generate FULL-STACK Apps with Claude 3.5 Sonnet](https://youtu.be/sKeIZGW8xzg) -- AICodeKing
+- [Creating Games with AI from Start-To-End](https://youtu.be/sOd2YYZFMUs) -- AICodeKing
+- [Claude 3.5 and aider: Use AI Assistants to Build AI Apps](https://youtu.be/0hIisJ3xAdU) -- Coding the Future With AI
+- [Develop a Full-stack App Without Writing ANY Code](https://youtu.be/dzOWn8TI738) -- WorldofAI
+- [Generate Games with AI (w/ Local LLMs)](https://youtu.be/DjVJpGzQbSA) -- AICodeKing
+- [Aider tips and Example use](https://www.youtube.com/watch?v=OsChkvGGDgw) -- techfren
+- [Aider and Claude 3.5: Develop a Full-stack App Without Writing ANY Code!](https://www.youtube.com/watch?v=BtAqHsySdSY) -- Coding the Future With AI
+- [Generate application with just one prompt using Aider](https://www.youtube.com/watch?v=Y-_0VkMUiPc&t=78s) -- AICodeKing
+- [Aider : the production ready AI coding assistant you've been waiting for](https://www.youtube.com/watch?v=zddJofosJuM) -- Learn Code With JV
+- [Holy Grail: FREE Coding Assistant That Can Build From EXISTING CODE BASE](https://www.youtube.com/watch?v=df8afeb1FY8) -- Matthew Berman
+- [Aider: This AI Coder Can Create AND Update Git Codebases](https://www.youtube.com/watch?v=EqLyFT78Sig) -- Ian Wootten
+
+Thanks to all these great creators for taking the time
+to share their experiences coding with aider!

aider/website/docs/usage/voice.md

@@ -0,0 +1,121 @@
+---
+parent: Usage
+nav_order: 100
+description: Speak with aider about your code!
+---
+
+# Voice-to-code with aider
+
+Speak with aider about your code! Request new features, test cases or bug fixes using your voice and let aider do the work of editing the files in your local git repo. As with all of aider's capabilities, you can use voice-to-code with an existing repo or to start a new project.
+
+Voice support fits quite naturally into aider's AI pair programming
+chat interface. Now you can fluidly switch between voice and text chat
+when you ask aider to edit your code.
+
+## How to use voice-to-code
+
+Use the in-chat `/voice` command to start recording,
+and press `ENTER` when you're done speaking.
+Your voice coding instructions will be transcribed, 
+as if you had  typed them into
+the aider chat session.
+
+See the [installation instructions](https://aider.chat/docs/install/optional.html#enable-voice-coding) for
+information on how to enable the `/voice` command.
+
+<br/>
+<div class="chat-transcript" markdown="1">
+
+> Aider v0.11.2-dev  
+> Added app.py to the chat.  
+
+#### /voice
+
+<blockquote>
+<div class="recording-line">
+    <p style="display: inline;">Recording, press ENTER when done... <span id="timer">3.5</span>sec</p>
+    <div id="progress-bar">
+        <div id="progress"></div>
+    </div>
+</div>
+</blockquote>
+
+<style>
+    .recording-line > * {
+        display: inline-block;
+        vertical-align: middle;
+    }
+    #progress-bar {
+        width: 100px;
+        height: 20px;
+        background-color: #333;
+        margin-left: 10px;
+    }
+    #progress {
+        height: 100%;
+        background-color: #f0f0f0;
+        animation: progress 3s infinite;
+    }
+    @keyframes progress {
+        0% { width: 10%; }
+        20% { width: 90%; }
+        50% { width: 30%; }
+        60% { width: 90%; }
+        80% { width: 20%; }
+        100% { width: 10%; }
+
+    }
+</style>
+
+<script>
+window.onload = function() {
+    var counter = 0;
+    var timer = document.getElementById('timer');
+    setInterval(function() {
+        counter = (counter + 0.1) % 9;
+        timer.textContent = counter.toFixed(1);
+    }, 100);
+}
+</script>
+
+<div style="display: inline-block; position: relative; width: 200px; background-color: #f0f0f0; border-radius: 10px; padding: 10px; color: #333; font-family: 'Comic Sans MS', 'Comic Sans', 'Marker Felt', sans-serif;">
+<span style="position: absolute; top: 0; left: 50%; transform: translate(-50%, -100%); width: 0; height: 0; border-left: 10px solid transparent; border-right: 10px solid transparent; border-bottom: 10px solid #f0f0f0;"></span>
+“&nbsp;add a factorial endpoint that uses math factorial&nbsp;”
+</div>
+
+#### Add a factorial endpoint that uses math.factorial.
+
+To add a factorial endpoint to the Flask application, we need to modify the `app.py` file.
+
+Here are the steps:
+
+1. Add a new route `/fact/<int:x>` to the Flask application.
+2. In the function for this route, call `math.factorial(x)` and return the result as a string.
+
+Here is the *edit block* for these changes:
+
+```python
+app.py
+<<<<<<< HEAD
+if __name__ == '__main__':
+    print("Starting...")
+    app.run()
+=======
+@app.route('/fact/<int:x>')
+def factorial(x):
+    result = math.factorial(x)
+    return str(result)
+
+if __name__ == '__main__':
+    print("Starting...")
+    app.run()
+>>>>>>> updated
+```
+
+> Applied edit to app.py  
+> Commit ef9e3e7 aider: Add a factorial endpoint that uses math.factorial.  
+
+</div>
+<br/>
+<br/>
+<br/>

aider/website/docs/usage/watch.md

@@ -0,0 +1,294 @@
+---
+title: Aider in your IDE
+#highlight_image: /assets/browser.jpg
+parent: Usage
+nav_order: 750
+description: Aider can watch your files and respond to AI comments you add in your favorite IDE or text editor.
+---
+
+# Aider in your IDE
+
+<div class="video-container">
+  <video controls loop poster="/assets/watch.jpg">
+    <source src="/assets/watch.mp4" type="video/mp4">
+    <a href="/assets/watch.mp4">Aider browser UI demo video</a>
+  </video>
+</div>
+
+<style>
+.video-container {
+  position: relative;
+  padding-bottom: 102.7%; /1.027 */
+  height: 0;
+  overflow: hidden;
+}
+
+.video-container video {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+</style>
+
+## AI comments
+
+If you run aider with `--watch-files`, it will watch all files in your repo
+and look for any AI coding instructions you add using your favorite IDE or text editor.
+
+Specifically, aider looks for one-liner comments (# ... or // ...) that either start or end with `AI`, `AI!` or `AI?` like these:
+
+```python
+# Make a snake game. AI!
+# What is the purpose of this method AI?
+```
+
+Or in `//` comment languages...
+
+```js
+// Write a protein folding prediction engine. AI!
+```
+
+Aider will take note of all the comments that start or end with `AI`.
+Comments that include `AI!` with an exclamation point or `AI?` with a question
+mark are special.
+They trigger aider to take action to collect *all* the AI comments and use them
+as your instructions.
+
+- `AI!` triggers aider to make changes to your code.
+- `AI?` triggers aider to answer your question.
+
+See the demo video above that shows aider working with AI comments in VSCode.
+
+
+## Example
+
+For example, if you included this AI comment in your code:
+
+```js
+function factorial(n) // Implement this. AI!
+```
+
+Then aider would update the file and implement the function:
+
+```js
+function factorial(n) {
+  if (n === 0 || n === 1) {
+    return 1;
+  } else {
+    return n * factorial(n - 1);
+  }
+}
+```
+
+## Comment styles
+
+Aider only watches for these types of **one-liner** comments:
+
+```
+# Python and bash style
+// Javascript style
+-- SQL style
+```
+
+Aider will look for those comment types in all files.
+You can use them into any code file you're editing, even if they aren't the
+correct comment syntax for that language.
+
+## Multiple uses
+
+This capability is quite flexible and powerful, and can be used in many ways.
+
+### In-context instructions
+
+You can add an AI comment in the function you want changed,
+explaining the change request in-context right where you want the changes.
+
+```javascript
+app.get('/sqrt/:n', (req, res) => {
+    const n = parseFloat(req.params.n);
+
+    // Add error handling for NaN and less than zero. AI!
+
+    const result = math.sqrt(n);
+    res.json({ result: result });
+});
+```
+
+### Multiple comments
+
+You can add multiple `AI` comments without the `!`,
+before triggering aider with a final `AI!`.
+Also keep in mind that you can spread the AI comments across
+multiple files, if you want to coordinate changes in multiple places.
+Just use `AI!` last, to trigger aider.
+
+```python
+@app.route('/factorial/<int:n>')
+def factorial(n):
+    if n < 0:
+        return jsonify(error="Factorial is not defined for negative numbers"), 400
+
+    # AI: Refactor this code...
+
+    result = 1
+    for i in range(1, n + 1):
+        result *= i
+
+    # ... into to a compute_factorial() function. AI!
+
+    return jsonify(result=result)
+```
+
+### Long form instructions
+
+You can add a block of comments, with longer instructions.
+Just be sure to start or end one of the lines with `AI` or `AI!` to draw
+aider's attention to the block.
+
+```python
+# Make these changes: AI!
+# - Add a proper main() function
+# - Use Click to process cmd line args
+# - Accept --host and --port args
+# - Print a welcome message that includes the listening url
+
+if __name__ == "__main__":
+    app.run(debug=True)
+```
+
+### Add a file to the aider chat
+
+Rather than using `/add` to add a file inside the aider chat, you can
+simply put an `#AI` comment in it and save the file.
+You can undo/remove the comment immediately if you like, the file
+will still be added to the aider chat.
+
+## Also use aider chat in the terminal
+
+It can be really helpful to get a change started with AI comments.
+But sometimes you want to build on or refine those changes.
+You can of course continue to do that with AI comments,
+but it can sometimes be effective to switch over to the aider terminal chat.
+The chat has the history of the AI comments you just made,
+so you can continue on naturally from there.
+
+You can also use the normal aider chat in your terminal to work with
+many of aider's more advanced features:
+
+- Use `/undo` to revert changes you don't like. Although you may also be able to use your IDE's undo function to step back in the file history.
+- Use [chat modes](https://aider.chat/docs/usage/modes.html) to ask questions or get help.
+- Manage the chat context with `/tokens`, `/clear`, `/drop`, `/reset`.
+Adding an AI comment will add the file to the chat.
+Periodically, you may want remove extra context that is no longer needed.
+- [Fix lint and test errors](https://aider.chat/docs/usage/lint-test.html).
+- Run shell commands.
+- Etc.
+
+
+## You can be lazy
+
+The examples above all show AI
+comments with full sentences, proper capitalization, punctuation, etc.
+This was done to help explain how AI comments work, but is not needed in practice.
+
+Most LLMs are perfectly capable of dealing with ambiguity and
+inferring implied intent.
+This often allows you to be quite lazy with your AI comments.
+In particular, you can start and end comments with lowercase `ai` and `ai!`,
+but you can also be much more terse with the request itself.
+Below are simpler versions of some of the examples given above.
+
+When the context clearly implies the needed action, `ai!` might be all you
+need. For example, to implement a factorial function
+in a program full of other math functions either of these
+approaches would probably work:
+
+```js
+function factorial(n) // ai!
+```
+
+Or...
+
+```js
+// add factorial() ai!
+```
+
+Rather than a long, explicit comment like "Add error handling for NaN and less than zero,"
+you can let aider infer more about the request.
+This simpler comment may be sufficient:
+
+```javascript
+app.get('/sqrt/:n', (req, res) => {
+    const n = parseFloat(req.params.n);
+
+    // add error handling ai!
+
+    const result = math.sqrt(n);
+    res.json({ result: result });
+});
+```
+
+Similarly, this refactor probably could have been requested with fewer words, like this:
+
+```python
+@app.route('/factorial/<int:n>')
+def factorial(n):
+    if n < 0:
+        return jsonify(error="Factorial is not defined for negative numbers"), 400
+
+    # ai refactor...
+
+    result = 1
+    for i in range(1, n + 1):
+        result *= i
+
+    # ... to compute_factorial() ai!
+
+    return jsonify(result=result)
+```
+
+As you use aider with your chosen LLM, you can develop a sense for how
+explicit you need to make your AI comments.
+
+## Behind the scenes
+
+Aider sends your AI comments to the LLM with the
+[repo map](https://aider.chat/docs/repomap.html)
+and all the other code context you've added to the chat.
+
+It also pulls out and highlights the AI comments with specific context, showing the LLM
+exactly how they fit into the code base.
+
+```
+The "AI" comments below marked with █ can be found in the code files I've shared with you.
+They contain your instructions.
+Make the requested changes.
+Be sure to remove all these "AI" comments from the code!
+
+todo_app.py:
+⋮...
+│class TodoList:
+⋮...
+│    def __init__(self):
+│        """Initialize an empty todo list"""
+⋮...
+│
+│    def list_tasks(self):
+│        """Display all tasks"""
+█        # Implement this. AI!
+│
+│def main():
+│    todo = TodoList()
+│
+⋮...
+```
+
+--------
+
+#### Credits
+
+*This feature was inspired by
+the way [Override](https://github.com/oi-overide) watches for file changes
+to find prompts embedded within `//> a specific set of delimiters <//`.*

aider/website/docs/usage.md

@@ -0,0 +1,92 @@
+---
+nav_order: 30
+has_children: true
+description: How to use aider to pair program with AI and edit code in your local git repo.
+---
+
+# Usage
+
+Run `aider` with the source code files you want to edit.
+These files will be "added to the chat session", so that
+aider can see their
+contents and edit them for you.
+They can be existing files or the name of files you want
+aider to create for you.
+
+```
+aider <file1> <file2> ...
+```
+
+At the aider `>` prompt, ask for code changes and aider
+will edit those files to accomplish your request.
+
+
+```
+$ aider factorial.py
+
+Aider v0.37.1-dev
+Models: gpt-4o with diff edit format, weak model gpt-3.5-turbo
+Git repo: .git with 258 files
+Repo-map: using 1024 tokens
+Use /help to see in-chat commands, run with --help to see cmd line args
+───────────────────────────────────────────────────────────────────────
+> Make a program that asks for a number and prints its factorial
+
+...
+```
+
+{% include help-tip.md %}
+
+## Adding files
+
+To edit files, you need to "add them to the chat".
+Do this
+by naming them on the aider command line.
+Or, you can use the in-chat
+`/add` command to add files.
+
+
+Only add the files that need to be edited for your task.
+Don't add a bunch of extra files.
+If you add too many files, the LLM can get overwhelmed
+and confused (and it costs more tokens).
+Aider will automatically
+pull in content from related files so that it can
+[understand the rest of your code base](https://aider.chat/docs/repomap.html).
+
+You can use aider without adding any files,
+and it will try to figure out which files need to be edited based
+on your requests.
+
+{: .tip }
+You'll get the best results if you think about which files need to be
+edited. Add **just** those files to the chat. Aider will include
+relevant context from the rest of your repo.
+
+## LLMs
+
+{% include works-best.md %}
+
+```
+# o3-mini
+$ aider --model o3-mini --api-key openai=<key>
+
+# Claude 3.7 Sonnet
+$ aider --model sonnet --api-key anthropic=<key>
+```
+
+Or you can run `aider --model XXX` to launch aider with
+another model.
+During your chat you can switch models with the in-chat
+`/model` command.
+
+## Making changes
+
+Ask aider to make changes to your code.
+It will show you some diffs of the changes it is making to
+complete you request.
+[Aider will git commit all of its changes](/docs/git.html),
+so they are easy to track and undo.
+
+You can always use the `/undo` command to undo AI changes that you don't
+like.