aider-ce 0.88.20__py3-none-any.whl

aider/voice.py

@@ -0,0 +1,205 @@
+import math
+import os
+import queue
+import tempfile
+import time
+import warnings
+
+from prompt_toolkit.shortcuts import prompt
+
+from aider.llm import litellm
+
+from .dump import dump  # noqa: F401
+
+warnings.filterwarnings(
+    "ignore", message="Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work"
+)
+warnings.filterwarnings("ignore", category=SyntaxWarning)
+
+
+try:
+    from pydub import AudioSegment  # noqa
+    from pydub.exceptions import CouldntDecodeError, CouldntEncodeError  # noqa
+
+    PYDUB_AVAILABLE = True
+except (ModuleNotFoundError, ImportError) as e:
+    if "audioop" in str(e) or "pyaudioop" in str(e):
+        # Handle missing audioop/pyaudioop dependency gracefully
+        PYDUB_AVAILABLE = False
+        AudioSegment = None
+        CouldntDecodeError = Exception
+        CouldntEncodeError = Exception
+    else:
+        raise
+
+try:
+    import soundfile as sf
+except (OSError, ModuleNotFoundError):
+    sf = None
+
+
+class SoundDeviceError(Exception):
+    pass
+
+
+class Voice:
+    max_rms = 0
+    min_rms = 1e5
+    pct = 0
+
+    threshold = 0.15
+
+    def __init__(self, audio_format="wav", device_name=None):
+        if sf is None:
+            raise SoundDeviceError
+        try:
+            print("Initializing sound device...")
+            import sounddevice as sd
+
+            self.sd = sd
+
+            devices = sd.query_devices()
+
+            if device_name:
+                # Find the device with matching name
+                device_id = None
+                for i, device in enumerate(devices):
+                    if device_name in device["name"]:
+                        device_id = i
+                        break
+                if device_id is None:
+                    available_inputs = [d["name"] for d in devices if d["max_input_channels"] > 0]
+                    raise ValueError(
+                        f"Device '{device_name}' not found. Available input devices:"
+                        f" {available_inputs}"
+                    )
+
+                print(f"Using input device: {device_name} (ID: {device_id})")
+
+                self.device_id = device_id
+            else:
+                self.device_id = None
+
+        except (OSError, ModuleNotFoundError):
+            raise SoundDeviceError
+        if audio_format not in ["wav", "mp3", "webm"]:
+            raise ValueError(f"Unsupported audio format: {audio_format}")
+        self.audio_format = audio_format
+
+    def callback(self, indata, frames, time, status):
+        """This is called (from a separate thread) for each audio block."""
+        import numpy as np
+
+        rms = np.sqrt(np.mean(indata**2))
+        self.max_rms = max(self.max_rms, rms)
+        self.min_rms = min(self.min_rms, rms)
+
+        rng = self.max_rms - self.min_rms
+        if rng > 0.001:
+            self.pct = (rms - self.min_rms) / rng
+        else:
+            self.pct = 0.5
+
+        self.q.put(indata.copy())
+
+    def get_prompt(self):
+        num = 10
+        if math.isnan(self.pct) or self.pct < self.threshold:
+            cnt = 0
+        else:
+            cnt = int(self.pct * 10)
+
+        bar = "░" * cnt + "█" * (num - cnt)
+        bar = bar[:num]
+
+        dur = time.time() - self.start_time
+        return f"Recording, press ENTER when done... {dur:.1f}sec {bar}"
+
+    def record_and_transcribe(self, history=None, language=None):
+        try:
+            return self.raw_record_and_transcribe(history, language)
+        except KeyboardInterrupt:
+            return
+        except SoundDeviceError as e:
+            print(f"Error: {e}")
+            print("Please ensure you have a working audio input device connected and try again.")
+            return
+
+    def raw_record_and_transcribe(self, history, language):
+        self.q = queue.Queue()
+
+        temp_wav = tempfile.mktemp(suffix=".wav")
+
+        try:
+            sample_rate = int(self.sd.query_devices(self.device_id, "input")["default_samplerate"])
+        except (TypeError, ValueError):
+            sample_rate = 16000  # fallback to 16kHz if unable to query device
+        except self.sd.PortAudioError:
+            raise SoundDeviceError(
+                "No audio input device detected. Please check your audio settings and try again."
+            )
+
+        self.start_time = time.time()
+
+        try:
+            with self.sd.InputStream(
+                samplerate=sample_rate, channels=1, callback=self.callback, device=self.device_id
+            ):
+                prompt(self.get_prompt, refresh_interval=0.1)
+        except self.sd.PortAudioError as err:
+            raise SoundDeviceError(f"Error accessing audio input device: {err}")
+
+        with sf.SoundFile(temp_wav, mode="x", samplerate=sample_rate, channels=1) as file:
+            while not self.q.empty():
+                file.write(self.q.get())
+
+        use_audio_format = self.audio_format
+
+        # Check file size and offer to convert to mp3 if too large
+        file_size = os.path.getsize(temp_wav)
+        if file_size > 24.9 * 1024 * 1024 and self.audio_format == "wav":
+            print("\nWarning: {temp_wav} is too large, switching to mp3 format.")
+            use_audio_format = "mp3"
+
+        filename = temp_wav
+        if use_audio_format != "wav":
+            try:
+                if not PYDUB_AVAILABLE:
+                    print(
+                        f"Warning: pydub not available, cannot convert to {use_audio_format}. Using"
+                        " original WAV file."
+                    )
+                else:
+                    new_filename = tempfile.mktemp(suffix=f".{use_audio_format}")
+                    audio = AudioSegment.from_wav(temp_wav)
+                    audio.export(new_filename, format=use_audio_format)
+                    os.remove(temp_wav)
+                    filename = new_filename
+            except (CouldntDecodeError, CouldntEncodeError) as e:
+                print(f"Error converting audio: {e}")
+            except (OSError, FileNotFoundError) as e:
+                print(f"File system error during conversion: {e}")
+            except Exception as e:
+                print(f"Unexpected error during audio conversion: {e}")
+
+        with open(filename, "rb") as fh:
+            try:
+                transcript = litellm.transcription(
+                    model="whisper-1", file=fh, prompt=history, language=language
+                )
+            except Exception as err:
+                print(f"Unable to transcribe {filename}: {err}")
+                return
+
+        if filename != temp_wav:
+            os.remove(filename)
+
+        text = transcript.text
+        return text
+
+
+if __name__ == "__main__":
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("Please set the OPENAI_API_KEY environment variable.")
+    print(Voice().record_and_transcribe())

aider/waiting.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+"""
+A simple wrapper for rich.status to provide a spinner.
+"""
+
+from rich.console import Console
+
+
+class Spinner:
+    """A wrapper around rich.status.Status for displaying a spinner."""
+
+    def __init__(self, text: str = "Waiting..."):
+        self.text = text
+        self.console = Console()
+        self.status = None
+
+    def step(self, message=None):
+        """Start the spinner or update its text."""
+        if self.status is None:
+            self.status = self.console.status(self.text, spinner="dots2")
+            self.status.start()
+        elif message:
+            self.status.update(message)
+
+    def end(self):
+        """Stop the spinner."""
+        if self.status:
+            self.status.stop()
+            self.status = None
+
+    # Allow use as a context-manager
+    def __enter__(self):
+        self.step()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.end()

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"