aider-ce 0.87.2.dev9__py3-none-any.whl

aider/watch.py

@@ -0,0 +1,318 @@
+import re
+import threading
+from pathlib import Path
+from typing import Optional
+
+from grep_ast import TreeContext
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+from watchfiles import watch
+
+from aider.dump import dump  # noqa
+from aider.watch_prompts import watch_ask_prompt, watch_code_prompt
+
+
+def load_gitignores(gitignore_paths: list[Path]) -> Optional[PathSpec]:
+    """Load and parse multiple .gitignore files into a single PathSpec"""
+    if not gitignore_paths:
+        return None
+
+    patterns = [
+        ".aider*",
+        ".git",
+        # Common editor backup/temp files
+        "*~",  # Emacs/vim backup
+        "*.bak",  # Generic backup
+        "*.swp",  # Vim swap
+        "*.swo",  # Vim swap
+        "\\#*\\#",  # Emacs auto-save
+        ".#*",  # Emacs lock files
+        "*.tmp",  # Generic temp files
+        "*.temp",  # Generic temp files
+        "*.orig",  # Merge conflict originals
+        "*.pyc",  # Python bytecode
+        "__pycache__/",  # Python cache dir
+        ".DS_Store",  # macOS metadata
+        "Thumbs.db",  # Windows thumbnail cache
+        "*.svg",
+        "*.pdf",
+        # IDE files
+        ".idea/",  # JetBrains IDEs
+        ".vscode/",  # VS Code
+        "*.sublime-*",  # Sublime Text
+        ".project",  # Eclipse
+        ".settings/",  # Eclipse
+        "*.code-workspace",  # VS Code workspace
+        # Environment files
+        ".env",  # Environment variables
+        ".venv/",  # Python virtual environments
+        "node_modules/",  # Node.js dependencies
+        "vendor/",  # Various dependencies
+        # Logs and caches
+        "*.log",  # Log files
+        ".cache/",  # Cache directories
+        ".pytest_cache/",  # Python test cache
+        "coverage/",  # Code coverage reports
+    ]  # Always ignore
+    for path in gitignore_paths:
+        if path.exists():
+            with open(path) as f:
+                patterns.extend(f.readlines())
+
+    return PathSpec.from_lines(GitWildMatchPattern, patterns) if patterns else None
+
+
+class FileWatcher:
+    """Watches source files for changes and AI comments"""
+
+    # Compiled regex pattern for AI comments
+    ai_comment_pattern = re.compile(
+        r"(?:#|//|--|;+) *(ai\b.*|ai\b.*|.*\bai[?!]?) *$", re.IGNORECASE
+    )
+
+    def __init__(self, coder, gitignores=None, verbose=False, analytics=None, root=None):
+        self.coder = coder
+        self.io = coder.io
+        self.root = Path(root) if root else Path(coder.root)
+        self.verbose = verbose
+        self.analytics = analytics
+        self.stop_event = None
+        self.watcher_thread = None
+        self.changed_files = set()
+        self.gitignores = gitignores
+
+        self.gitignore_spec = load_gitignores(
+            [Path(g) for g in self.gitignores] if self.gitignores else []
+        )
+
+        coder.io.file_watcher = self
+
+    def filter_func(self, change_type, path):
+        """Filter function for the file watcher"""
+        path_obj = Path(path)
+        path_abs = path_obj.absolute()
+
+        if not path_abs.is_relative_to(self.root.absolute()):
+            return False
+
+        rel_path = path_abs.relative_to(self.root)
+        if self.verbose:
+            print("Changed", rel_path)
+
+        if self.gitignore_spec and self.gitignore_spec.match_file(
+            rel_path.as_posix() + ("/" if path_abs.is_dir() else "")
+        ):
+            return False
+
+        # Check file size before reading content
+        if path_abs.is_file() and path_abs.stat().st_size > 1 * 1024 * 1024:  # 1MB limit
+            return False
+
+        if self.verbose:
+            print("Checking", rel_path)
+
+        # Check if file contains AI markers
+        try:
+            comments, _, _ = self.get_ai_comments(str(path_abs))
+            return bool(comments)
+        except Exception:
+            return
+
+    def get_roots_to_watch(self):
+        """Determine which root paths to watch based on gitignore rules"""
+        if self.gitignore_spec:
+            roots = [
+                str(path)
+                for path in self.root.iterdir()
+                if not self.gitignore_spec.match_file(
+                    path.relative_to(self.root).as_posix() + ("/" if path.is_dir() else "")
+                )
+            ]
+            # Fallback to watching root if all top-level items are filtered out
+            return roots if roots else [str(self.root)]
+        return [str(self.root)]
+
+    def handle_changes(self, changes):
+        """Process the detected changes and update state"""
+        if not changes:
+            return False
+
+        changed_files = {str(Path(change[1])) for change in changes}
+        self.changed_files.update(changed_files)
+        self.io.interrupt_input()
+        return True
+
+    def watch_files(self):
+        """Watch for file changes and process them"""
+        try:
+            roots_to_watch = self.get_roots_to_watch()
+
+            for changes in watch(
+                *roots_to_watch,
+                watch_filter=self.filter_func,
+                stop_event=self.stop_event,
+                ignore_permission_denied=True,
+            ):
+                if self.handle_changes(changes):
+                    return
+
+        except Exception as e:
+            if self.verbose:
+                dump(f"File watcher error: {e}")
+            raise e
+
+    def start(self):
+        """Start watching for file changes"""
+        self.stop_event = threading.Event()
+        self.changed_files = set()
+
+        self.watcher_thread = threading.Thread(target=self.watch_files, daemon=True)
+        self.watcher_thread.start()
+
+    def stop(self):
+        """Stop watching for file changes"""
+        if self.stop_event:
+            self.stop_event.set()
+        if self.watcher_thread:
+            self.watcher_thread.join()
+            self.watcher_thread = None
+            self.stop_event = None
+
+    def process_changes(self):
+        """Get any detected file changes"""
+
+        has_action = None
+        added = False
+        for fname in self.changed_files:
+            _, _, action = self.get_ai_comments(fname)
+            if action in ("!", "?"):
+                has_action = action
+
+            if fname in self.coder.abs_fnames:
+                continue
+            if self.analytics:
+                self.analytics.event("ai-comments file-add")
+            self.coder.abs_fnames.add(fname)
+            rel_fname = self.coder.get_rel_fname(fname)
+            if not added:
+                self.io.tool_output()
+                added = True
+            self.io.tool_output(f"Added {rel_fname} to the chat")
+
+        if not has_action:
+            if added:
+                self.io.tool_output(
+                    "End your comment with AI! to request changes or AI? to ask questions"
+                )
+            return ""
+
+        if self.analytics:
+            self.analytics.event("ai-comments execute")
+        self.io.tool_output("Processing your request...")
+
+        if has_action == "!":
+            res = watch_code_prompt
+        elif has_action == "?":
+            res = watch_ask_prompt
+
+        # Refresh all AI comments from tracked files
+        for fname in self.coder.abs_fnames:
+            line_nums, comments, _action = self.get_ai_comments(fname)
+            if not line_nums:
+                continue
+
+            code = self.io.read_text(fname)
+            if not code:
+                continue
+
+            rel_fname = self.coder.get_rel_fname(fname)
+            res += f"\n{rel_fname}:\n"
+
+            # Convert comment line numbers to line indices (0-based)
+            lois = [ln - 1 for ln, _ in zip(line_nums, comments) if ln > 0]
+
+            try:
+                context = TreeContext(
+                    rel_fname,
+                    code,
+                    color=False,
+                    line_number=False,
+                    child_context=False,
+                    last_line=False,
+                    margin=0,
+                    mark_lois=True,
+                    loi_pad=3,
+                    show_top_of_file_parent_scope=False,
+                )
+                context.lines_of_interest = set()
+                context.add_lines_of_interest(lois)
+                context.add_context()
+                res += context.format()
+            except ValueError:
+                for ln, comment in zip(line_nums, comments):
+                    res += f"  Line {ln}: {comment}\n"
+
+        return res
+
+    def get_ai_comments(self, filepath):
+        """Extract AI comment line numbers, comments and action status from a file"""
+        line_nums = []
+        comments = []
+        has_action = None  # None, "!" or "?"
+        content = self.io.read_text(filepath, silent=True)
+        if not content:
+            return None, None, None
+
+        for i, line in enumerate(content.splitlines(), 1):
+            if match := self.ai_comment_pattern.search(line):
+                comment = match.group(0).strip()
+                if comment:
+                    line_nums.append(i)
+                    comments.append(comment)
+                    comment = comment.lower()
+                    comment = comment.lstrip("/#-;")  # Added semicolon for Lisp comments
+                    comment = comment.strip()
+                    if comment.startswith("ai!") or comment.endswith("ai!"):
+                        has_action = "!"
+                    elif comment.startswith("ai?") or comment.endswith("ai?"):
+                        has_action = "?"
+        if not line_nums:
+            return None, None, None
+        return line_nums, comments, has_action
+
+
+def main():
+    """Example usage of the file watcher"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Watch source files for changes")
+    parser.add_argument("directory", help="Directory to watch")
+    parser.add_argument(
+        "--gitignore",
+        action="append",
+        help="Path to .gitignore file (can be specified multiple times)",
+    )
+    args = parser.parse_args()
+
+    directory = args.directory
+    print(f"Watching source files in {directory}...")
+
+    # Example ignore function that ignores files with "test" in the name
+    def ignore_test_files(path):
+        return "test" in path.name.lower()
+
+    watcher = FileWatcher(directory, gitignores=args.gitignore)
+    try:
+        watcher.start()
+        while True:
+            if changes := watcher.get_changes():
+                for file in sorted(changes.keys()):
+                    print(file)
+                watcher.changed_files = None
+    except KeyboardInterrupt:
+        print("\nStopped watching files")
+        watcher.stop()
+
+
+if __name__ == "__main__":
+    main()

aider/watch_prompts.py

@@ -0,0 +1,12 @@
+watch_code_prompt = """
+I've written your instructions in comments in the code and marked them with "ai"
+You can see the "AI" comments shown below (marked with █).
+Find them in the code files I've shared with you, and follow their instructions.
+
+After completing those instructions, also be sure to remove all the "AI" comments from the code too.
+"""
+
+watch_ask_prompt = """/ask
+Find the "AI" comments below (marked with █) in the code files I've shared with you.
+They contain my questions that I need you to answer and other instructions for you.
+"""

aider/website/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gem 'jekyll'
+gem "just-the-docs", "0.8.2"
+gem 'jekyll-redirect-from'
+gem 'jekyll-sitemap'
+gem "webrick"
+gem 'github-pages', group: :jekyll_plugins
+gem "html-proofer"

aider/website/_includes/blame.md

@@ -0,0 +1,162 @@
+<div class="chart-container">
+    <canvas id="blameChart" style="margin-top: 20px"></canvas>
+</div>
+<div class="chart-container">
+    <canvas id="linesChart" style="margin-top: 20px"></canvas>
+</div>
+
+<style>
+.chart-container {
+    position: relative;
+    width: 100%;
+    height: 300px;
+}
+</style>
+
+<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/moment"></script>
+<script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-moment"></script>
+<script>
+document.addEventListener('DOMContentLoaded', function () {
+    var blameCtx = document.getElementById('blameChart').getContext('2d');
+    var linesCtx = document.getElementById('linesChart').getContext('2d');
+    
+    var labels = [{% for row in site.data.blame %}'{{ row.end_tag }}',{% endfor %}];
+    
+    var blameData = {
+        labels: labels,
+        datasets: [{
+            label: 'Aider\'s percent of new code by release',
+            data: [{% for row in site.data.blame %}{ x: '{{ row.end_tag }}', y: {{ row.aider_percentage }}, lines: {{ row.aider_total }}, end_date: '{{ row.end_date }}' },{% endfor %}],
+            backgroundColor: 'rgba(54, 162, 235, 0.8)',
+            borderColor: 'rgba(54, 162, 235, 1)',
+            borderWidth: 1
+        }]
+    };
+
+    var linesData = {
+        labels: labels,
+        datasets: [{
+            label: 'Aider',
+            data: [{% for row in site.data.blame %}{ x: '{{ row.end_tag }}', y: {{ row.aider_total }} },{% endfor %}],
+            backgroundColor: 'rgba(54, 162, 235, 0.8)',
+            borderColor: 'rgba(54, 162, 235, 1)',
+            borderWidth: 1
+        },
+        {
+            label: 'Human',
+            data: [{% for row in site.data.blame %}{ x: '{{ row.end_tag }}', y: {{ row.total_lines | minus: row.aider_total }} },{% endfor %}],
+            backgroundColor: 'rgba(200, 200, 200, 0.8)',
+            borderColor: 'rgba(200, 200, 200, 1)',
+            borderWidth: 1
+        }]
+    };
+
+    var blameChart = new Chart(blameCtx, {
+        type: 'bar',
+        data: blameData,
+        options: {
+            maintainAspectRatio: false,
+            scales: {
+                x: {
+                    type: 'category',
+                    title: {
+                        display: true,
+                        text: 'Version'
+                    },
+                    ticks: {
+                        maxRotation: 45,
+                        minRotation: 45
+                    }
+                },
+                y: {
+                    title: {
+                        display: true,
+                        text: 'Percent of new code'
+                    },
+                    beginAtZero: true
+                }
+            },
+            plugins: {
+                legend: {
+                    display: false
+                },
+                tooltip: {
+                    callbacks: {
+                        label: function(context) {
+                            var label = 'Aider\'s contribution';
+                            var value = context.parsed.y || 0;
+                            var lines = context.raw.lines || 0;
+                            return `${label}: ${Math.round(value)}% (${lines} lines)`;
+                        },
+                        afterLabel: function(context) {
+                            let date = context.raw.end_date || 'n/a';
+                            return `Date: ` + date;
+                        }
+                    }
+                },
+                title: {
+                    display: true,
+                    text: 'Percent of new code written by aider, by release',
+                    font: {
+                        size: 16
+                    }
+                }
+            }
+        }
+    });
+
+    var linesChart = new Chart(linesCtx, {
+        type: 'bar',
+        data: linesData,
+        options: {
+            maintainAspectRatio: false,
+            scales: {
+                x: {
+                    type: 'category',
+                    stacked: true,
+                    title: {
+                        display: true,
+                        text: 'Version'
+                    },
+                    ticks: {
+                        maxRotation: 45,
+                        minRotation: 45
+                    }
+                },
+                y: {
+                    stacked: true,
+                    title: {
+                        display: true,
+                        text: 'Lines of new code'
+                    },
+                    beginAtZero: true
+                }
+            },
+            plugins: {
+                legend: {
+                    display: true,
+                    position: 'chartArea',
+                    reverse: true
+                },
+                tooltip: {
+                    callbacks: {
+                        label: function(context) {
+                            var label = context.dataset.label;
+                            var value = context.parsed.y || 0;
+                            return `${label}: ${value}`;
+                        }
+                    }
+                },
+                title: {
+                    display: true,
+                    text: 'Lines of new code, by release',
+                    font: {
+                        size: 16
+                    }
+                }
+            }
+        }
+    });
+});
+</script>

aider/website/_includes/get-started.md

@@ -0,0 +1,22 @@
+
+If you already have python 3.8-3.13 installed, you can get started quickly like this.
+
+First, install aider:
+
+{% include install.md %}
+
+Start working with aider on your codebase:
+
+```bash
+# Change directory into your codebase
+cd /to/your/project
+
+# DeepSeek
+aider --model deepseek --api-key deepseek=<key>
+
+# Claude 3.7 Sonnet
+aider --model sonnet --api-key anthropic=<key>
+
+# o3-mini
+aider --model o3-mini --api-key openai=<key>
+```

aider/website/_includes/help-tip.md

@@ -0,0 +1,5 @@
+{: .tip }
+Use `/help <question>` to 
+[ask for help about using aider](/docs/troubleshooting/support.html),
+customizing settings, troubleshooting, using LLMs, etc.
+

aider/website/_includes/help.md

@@ -0,0 +1,24 @@
+If you need more help, please check our
+[GitHub issues](https://github.com/Aider-AI/aider/issues)
+and file a new issue if your problem isn't discussed.
+Or drop into our
+[Discord](https://discord.gg/Y7X7bhMQFV)
+to chat with us.
+
+When reporting problems, it is very helpful if you can provide:
+
+- Aider version
+- LLM model you are using
+
+Including the "announcement" lines that
+aider prints at startup
+is an easy way to share this helpful info.
+
+```
+Aider v0.37.1-dev
+Models: gpt-4o with diff edit format, weak model gpt-3.5-turbo
+Git repo: .git with 243 files
+Repo-map: using 1024 tokens
+```
+
+{% include help-tip.md %}

aider/website/_includes/install.md

@@ -0,0 +1,5 @@
+
+```bash
+python -m pip install aider-install
+aider-install
+```

aider/website/_includes/keys.md

@@ -0,0 +1,4 @@
+{: .tip :}
+See the
+[API key configuration docs](/docs/config/api-keys.html)
+for information on how to configure and store your API keys.

aider/website/_includes/model-warnings.md

@@ -0,0 +1,67 @@
+
+## Unknown context window size and token costs
+
+```
+Model foobar: Unknown context window size and costs, using sane defaults.
+```
+
+If you specify a model that aider has never heard of, you will get
+this warning.
+This means aider doesn't know the context window size and token costs
+for that model.
+Aider will use an unlimited context window and assume the model is free,
+so this is not usually a significant problem.
+
+See the docs on 
+[configuring advanced model settings](/docs/config/adv-model-settings.html)
+for details on how to remove this warning.
+
+{: .tip }
+You can probably ignore the unknown context window size and token costs warning.
+
+## Did you mean?
+
+If aider isn't familiar with the model you've specified,
+it will suggest similarly named models.
+This helps
+in the case where you made a typo or mistake when specifying the model name.
+
+```
+Model gpt-5o: Unknown context window size and costs, using sane defaults.
+Did you mean one of these?
+- gpt-4o
+```
+
+## Missing environment variables
+
+You need to set the listed environment variables.
+Otherwise you will get error messages when you start chatting with the model.
+
+```
+Model azure/gpt-4-turbo: Missing these environment variables:
+- AZURE_API_BASE
+- AZURE_API_VERSION
+- AZURE_API_KEY
+```
+
+{: .tip }
+On Windows, 
+if you just set these environment variables using `setx` you may need to restart your terminal or
+command prompt for the changes to take effect.
+
+
+## Unknown which environment variables are required
+
+```
+Model gpt-5: Unknown which environment variables are required.
+```
+
+Aider is unable verify the environment because it doesn't know
+which variables are required for the model.
+If required variables are missing,
+you may get errors when you attempt to chat with the model.
+You can look in the [aider's LLM documentation](/docs/llms.html)
+or the
+[litellm documentation](https://docs.litellm.ai/docs/providers)
+to see if the required variables are listed there.
+

aider/website/_includes/multi-line.md

@@ -0,0 +1,22 @@
+You can send long, multi-line messages in the chat in a few ways:
+  - Paste a multi-line message directly into the chat.
+  - Enter `{` alone on the first line to start a multiline message and `}` alone on the last line to end it.
+    - Or, start with `{tag` (where "tag" is any sequence of letters/numbers) and end with `tag}`. This is useful when you need to include closing braces `}` in your message.
+  - Use Meta-ENTER to start a new line without sending the message (Esc+ENTER in some environments).
+  - Use `/paste` to paste text from the clipboard into the chat.
+  - Use the `/editor` command (or press `Ctrl-X Ctrl-E` if your terminal allows) to open your editor to create the next chat message. See [editor configuration docs](/docs/config/editor.html) for more info.
+  - Use multiline-mode, which swaps the function of Meta-Enter and Enter, so that Enter inserts a newline, and Meta-Enter submits your command. To enable multiline mode:
+    - Use the `/multiline-mode` command to toggle it during a session.
+    - Use the `--multiline` switch.
+  
+Example with a tag:
+```
+{python
+def hello():
+    print("Hello}")  # Note: contains a brace
+python}
+```
+
+{: .note }
+People often ask for SHIFT-ENTER to be a soft-newline.
+Unfortunately there is no portable way to detect that keystroke in terminals.

aider/website/_includes/python-m-aider.md

@@ -0,0 +1,5 @@
+{: .tip }
+In some environments you may get "aider command not found" errors.
+You can try `python -m aider` or 
+[see here for more info](/docs/troubleshooting/aider-not-found.html).
+