chatmcp-cli 0.1.0__py3-none-any.whl

aider/run_cmd.py

@@ -0,0 +1,132 @@
+import os
+import platform
+import subprocess
+import sys
+from io import BytesIO
+
+import pexpect
+import psutil
+
+
+def run_cmd(command, verbose=False, error_print=None, cwd=None):
+    try:
+        if sys.stdin.isatty() and hasattr(pexpect, "spawn") and platform.system() != "Windows":
+            return run_cmd_pexpect(command, verbose, cwd)
+
+        return run_cmd_subprocess(command, verbose, cwd)
+    except OSError as e:
+        error_message = f"Error occurred while running command '{command}': {str(e)}"
+        if error_print is None:
+            print(error_message)
+        else:
+            error_print(error_message)
+        return 1, error_message
+
+
+def get_windows_parent_process_name():
+    try:
+        current_process = psutil.Process()
+        while True:
+            parent = current_process.parent()
+            if parent is None:
+                break
+            parent_name = parent.name().lower()
+            if parent_name in ["powershell.exe", "cmd.exe"]:
+                return parent_name
+            current_process = parent
+        return None
+    except Exception:
+        return None
+
+
+def run_cmd_subprocess(command, verbose=False, cwd=None, encoding=sys.stdout.encoding):
+    if verbose:
+        print("Using run_cmd_subprocess:", command)
+
+    try:
+        shell = os.environ.get("SHELL", "/bin/sh")
+        parent_process = None
+
+        # Determine the appropriate shell
+        if platform.system() == "Windows":
+            parent_process = get_windows_parent_process_name()
+            if parent_process == "powershell.exe":
+                command = f"powershell -Command {command}"
+
+        if verbose:
+            print("Running command:", command)
+            print("SHELL:", shell)
+            if platform.system() == "Windows":
+                print("Parent process:", parent_process)
+
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            shell=True,
+            encoding=encoding,
+            errors="replace",
+            bufsize=0,  # Set bufsize to 0 for unbuffered output
+            universal_newlines=True,
+            cwd=cwd,
+        )
+
+        output = []
+        while True:
+            chunk = process.stdout.read(1)
+            if not chunk:
+                break
+            print(chunk, end="", flush=True)  # Print the chunk in real-time
+            output.append(chunk)  # Store the chunk for later use
+
+        process.wait()
+        return process.returncode, "".join(output)
+    except Exception as e:
+        return 1, str(e)
+
+
+def run_cmd_pexpect(command, verbose=False, cwd=None):
+    """
+    Run a shell command interactively using pexpect, capturing all output.
+
+    :param command: The command to run as a string.
+    :param verbose: If True, print output in real-time.
+    :return: A tuple containing (exit_status, output)
+    """
+    if verbose:
+        print("Using run_cmd_pexpect:", command)
+
+    output = BytesIO()
+
+    def output_callback(b):
+        output.write(b)
+        return b
+
+    try:
+        # Use the SHELL environment variable, falling back to /bin/sh if not set
+        shell = os.environ.get("SHELL", "/bin/sh")
+        if verbose:
+            print("With shell:", shell)
+
+        if os.path.exists(shell):
+            # Use the shell from SHELL environment variable
+            if verbose:
+                print("Running pexpect.spawn with shell:", shell)
+            child = pexpect.spawn(shell, args=["-i", "-c", command], encoding="utf-8", cwd=cwd)
+        else:
+            # Fall back to spawning the command directly
+            if verbose:
+                print("Running pexpect.spawn without shell.")
+            child = pexpect.spawn(command, encoding="utf-8", cwd=cwd)
+
+        # Transfer control to the user, capturing output
+        child.interact(output_filter=output_callback)
+
+        # Wait for the command to finish and get the exit status
+        child.close()
+        return child.exitstatus, output.getvalue().decode("utf-8", errors="replace")
+
+    except (pexpect.ExceptionPexpect, TypeError, ValueError) as e:
+        error_msg = f"Error running command {command}: {e}"
+        return 1, error_msg

