aider-ce 0.88.20__py3-none-any.whl

aider/mcp/__init__.py

@@ -0,0 +1,174 @@
+import json
+from pathlib import Path
+
+from aider.mcp.server import HttpStreamingServer, McpServer, SseServer
+
+
+def _parse_mcp_servers_from_json_string(json_string, io, verbose=False, mcp_transport="stdio"):
+    """Parse MCP servers from a JSON string."""
+    servers = []
+
+    try:
+        config = json.loads(json_string)
+        if verbose:
+            io.tool_output("Loading MCP servers from provided JSON string")
+
+        if "mcpServers" in config:
+            for name, server_config in config["mcpServers"].items():
+                if verbose:
+                    io.tool_output(f"Loading MCP server: {name}")
+
+                # Create a server config with name included
+                server_config["name"] = name
+                transport = server_config.get("transport", mcp_transport)
+                if transport == "stdio":
+                    servers.append(McpServer(server_config))
+                elif transport == "http":
+                    servers.append(HttpStreamingServer(server_config))
+                elif transport == "sse":
+                    servers.append(SseServer(server_config))
+
+            if verbose:
+                io.tool_output(f"Loaded {len(servers)} MCP servers from JSON string")
+            return servers
+        else:
+            io.tool_warning("No 'mcpServers' key found in MCP config JSON string")
+    except json.JSONDecodeError:
+        io.tool_error("Invalid JSON in MCP config string")
+    except Exception as e:
+        io.tool_error(f"Error loading MCP config from string: {e}")
+
+    return servers
+
+
+def _resolve_mcp_config_path(file_path, io, verbose=False):
+    """Resolve MCP config file path relative to closest aider.conf.yml, git directory, or CWD."""
+    if not file_path:
+        return None
+
+    # If the path is absolute or already exists, use it as-is
+    path = Path(file_path)
+    if path.is_absolute() or path.exists():
+        return str(path.resolve())
+
+    # Search for the closest aider.conf.yml in parent directories
+    current_dir = Path.cwd()
+    aider_conf_path = None
+
+    for parent in [current_dir] + list(current_dir.parents):
+        conf_file = parent / ".aider.conf.yml"
+        if conf_file.exists():
+            aider_conf_path = parent
+            break
+
+    # If aider.conf.yml found, try relative to that directory
+    if aider_conf_path:
+        resolved_path = aider_conf_path / file_path
+        if resolved_path.exists():
+            if verbose:
+                io.tool_output(f"Resolved MCP config relative to aider.conf.yml: {resolved_path}")
+            return str(resolved_path.resolve())
+
+    # Try to find git root directory
+    git_root = None
+    try:
+        import git
+
+        repo = git.Repo(search_parent_directories=True)
+        git_root = Path(repo.working_tree_dir)
+    except (ImportError, git.InvalidGitRepositoryError, FileNotFoundError):
+        pass
+
+    # If git root found, try relative to that directory
+    if git_root:
+        resolved_path = git_root / file_path
+        if resolved_path.exists():
+            if verbose:
+                io.tool_output(f"Resolved MCP config relative to git root: {resolved_path}")
+            return str(resolved_path.resolve())
+
+    # Finally, try relative to current working directory
+    resolved_path = current_dir / file_path
+    if resolved_path.exists():
+        if verbose:
+            io.tool_output(f"Resolved MCP config relative to CWD: {resolved_path}")
+        return str(resolved_path.resolve())
+
+    # If none found, return the original path (will trigger FileNotFoundError)
+    return str(path.resolve())
+
+
+def _parse_mcp_servers_from_file(file_path, io, verbose=False, mcp_transport="stdio"):
+    """Parse MCP servers from a JSON file."""
+    servers = []
+
+    # Resolve the file path relative to closest aider.conf.yml, git directory, or CWD
+    resolved_file_path = _resolve_mcp_config_path(file_path, io, verbose)
+
+    try:
+        with open(resolved_file_path, "r") as f:
+            config = json.load(f)
+
+        if verbose:
+            io.tool_output(f"Loading MCP servers from file: {file_path}")
+
+        if "mcpServers" in config:
+            for name, server_config in config["mcpServers"].items():
+                if verbose:
+                    io.tool_output(f"Loading MCP server: {name}")
+
+                # Create a server config with name included
+                server_config["name"] = name
+                transport = server_config.get("transport", mcp_transport)
+                if transport == "stdio":
+                    servers.append(McpServer(server_config))
+                elif transport == "http":
+                    servers.append(HttpStreamingServer(server_config))
+
+            if verbose:
+                io.tool_output(f"Loaded {len(servers)} MCP servers from {file_path}")
+            return servers
+        else:
+            io.tool_warning(f"No 'mcpServers' key found in MCP config file: {file_path}")
+    except FileNotFoundError:
+        io.tool_warning(f"MCP config file not found: {file_path}")
+    except json.JSONDecodeError:
+        io.tool_error(f"Invalid JSON in MCP config file: {file_path}")
+    except Exception as e:
+        io.tool_error(f"Error loading MCP config from file: {e}")
+
+    return servers
+
+
+def load_mcp_servers(mcp_servers, mcp_servers_file, io, verbose=False, mcp_transport="stdio"):
+    """Load MCP servers from a JSON string or file."""
+    servers = []
+
+    # First try to load from the JSON string (preferred)
+    if mcp_servers:
+        servers = _parse_mcp_servers_from_json_string(mcp_servers, io, verbose, mcp_transport)
+        if servers:
+            return servers
+
+    # If JSON string failed or wasn't provided, try the file
+    if mcp_servers_file:
+        servers = _parse_mcp_servers_from_file(mcp_servers_file, io, verbose, mcp_transport)
+
+    if not servers:
+        # A default MCP server is actually now necessary for the overall agentic loop
+        # and a dummy server does suffice for the job
+        # because I am not smart enough to figure out why
+        # on coder switch, the agent actually initializes the prompt area twice
+        # once immediately after input for the old coder
+        # and immediately again for the new target coder
+        # which causes a race condition where we are awaiting a coroutine
+        # that can no longer yield control (somehow?)
+        # but somehow having to run through the MCP server checks
+        # allows control to be yielded again somehow
+        # and I cannot figure out just how that is happening
+        # and maybe it is actually prompt_toolkit's fault
+        # but this hack works swimmingly because ???
+        # so sure! why not
+        servers = [McpServer(json.loads('{"aider_default": {}}'))]
+
+    return servers

