chatmcp-cli 0.1.0__py3-none-any.whl

aider/copypaste.py

@@ -0,0 +1,72 @@
+import threading
+import time
+
+import pyperclip
+
+
+class ClipboardWatcher:
+    """Watches clipboard for changes and updates IO placeholder"""
+
+    def __init__(self, io, verbose=False):
+        self.io = io
+        self.verbose = verbose
+        self.stop_event = None
+        self.watcher_thread = None
+        self.last_clipboard = None
+        self.io.clipboard_watcher = self
+
+    def start(self):
+        """Start watching clipboard for changes"""
+        self.stop_event = threading.Event()
+        self.last_clipboard = pyperclip.paste()
+
+        def watch_clipboard():
+            while not self.stop_event.is_set():
+                try:
+                    current = pyperclip.paste()
+                    if current != self.last_clipboard:
+                        self.last_clipboard = current
+                        self.io.interrupt_input()
+                        self.io.placeholder = current
+                        if len(current.splitlines()) > 1:
+                            self.io.placeholder = "\n" + self.io.placeholder + "\n"
+
+                    time.sleep(0.5)
+                except Exception as e:
+                    if self.verbose:
+                        from aider.dump import dump
+
+                        dump(f"Clipboard watcher error: {e}")
+                    continue
+
+        self.watcher_thread = threading.Thread(target=watch_clipboard, daemon=True)
+        self.watcher_thread.start()
+
+    def stop(self):
+        """Stop watching clipboard for 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 main():
+    """Example usage of the clipboard watcher"""
+    from aider.io import InputOutput
+
+    io = InputOutput()
+    watcher = ClipboardWatcher(io, verbose=True)
+
+    try:
+        watcher.start()
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopped watching clipboard")
+        watcher.stop()
+
+
+if __name__ == "__main__":
+    main()

aider/deprecated.py

@@ -0,0 +1,126 @@
+def add_deprecated_model_args(parser, group):
+    """Add deprecated model shortcut arguments to the argparse parser."""
+    opus_model = "claude-3-opus-20240229"
+    group.add_argument(
+        "--opus",
+        action="store_true",
+        help=f"Use {opus_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    sonnet_model = "anthropic/claude-3-7-sonnet-20250219"
+    group.add_argument(
+        "--sonnet",
+        action="store_true",
+        help=f"Use {sonnet_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    haiku_model = "claude-3-5-haiku-20241022"
+    group.add_argument(
+        "--haiku",
+        action="store_true",
+        help=f"Use {haiku_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4_model = "gpt-4-0613"
+    group.add_argument(
+        "--4",
+        "-4",
+        action="store_true",
+        help=f"Use {gpt_4_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4o_model = "gpt-4o"
+    group.add_argument(
+        "--4o",
+        action="store_true",
+        help=f"Use {gpt_4o_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4o_mini_model = "gpt-4o-mini"
+    group.add_argument(
+        "--mini",
+        action="store_true",
+        help=f"Use {gpt_4o_mini_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_4_turbo_model = "gpt-4-1106-preview"
+    group.add_argument(
+        "--4-turbo",
+        action="store_true",
+        help=f"Use {gpt_4_turbo_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    gpt_3_model_name = "gpt-3.5-turbo"
+    group.add_argument(
+        "--35turbo",
+        "--35-turbo",
+        "--3",
+        "-3",
+        action="store_true",
+        help=f"Use {gpt_3_model_name} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    deepseek_model = "deepseek/deepseek-chat"
+    group.add_argument(
+        "--deepseek",
+        action="store_true",
+        help=f"Use {deepseek_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    o1_mini_model = "o1-mini"
+    group.add_argument(
+        "--o1-mini",
+        action="store_true",
+        help=f"Use {o1_mini_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+    o1_preview_model = "o1-preview"
+    group.add_argument(
+        "--o1-preview",
+        action="store_true",
+        help=f"Use {o1_preview_model} model for the main chat (deprecated, use --model)",
+        default=False,
+    )
+
+
+def handle_deprecated_model_args(args, io):
+    """Handle deprecated model shortcut arguments and provide appropriate warnings."""
+    # Define model mapping
+    model_map = {
+        "opus": "claude-3-opus-20240229",
+        "sonnet": "anthropic/claude-3-7-sonnet-20250219",
+        "haiku": "claude-3-5-haiku-20241022",
+        "4": "gpt-4-0613",
+        "4o": "gpt-4o",
+        "mini": "gpt-4o-mini",
+        "4_turbo": "gpt-4-1106-preview",
+        "35turbo": "gpt-3.5-turbo",
+        "deepseek": "deepseek/deepseek-chat",
+        "o1_mini": "o1-mini",
+        "o1_preview": "o1-preview",
+    }
+
+    # Check if any deprecated args are used
+    for arg_name, model_name in model_map.items():
+        arg_name_clean = arg_name.replace("-", "_")
+        if hasattr(args, arg_name_clean) and getattr(args, arg_name_clean):
+            # Find preferred name to display in warning
+            from aider.models import MODEL_ALIASES
+
+            display_name = model_name
+            # Check if there's a shorter alias for this model
+            for alias, full_name in MODEL_ALIASES.items():
+                if full_name == model_name:
+                    display_name = alias
+                    break
+
+            # Show the warning
+            io.tool_warning(
+                f"The --{arg_name.replace('_', '-')} flag is deprecated and will be removed in a"
+                f" future version. Please use --model {display_name} instead."
+            )
+
+            # Set the model
+            if not args.model:
+                args.model = model_name
+            break

aider/diffs.py

@@ -0,0 +1,128 @@
+import difflib
+import sys
+
+from .dump import dump  # noqa: F401
+
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python diffs.py file1 file")
+        sys.exit(1)
+
+    file_orig, file_updated = sys.argv[1], sys.argv[2]
+
+    with open(file_orig, "r", encoding="utf-8") as f:
+        lines_orig = f.readlines()
+
+    with open(file_updated, "r", encoding="utf-8") as f:
+        lines_updated = f.readlines()
+
+    for i in range(len(file_updated)):
+        res = diff_partial_update(lines_orig, lines_updated[:i])
+        print(res)
+        input()
+
+
+def create_progress_bar(percentage):
+    block = "█"
+    empty = "░"
+    total_blocks = 30
+    filled_blocks = int(total_blocks * percentage // 100)
+    empty_blocks = total_blocks - filled_blocks
+    bar = block * filled_blocks + empty * empty_blocks
+    return bar
+
+
+def assert_newlines(lines):
+    if not lines:
+        return
+    for line in lines[:-1]:
+        assert line and line[-1] == "\n", line
+
+
+def diff_partial_update(lines_orig, lines_updated, final=False, fname=None):
+    """
+    Given only the first part of an updated file, show the diff while
+    ignoring the block of "deleted" lines that are past the end of the
+    partially complete update.
+    """
+
+    # dump(lines_orig)
+    # dump(lines_updated)
+
+    assert_newlines(lines_orig)
+
+    num_orig_lines = len(lines_orig)
+
+    if final:
+        last_non_deleted = num_orig_lines
+    else:
+        last_non_deleted = find_last_non_deleted(lines_orig, lines_updated)
+
+    # dump(last_non_deleted)
+    if last_non_deleted is None:
+        return ""
+
+    if num_orig_lines:
+        pct = last_non_deleted * 100 / num_orig_lines
+    else:
+        pct = 50
+    bar = create_progress_bar(pct)
+    bar = f" {last_non_deleted:3d} / {num_orig_lines:3d} lines [{bar}] {pct:3.0f}%\n"
+
+    lines_orig = lines_orig[:last_non_deleted]
+
+    if not final:
+        lines_updated = lines_updated[:-1] + [bar]
+
+    diff = difflib.unified_diff(lines_orig, lines_updated, n=5)
+
+    diff = list(diff)[2:]
+
+    diff = "".join(diff)
+    if not diff.endswith("\n"):
+        diff += "\n"
+
+    for i in range(3, 10):
+        backticks = "`" * i
+        if backticks not in diff:
+            break
+
+    show = f"{backticks}diff\n"
+    if fname:
+        show += f"--- {fname} original\n"
+        show += f"+++ {fname} updated\n"
+
+    show += diff
+
+    show += f"{backticks}\n\n"
+
+    # print(diff)
+
+    return show
+
+
+def find_last_non_deleted(lines_orig, lines_updated):
+    diff = list(difflib.ndiff(lines_orig, lines_updated))
+
+    num_orig = 0
+    last_non_deleted_orig = None
+
+    for line in diff:
+        # print(f"{num_orig:2d} {num_updated:2d} {line}", end="")
+        code = line[0]
+        if code == " ":
+            num_orig += 1
+            last_non_deleted_orig = num_orig
+        elif code == "-":
+            # line only in orig
+            num_orig += 1
+        elif code == "+":
+            # line only in updated
+            pass
+
+    return last_non_deleted_orig
+
+
+if __name__ == "__main__":
+    main()

aider/dump.py

@@ -0,0 +1,29 @@
+import json
+import traceback
+
+
+def cvt(s):
+    if isinstance(s, str):
+        return s
+    try:
+        return json.dumps(s, indent=4)
+    except TypeError:
+        return str(s)
+
+
+def dump(*vals):
+    # http://docs.python.org/library/traceback.html
+    stack = traceback.extract_stack()
+    vars = stack[-2][3]
+
+    # strip away the call to dump()
+    vars = "(".join(vars.split("(")[1:])
+    vars = ")".join(vars.split(")")[:-1])
+
+    vals = [cvt(v) for v in vals]
+    has_newline = sum(1 for v in vals if "\n" in v)
+    if has_newline:
+        print("%s:" % vars)
+        print(", ".join(vals))
+    else:
+        print("%s:" % vars, ", ".join(vals))

aider/editor.py

@@ -0,0 +1,147 @@
+"""
+Editor module for handling system text editor interactions.
+
+This module provides functionality to:
+- Discover and launch the system's configured text editor
+- Create and manage temporary files for editing
+- Handle editor preferences from environment variables
+- Support cross-platform editor operations
+"""
+
+import os
+import platform
+import subprocess
+import tempfile
+
+from rich.console import Console
+
+from aider.dump import dump  # noqa
+
+DEFAULT_EDITOR_NIX = "vi"
+DEFAULT_EDITOR_OS_X = "vim"
+DEFAULT_EDITOR_WINDOWS = "notepad"
+
+console = Console()
+
+
+def print_status_message(success, message, style=None):
+    """
+    Print a status message with appropriate styling.
+
+    :param success: Whether the operation was successful
+    :param message: The message to display
+    :param style: Optional style override. If None, uses green for success and red for failure
+    """
+    if style is None:
+        style = "bold green" if success else "bold red"
+    console.print(message, style=style)
+    print("")
+
+
+def write_temp_file(
+    input_data="",
+    suffix=None,
+    prefix=None,
+    dir=None,
+):
+    """
+    Create a temporary file with the given input data.
+
+    :param input_data: Content to write to the temporary file
+    :param suffix: Optional file extension (without the dot)
+    :param prefix: Optional prefix for the temporary filename
+    :param dir: Optional directory to create the file in
+    :return: Path to the created temporary file
+    :raises: OSError if file creation or writing fails
+    """
+    kwargs = {"prefix": prefix, "dir": dir}
+    if suffix:
+        kwargs["suffix"] = f".{suffix}"
+    fd, filepath = tempfile.mkstemp(**kwargs)
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(input_data)
+    except Exception:
+        os.close(fd)
+        raise
+    return filepath
+
+
+def get_environment_editor(default=None):
+    """
+    Fetches the preferred editor from the environment variables.
+
+    This function checks the following environment variables in order to
+    determine the user's preferred editor:
+
+     - VISUAL
+     - EDITOR
+
+    :param default: The default editor to return if no environment variable is set.
+    :type default: str or None
+    :return: The preferred editor as specified by environment variables or the default value.
+    :rtype: str or None
+    """
+    editor = os.environ.get("VISUAL", os.environ.get("EDITOR", default))
+    return editor
+
+
+def discover_editor(editor_override=None):
+    """
+    Discovers and returns the appropriate editor command.
+
+    Handles cases where the editor command includes arguments, including quoted arguments
+    with spaces (e.g. 'vim -c "set noswapfile"').
+
+    :return: The editor command as a string
+    :rtype: str
+    """
+    system = platform.system()
+    if system == "Windows":
+        default_editor = DEFAULT_EDITOR_WINDOWS
+    elif system == "Darwin":
+        default_editor = DEFAULT_EDITOR_OS_X
+    else:
+        default_editor = DEFAULT_EDITOR_NIX
+
+    if editor_override:
+        editor = editor_override
+    else:
+        editor = get_environment_editor(default_editor)
+
+    return editor
+
+
+def pipe_editor(input_data="", suffix=None, editor=None):
+    """
+    Opens the system editor with optional input data and returns the edited content.
+
+    This function creates a temporary file with the provided input data, opens it in
+    the system editor, waits for the user to make changes and close the editor, then
+    reads and returns the modified content. The temporary file is deleted afterwards.
+
+    :param input_data: Initial content to populate the editor with
+    :type input_data: str
+    :param suffix: Optional file extension for the temporary file (e.g. '.txt', '.md')
+    :type suffix: str or None
+    :return: The edited content after the editor is closed
+    :rtype: str
+    """
+    filepath = write_temp_file(input_data, suffix)
+    command_str = discover_editor(editor)
+    command_str += " " + filepath
+
+    subprocess.call(command_str, shell=True)
+    with open(filepath, "r") as f:
+        output_data = f.read()
+    try:
+        os.remove(filepath)
+    except PermissionError:
+        print_status_message(
+            False,
+            (
+                f"WARNING: Unable to delete temporary file {filepath!r}. You may need to delete it"
+                " manually."
+            ),
+        )
+    return output_data

aider/exceptions.py

@@ -0,0 +1,107 @@
+from dataclasses import dataclass
+
+from aider.dump import dump  # noqa: F401
+
+
+@dataclass
+class ExInfo:
+    name: str
+    retry: bool
+    description: str
+
+
+EXCEPTIONS = [
+    ExInfo("APIConnectionError", True, None),
+    ExInfo("APIError", True, None),
+    ExInfo("APIResponseValidationError", True, None),
+    ExInfo(
+        "AuthenticationError",
+        False,
+        "The API provider is not able to authenticate you. Check your API key.",
+    ),
+    ExInfo("AzureOpenAIError", True, None),
+    ExInfo("BadRequestError", False, None),
+    ExInfo("BudgetExceededError", True, None),
+    ExInfo(
+        "ContentPolicyViolationError",
+        True,
+        "The API provider has refused the request due to a safety policy about the content.",
+    ),
+    ExInfo("ContextWindowExceededError", False, None),  # special case handled in base_coder
+    ExInfo("InternalServerError", True, "The API provider's servers are down or overloaded."),
+    ExInfo("InvalidRequestError", True, None),
+    ExInfo("JSONSchemaValidationError", True, None),
+    ExInfo("NotFoundError", False, None),
+    ExInfo("OpenAIError", True, None),
+    ExInfo(
+        "RateLimitError",
+        True,
+        "The API provider has rate limited you. Try again later or check your quotas.",
+    ),
+    ExInfo("RouterRateLimitError", True, None),
+    ExInfo("ServiceUnavailableError", True, "The API provider's servers are down or overloaded."),
+    ExInfo("UnprocessableEntityError", True, None),
+    ExInfo("UnsupportedParamsError", True, None),
+    ExInfo(
+        "Timeout",
+        True,
+        "The API provider timed out without returning a response. They may be down or overloaded.",
+    ),
+]
+
+
+class LiteLLMExceptions:
+    exceptions = dict()
+    exception_info = {exi.name: exi for exi in EXCEPTIONS}
+
+    def __init__(self):
+        self._load()
+
+    def _load(self, strict=False):
+        import litellm
+
+        for var in dir(litellm):
+            if var.endswith("Error"):
+                if var not in self.exception_info:
+                    raise ValueError(f"{var} is in litellm but not in aider's exceptions list")
+
+        for var in self.exception_info:
+            ex = getattr(litellm, var)
+            self.exceptions[ex] = self.exception_info[var]
+
+    def exceptions_tuple(self):
+        return tuple(self.exceptions)
+
+    def get_ex_info(self, ex):
+        """Return the ExInfo for a given exception instance"""
+        import litellm
+
+        if ex.__class__ is litellm.APIConnectionError:
+            if "google.auth" in str(ex):
+                return ExInfo(
+                    "APIConnectionError", False, "You need to: pip install google-generativeai"
+                )
+            if "boto3" in str(ex):
+                return ExInfo("APIConnectionError", False, "You need to: pip install boto3")
+            if "OpenrouterException" in str(ex) and "'choices'" in str(ex):
+                return ExInfo(
+                    "APIConnectionError",
+                    True,
+                    (
+                        "OpenRouter or the upstream API provider is down, overloaded or rate"
+                        " limiting your requests."
+                    ),
+                )
+
+        # Check for specific non-retryable APIError cases like insufficient credits
+        if ex.__class__ is litellm.APIError:
+            err_str = str(ex).lower()
+            if "insufficient credits" in err_str and '"code":402' in err_str:
+                return ExInfo(
+                    "APIError",
+                    False,
+                    "Insufficient credits with the API provider. Please add credits.",
+                )
+            # Fall through to default APIError handling if not the specific credits error
+
+        return self.exceptions.get(ex.__class__, ExInfo(None, None, None))

aider/format_settings.py

@@ -0,0 +1,26 @@
+def scrub_sensitive_info(args, text):
+    # Replace sensitive information with last 4 characters
+    if text and args.openai_api_key:
+        last_4 = args.openai_api_key[-4:]
+        text = text.replace(args.openai_api_key, f"...{last_4}")
+    if text and args.anthropic_api_key:
+        last_4 = args.anthropic_api_key[-4:]
+        text = text.replace(args.anthropic_api_key, f"...{last_4}")
+    return text
+
+
+def format_settings(parser, args):
+    show = scrub_sensitive_info(args, parser.format_values())
+    # clean up the headings for consistency w/ new lines
+    heading_env = "Environment Variables:"
+    heading_defaults = "Defaults:"
+    if heading_env in show:
+        show = show.replace(heading_env, "\n" + heading_env)
+        show = show.replace(heading_defaults, "\n" + heading_defaults)
+    show += "\n"
+    show += "Option settings:\n"
+    for arg, val in sorted(vars(args).items()):
+        if val:
+            val = scrub_sensitive_info(args, str(val))
+        show += f"  - {arg}: {val}\n"  # noqa: E221
+    return show