aider/scrape.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+
+import re
+import sys
+
+import pypandoc
+
+from aider import __version__, urls, utils
+from aider.dump import dump  # noqa: F401
+
+aider_user_agent = f"Aider/{__version__} +{urls.website}"
+
+# Playwright is nice because it has a simple way to install dependencies on most
+# platforms.
+
+
+def check_env():
+    try:
+        from playwright.sync_api import sync_playwright
+
+        has_pip = True
+    except ImportError:
+        has_pip = False
+
+    try:
+        with sync_playwright() as p:
+            p.chromium.launch()
+            has_chromium = True
+    except Exception:
+        has_chromium = False
+
+    return has_pip, has_chromium
+
+
+def has_playwright():
+    has_pip, has_chromium = check_env()
+    return has_pip and has_chromium
+
+
+def install_playwright(io):
+    has_pip, has_chromium = check_env()
+    if has_pip and has_chromium:
+        return True
+
+    pip_cmd = utils.get_pip_install(["aider-chat[playwright]"])
+    chromium_cmd = "-m playwright install --with-deps chromium"
+    chromium_cmd = [sys.executable] + chromium_cmd.split()
+
+    cmds = ""
+    if not has_pip:
+        cmds += " ".join(pip_cmd) + "\n"
+    if not has_chromium:
+        cmds += " ".join(chromium_cmd) + "\n"
+
+    text = f"""For the best web scraping, install Playwright:
+
+{cmds}
+See {urls.enable_playwright} for more info.
+"""
+
+    io.tool_output(text)
+    if not io.confirm_ask("Install playwright?", default="y"):
+        return
+
+    if not has_pip:
+        success, output = utils.run_install(pip_cmd)
+        if not success:
+            io.tool_error(output)
+            return
+
+    success, output = utils.run_install(chromium_cmd)
+    if not success:
+        io.tool_error(output)
+        return
+
+    return True
+
+
+class Scraper:
+    pandoc_available = None
+    playwright_available = None
+    playwright_instructions_shown = False
+
+    # Public API...
+    def __init__(self, print_error=None, playwright_available=None, verify_ssl=True):
+        """
+        `print_error` - a function to call to print error/debug info.
+        `verify_ssl` - if False, disable SSL certificate verification when scraping.
+        """
+        if print_error:
+            self.print_error = print_error
+        else:
+            self.print_error = print
+
+        self.playwright_available = playwright_available
+        self.verify_ssl = verify_ssl
+
+    def scrape(self, url):
+        """
+        Scrape a url and turn it into readable markdown if it's HTML.
+        If it's plain text or non-HTML, return it as-is.
+
+        `url` - the URL to scrape.
+        """
+
+        if self.playwright_available:
+            content, mime_type = self.scrape_with_playwright(url)
+        else:
+            content, mime_type = self.scrape_with_httpx(url)
+
+        if not content:
+            self.print_error(f"Failed to retrieve content from {url}")
+            return None
+
+        # Check if the content is HTML based on MIME type or content
+        if (mime_type and mime_type.startswith("text/html")) or (
+            mime_type is None and self.looks_like_html(content)
+        ):
+            self.try_pandoc()
+            content = self.html_to_markdown(content)
+
+        return content
+
+    def looks_like_html(self, content):
+        """
+        Check if the content looks like HTML.
+        """
+        if isinstance(content, str):
+            # Check for common HTML tags
+            html_patterns = [
+                r"<!DOCTYPE\s+html",
+                r"<html",
+                r"<head",
+                r"<body",
+                r"<div",
+                r"<p>",
+                r"<a\s+href=",
+            ]
+            return any(re.search(pattern, content, re.IGNORECASE) for pattern in html_patterns)
+        return False
+
+    # Internals...
+    def scrape_with_playwright(self, url):
+        import playwright  # noqa: F401
+        from playwright.sync_api import Error as PlaywrightError
+        from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+        from playwright.sync_api import sync_playwright
+
+        with sync_playwright() as p:
+            try:
+                browser = p.chromium.launch()
+            except Exception as e:
+                self.playwright_available = False
+                self.print_error(str(e))
+                return None, None
+
+            try:
+                context = browser.new_context(ignore_https_errors=not self.verify_ssl)
+                page = context.new_page()
+
+                user_agent = page.evaluate("navigator.userAgent")
+                user_agent = user_agent.replace("Headless", "")
+                user_agent = user_agent.replace("headless", "")
+                user_agent += " " + aider_user_agent
+
+                page.set_extra_http_headers({"User-Agent": user_agent})
+
+                response = None
+                try:
+                    response = page.goto(url, wait_until="networkidle", timeout=5000)
+                except PlaywrightTimeoutError:
+                    print(f"Page didn't quiesce, scraping content anyway: {url}")
+                    response = None
+                except PlaywrightError as e:
+                    self.print_error(f"Error navigating to {url}: {str(e)}")
+                    return None, None
+
+                try:
+                    content = page.content()
+                    mime_type = None
+                    if response:
+                        content_type = response.header_value("content-type")
+                        if content_type:
+                            mime_type = content_type.split(";")[0]
+                except PlaywrightError as e:
+                    self.print_error(f"Error retrieving page content: {str(e)}")
+                    content = None
+                    mime_type = None
+            finally:
+                browser.close()
+
+        return content, mime_type
+
+    def scrape_with_httpx(self, url):
+        import httpx
+
+        headers = {"User-Agent": f"Mozilla./5.0 ({aider_user_agent})"}
+        try:
+            with httpx.Client(
+                headers=headers, verify=self.verify_ssl, follow_redirects=True
+            ) as client:
+                response = client.get(url)
+                response.raise_for_status()
+                return response.text, response.headers.get("content-type", "").split(";")[0]
+        except httpx.HTTPError as http_err:
+            self.print_error(f"HTTP error occurred: {http_err}")
+        except Exception as err:
+            self.print_error(f"An error occurred: {err}")
+        return None, None
+
+    def try_pandoc(self):
+        if self.pandoc_available:
+            return
+
+        try:
+            pypandoc.get_pandoc_version()
+            self.pandoc_available = True
+            return
+        except OSError:
+            pass
+
+        try:
+            pypandoc.download_pandoc(delete_installer=True)
+        except Exception as err:
+            self.print_error(f"Unable to install pandoc: {err}")
+            return
+
+        self.pandoc_available = True
+
+    def html_to_markdown(self, page_source):
+        from bs4 import BeautifulSoup
+
+        soup = BeautifulSoup(page_source, "html.parser")
+        soup = slimdown_html(soup)
+        page_source = str(soup)
+
+        if not self.pandoc_available:
+            return page_source
+
+        try:
+            md = pypandoc.convert_text(page_source, "markdown", format="html")
+        except OSError:
+            return page_source
+
+        md = re.sub(r"</div>", "      ", md)
+        md = re.sub(r"<div>", "     ", md)
+
+        md = re.sub(r"\n\s*\n", "\n\n", md)
+
+        return md
+
+
+def slimdown_html(soup):
+    for svg in soup.find_all("svg"):
+        svg.decompose()
+
+    if soup.img:
+        soup.img.decompose()
+
+    for tag in soup.find_all(href=lambda x: x and x.startswith("data:")):
+        tag.decompose()
+
+    for tag in soup.find_all(src=lambda x: x and x.startswith("data:")):
+        tag.decompose()
+
+    for tag in soup.find_all(True):
+        for attr in list(tag.attrs):
+            if attr != "href":
+                tag.attrs.pop(attr, None)
+
+    return soup
+
+
+def main(url):
+    scraper = Scraper(playwright_available=has_playwright())
+    content = scraper.scrape(url)
+    print(content)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python playw.py <URL>")
+        sys.exit(1)
+    main(sys.argv[1])