aider/mcp/server.py

@@ -0,0 +1,149 @@
+import asyncio
+import logging
+import os
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
+
+
+class McpServer:
+    """
+    A client for MCP servers that provides tools to Aider coders. An McpServer class
+    is initialized per configured MCP Server
+
+    Uses the mcp library to create and initialize ClientSession objects.
+    """
+
+    def __init__(self, server_config):
+        """Initialize the MCP tool provider.
+
+        Args:
+            server_config: Configuration for the MCP server
+        """
+        self.config = server_config
+        self.name = server_config.get("name", "unnamed-server")
+        self.session = None
+        self._cleanup_lock: asyncio.Lock = asyncio.Lock()
+        self.exit_stack = AsyncExitStack()
+
+    async def connect(self):
+        """Connect to the MCP server and return the session.
+
+        If a session is already active, returns the existing session.
+        Otherwise, establishes a new connection and initializes the session.
+
+        Returns:
+            ClientSession: The active session
+        """
+        if self.session is not None:
+            logging.info(f"Using existing session for MCP server: {self.name}")
+            return self.session
+
+        logging.info(f"Establishing new connection to MCP server: {self.name}")
+        command = self.config["command"]
+        server_params = StdioServerParameters(
+            command=command,
+            args=self.config.get("args"),
+            env={**os.environ, **self.config["env"]} if self.config.get("env") else None,
+        )
+
+        try:
+            os.makedirs(".aider/logs/", exist_ok=True)
+            with open(".aider/logs/mcp-errors.log", "w") as err_file:
+                stdio_transport = await self.exit_stack.enter_async_context(
+                    stdio_client(server_params, errlog=err_file)
+                )
+                read, write = stdio_transport
+                session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+                await session.initialize()
+                self.session = session
+                return session
+        except Exception as e:
+            logging.error(f"Error initializing server {self.name}: {e}")
+            await self.disconnect()
+            raise
+
+    async def disconnect(self):
+        """Disconnect from the MCP server and clean up resources."""
+        async with self._cleanup_lock:
+            try:
+                await self.exit_stack.aclose()
+                self.session = None
+            except Exception as e:
+                logging.error(f"Error during cleanup of server {self.name}: {e}")
+
+
+class HttpStreamingServer(McpServer):
+    """HTTP streaming MCP server using mcp.client.streamablehttp_client."""
+
+    async def connect(self):
+        if self.session is not None:
+            logging.info(f"Using existing session for MCP server: {self.name}")
+            return self.session
+
+        logging.info(f"Establishing new connection to HTTP MCP server: {self.name}")
+        try:
+            url = self.config.get("url")
+            headers = self.config.get("headers", {})
+            http_transport = await self.exit_stack.enter_async_context(
+                streamablehttp_client(url, headers=headers)
+            )
+            read, write, _response = http_transport
+
+            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            self.session = session
+            return session
+        except Exception as e:
+            logging.error(f"Error initializing HTTP server {self.name}: {e}")
+            await self.disconnect()
+            raise
+
+
+class SseServer(McpServer):
+    """SSE (Server-Sent Events) MCP server using mcp.client.sse_client."""
+
+    async def connect(self):
+        if self.session is not None:
+            logging.info(f"Using existing session for SSE MCP server: {self.name}")
+            return self.session
+
+        logging.info(f"Establishing new connection to SSE MCP server: {self.name}")
+        try:
+            url = self.config.get("url")
+            headers = self.config.get("headers", {})
+            sse_transport = await self.exit_stack.enter_async_context(
+                sse_client(url, headers=headers)
+            )
+            read, write, _response = sse_transport
+            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            self.session = session
+            return session
+        except Exception as e:
+            logging.error(f"Error initializing SSE server {self.name}: {e}")
+            await self.disconnect()
+            raise
+
+
+class LocalServer(McpServer):
+    """
+    A dummy McpServer for executing local, in-process tools
+    that are not provided by an external MCP server.
+    """
+
+    async def connect(self):
+        """Local tools don't need a connection."""
+        if self.session is not None:
+            logging.info(f"Using existing session for local tools: {self.name}")
+            return self.session
+
+        self.session = object()  # Dummy session object
+        return self.session
+
+    async def disconnect(self):
+        """Disconnect from the MCP server and clean up resources."""
+        self.session = None