aider/sendchat.py

@@ -0,0 +1,61 @@
+from aider.dump import dump  # noqa: F401
+from aider.utils import format_messages
+
+
+def sanity_check_messages(messages):
+    """Check if messages alternate between user and assistant roles.
+    System messages can be interspersed anywhere.
+    Also verifies the last non-system message is from the user.
+    Returns True if valid, False otherwise."""
+    last_role = None
+    last_non_system_role = None
+
+    for msg in messages:
+        role = msg.get("role")
+        if role == "system":
+            continue
+
+        if last_role and role == last_role:
+            turns = format_messages(messages)
+            raise ValueError("Messages don't properly alternate user/assistant:\n\n" + turns)
+
+        last_role = role
+        last_non_system_role = role
+
+    # Ensure last non-system message is from user
+    return last_non_system_role == "user"
+
+
+def ensure_alternating_roles(messages):
+    """Ensure messages alternate between 'assistant' and 'user' roles.
+
+    Inserts empty messages of the opposite role when consecutive messages
+    of the same role are found.
+
+    Args:
+        messages: List of message dictionaries with 'role' and 'content' keys.
+
+    Returns:
+        List of messages with alternating roles.
+    """
+    if not messages:
+        return messages
+
+    fixed_messages = []
+    prev_role = None
+
+    for msg in messages:
+        current_role = msg.get("role")  # Get 'role', None if missing
+
+        # If current role same as previous, insert empty message
+        # of the opposite role
+        if current_role == prev_role:
+            if current_role == "user":
+                fixed_messages.append({"role": "assistant", "content": ""})
+            else:
+                fixed_messages.append({"role": "user", "content": ""})
+
+        fixed_messages.append(msg)
+        prev_role = current_role
+
+    return fixed_messages

aider/special.py

@@ -0,0 +1,203 @@
+import os
+
+ROOT_IMPORTANT_FILES = [
+    # Version Control
+    ".gitignore",
+    ".gitattributes",
+    # Documentation
+    "README",
+    "README.md",
+    "README.txt",
+    "README.rst",
+    "CONTRIBUTING",
+    "CONTRIBUTING.md",
+    "CONTRIBUTING.txt",
+    "CONTRIBUTING.rst",
+    "LICENSE",
+    "LICENSE.md",
+    "LICENSE.txt",
+    "CHANGELOG",
+    "CHANGELOG.md",
+    "CHANGELOG.txt",
+    "CHANGELOG.rst",
+    "SECURITY",
+    "SECURITY.md",
+    "SECURITY.txt",
+    "CODEOWNERS",
+    # Package Management and Dependencies
+    "requirements.txt",
+    "Pipfile",
+    "Pipfile.lock",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "npm-shrinkwrap.json",
+    "Gemfile",
+    "Gemfile.lock",
+    "composer.json",
+    "composer.lock",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "build.sbt",
+    "go.mod",
+    "go.sum",
+    "Cargo.toml",
+    "Cargo.lock",
+    "mix.exs",
+    "rebar.config",
+    "project.clj",
+    "Podfile",
+    "Cartfile",
+    "dub.json",
+    "dub.sdl",
+    # Configuration and Settings
+    ".env",
+    ".env.example",
+    ".editorconfig",
+    "tsconfig.json",
+    "jsconfig.json",
+    ".babelrc",
+    "babel.config.js",
+    ".eslintrc",
+    ".eslintignore",
+    ".prettierrc",
+    ".stylelintrc",
+    "tslint.json",
+    ".pylintrc",
+    ".flake8",
+    ".rubocop.yml",
+    ".scalafmt.conf",
+    ".dockerignore",
+    ".gitpod.yml",
+    "sonar-project.properties",
+    "renovate.json",
+    "dependabot.yml",
+    ".pre-commit-config.yaml",
+    "mypy.ini",
+    "tox.ini",
+    ".yamllint",
+    "pyrightconfig.json",
+    # Build and Compilation
+    "webpack.config.js",
+    "rollup.config.js",
+    "parcel.config.js",
+    "gulpfile.js",
+    "Gruntfile.js",
+    "build.xml",
+    "build.boot",
+    "project.json",
+    "build.cake",
+    "MANIFEST.in",
+    # Testing
+    "pytest.ini",
+    "phpunit.xml",
+    "karma.conf.js",
+    "jest.config.js",
+    "cypress.json",
+    ".nycrc",
+    ".nycrc.json",
+    # CI/CD
+    ".travis.yml",
+    ".gitlab-ci.yml",
+    "Jenkinsfile",
+    "azure-pipelines.yml",
+    "bitbucket-pipelines.yml",
+    "appveyor.yml",
+    "circle.yml",
+    ".circleci/config.yml",
+    ".github/dependabot.yml",
+    "codecov.yml",
+    ".coveragerc",
+    # Docker and Containers
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.override.yml",
+    # Cloud and Serverless
+    "serverless.yml",
+    "firebase.json",
+    "now.json",
+    "netlify.toml",
+    "vercel.json",
+    "app.yaml",
+    "terraform.tf",
+    "main.tf",
+    "cloudformation.yaml",
+    "cloudformation.json",
+    "ansible.cfg",
+    "kubernetes.yaml",
+    "k8s.yaml",
+    # Database
+    "schema.sql",
+    "liquibase.properties",
+    "flyway.conf",
+    # Framework-specific
+    "next.config.js",
+    "nuxt.config.js",
+    "vue.config.js",
+    "angular.json",
+    "gatsby-config.js",
+    "gridsome.config.js",
+    # API Documentation
+    "swagger.yaml",
+    "swagger.json",
+    "openapi.yaml",
+    "openapi.json",
+    # Development environment
+    ".nvmrc",
+    ".ruby-version",
+    ".python-version",
+    "Vagrantfile",
+    # Quality and metrics
+    ".codeclimate.yml",
+    "codecov.yml",
+    # Documentation
+    "mkdocs.yml",
+    "_config.yml",
+    "book.toml",
+    "readthedocs.yml",
+    ".readthedocs.yaml",
+    # Package registries
+    ".npmrc",
+    ".yarnrc",
+    # Linting and formatting
+    ".isort.cfg",
+    ".markdownlint.json",
+    ".markdownlint.yaml",
+    # Security
+    ".bandit",
+    ".secrets.baseline",
+    # Misc
+    ".pypirc",
+    ".gitkeep",
+    ".npmignore",
+]
+
+
+# Normalize the lists once
+NORMALIZED_ROOT_IMPORTANT_FILES = set(os.path.normpath(path) for path in ROOT_IMPORTANT_FILES)
+
+
+def is_important(file_path):
+    file_name = os.path.basename(file_path)
+    dir_name = os.path.normpath(os.path.dirname(file_path))
+    normalized_path = os.path.normpath(file_path)
+
+    # Check for GitHub Actions workflow files
+    if dir_name == os.path.normpath(".github/workflows") and file_name.endswith(".yml"):
+        return True
+
+    return normalized_path in NORMALIZED_ROOT_IMPORTANT_FILES
+
+
+def filter_important_files(file_paths):
+    """
+    Filter a list of file paths to return only those that are commonly important in codebases.
+
+    :param file_paths: List of file paths to check
+    :return: List of file paths that match important file patterns
+    """
+    return list(filter(is_important, file_paths))