aider/mdstream.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python
+
+import io
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import CodeBlock, Heading, Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from aider.dump import dump  # noqa: F401
+
+_text_prefix = """
+# Header
+
+Lorem Ipsum is simply dummy text of the printing and typesetting industry.
+Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,
+when an unknown printer took a galley of type and scrambled it to make a type
+specimen book. It has survived not only five centuries, but also the leap into
+electronic typesetting, remaining essentially unchanged. It was popularised in
+the 1960s with the release of Letraset sheets containing Lorem Ipsum passages,
+and more recently with desktop publishing software like Aldus PageMaker
+including versions of Lorem Ipsum.
+
+
+
+## Sub header
+
+- List 1
+- List 2
+- List me
+- List you
+
+
+
+```python
+"""
+
+_text_suffix = """
+```
+
+## Sub header too
+
+The end.
+
+"""  # noqa: E501
+
+
+class NoInsetCodeBlock(CodeBlock):
+    """A code block with syntax highlighting and no padding."""
+
+    def __rich_console__(self, console, options):
+        code = str(self.text).rstrip()
+        syntax = Syntax(code, self.lexer_name, theme=self.theme, word_wrap=True, padding=(1, 0))
+        yield syntax
+
+
+class LeftHeading(Heading):
+    """A heading class that renders left-justified."""
+
+    def __rich_console__(self, console, options):
+        text = self.text
+        text.justify = "left"  # Override justification
+        if self.tag == "h1":
+            # Draw a border around h1s, but keep text left-aligned
+            yield Panel(
+                text,
+                box=box.HEAVY,
+                style="markdown.h1.border",
+            )
+        else:
+            # Styled text for h2 and beyond
+            if self.tag == "h2":
+                yield Text("")  # Keep the blank line before h2
+            yield text
+
+
+class NoInsetMarkdown(Markdown):
+    """Markdown with code blocks that have no padding and left-justified headings."""
+
+    elements = {
+        **Markdown.elements,
+        "fence": NoInsetCodeBlock,
+        "code_block": NoInsetCodeBlock,
+        "heading_open": LeftHeading,
+    }
+
+
+class MarkdownStream:
+    """Streaming markdown renderer that progressively displays content with a live updating window.
+
+    Uses rich.console and rich.live to render markdown content with smooth scrolling
+    and partial updates. Maintains a sliding window of visible content while streaming
+    in new markdown text.
+    """
+
+    live = None  # Rich Live display instance
+    when = 0  # Timestamp of last update
+    min_delay = 1.0 / 20  # Minimum time between updates (20fps)
+    live_window = 6  # Number of lines to keep visible at bottom during streaming
+
+    def __init__(self, mdargs=None):
+        """Initialize the markdown stream.
+
+        Args:
+            mdargs (dict, optional): Additional arguments to pass to rich Markdown renderer
+        """
+        self.printed = []  # Stores lines that have already been printed
+
+        if mdargs:
+            self.mdargs = mdargs
+        else:
+            self.mdargs = dict()
+
+        # Defer Live creation until the first update.
+        self.live = None
+        self._live_started = False
+
+    def _render_markdown_to_lines(self, text):
+        """Render markdown text to a list of lines.
+
+        Args:
+            text (str): Markdown text to render
+
+        Returns:
+            list: List of rendered lines with line endings preserved
+        """
+        # Render the markdown to a string buffer
+        string_io = io.StringIO()
+        console = Console(file=string_io, force_terminal=True)
+        markdown = NoInsetMarkdown(text, **self.mdargs)
+        console.print(markdown)
+        output = string_io.getvalue()
+
+        # Split rendered output into lines
+        return output.splitlines(keepends=True)
+
+    def __del__(self):
+        """Destructor to ensure Live display is properly cleaned up."""
+        if self.live:
+            try:
+                self.live.stop()
+            except Exception:
+                pass  # Ignore any errors during cleanup
+
+    def update(self, text, final=False):
+        """Update the displayed markdown content.
+
+        Args:
+            text (str): The markdown text received so far
+            final (bool): If True, this is the final update and we should clean up
+
+        Splits the output into "stable" older lines and the "last few" lines
+        which aren't considered stable. They may shift around as new chunks
+        are appended to the markdown text.
+
+        The stable lines emit to the console above the Live window.
+        The unstable lines emit into the Live window so they can be repainted.
+
+        Markdown going to the console works better in terminal scrollback buffers.
+        The live window doesn't play nice with terminal scrollback.
+        """
+        # On the first call, stop the spinner and start the Live renderer
+        if not getattr(self, "_live_started", False):
+            self.live = Live(Text(""), refresh_per_second=1.0 / self.min_delay)
+            self.live.start()
+            self._live_started = True
+
+        now = time.time()
+        # Throttle updates to maintain smooth rendering
+        if not final and now - self.when < self.min_delay:
+            return
+        self.when = now
+
+        # Measure render time and adjust min_delay to maintain smooth rendering
+        start = time.time()
+        lines = self._render_markdown_to_lines(text)
+        render_time = time.time() - start
+
+        # Set min_delay to render time plus a small buffer
+        self.min_delay = min(max(render_time * 10, 1.0 / 20), 2)
+
+        num_lines = len(lines)
+
+        # How many lines have "left" the live window and are now considered stable?
+        # Or if final, consider all lines to be stable.
+        if not final:
+            num_lines -= self.live_window
+
+        # If we have stable content to display...
+        if final or num_lines > 0:
+            # How many stable lines do we need to newly show above the live window?
+            num_printed = len(self.printed)
+            show = num_lines - num_printed
+
+            # Skip if no new lines to show above live window
+            if show <= 0:
+                return
+
+            # Get the new lines and display them
+            show = lines[num_printed:num_lines]
+            show = "".join(show)
+            show = Text.from_ansi(show)
+            self.live.console.print(show)  # to the console above the live area
+
+            # Update our record of printed lines
+            self.printed = lines[:num_lines]
+
+        # Handle final update cleanup
+        if final:
+            self.live.update(Text(""))
+            self.live.stop()
+            self.live = None
+            return
+
+        # Update the live window with remaining lines
+        rest = lines[num_lines:]
+        rest = "".join(rest)
+        rest = Text.from_ansi(rest)
+        self.live.update(rest)
+
+    def find_minimal_suffix(self, text, match_lines=50):
+        """
+        Splits text into chunks on blank lines "\n\n".
+        """
+
+
+if __name__ == "__main__":
+    with open("aider/io.py", "r") as f:
+        code = f.read()
+    _text = _text_prefix + code + _text_suffix
+    _text = _text * 10
+
+    pm = MarkdownStream()
+    print("Using NoInsetMarkdown for code blocks with padding=0")
+    for i in range(6, len(_text), 5):
+        pm.update(_text[:i])
+        time.sleep(0.01)
+
+    pm.update(_text, final=True)