aider/urls.py

@@ -0,0 +1,17 @@
+website = "https://aider.chat/"
+add_all_files = "https://aider.chat/docs/faq.html#how-can-i-add-all-the-files-to-the-chat"
+edit_errors = "https://aider.chat/docs/troubleshooting/edit-errors.html"
+git = "https://aider.chat/docs/git.html"
+enable_playwright = "https://aider.chat/docs/install/optional.html#enable-playwright"
+favicon = "https://aider.chat/assets/icons/favicon-32x32.png"
+model_warnings = "https://aider.chat/docs/llms/warnings.html"
+token_limits = "https://aider.chat/docs/troubleshooting/token-limits.html"
+llms = "https://aider.chat/docs/llms.html"
+large_repos = "https://aider.chat/docs/faq.html#can-i-use-aider-in-a-large-mono-repo"
+github_issues = "https://github.com/Aider-AI/aider/issues/new"
+git_index_version = "https://github.com/Aider-AI/aider/issues/211"
+install_properly = "https://aider.chat/docs/troubleshooting/imports.html"
+analytics = "https://aider.chat/docs/more/analytics.html"
+release_notes = "https://aider.chat/HISTORY.html#release-notes"
+edit_formats = "https://aider.chat/docs/more/edit-formats.html"
+models_and_keys = "https://aider.chat/docs/troubleshooting/models-and-keys.html"