patch-chat 0.1.0__py3-none-any.whl

patch/main.py

@@ -0,0 +1,1466 @@
+import json
+import os
+import re
+import sys
+import threading
+import traceback
+import webbrowser
+from dataclasses import fields
+from pathlib import Path
+
+try:
+    import git
+except ImportError:
+    git = None
+
+import importlib_resources
+import shtab
+import yaml
+from dotenv import dotenv_values, load_dotenv
+from prompt_toolkit.enums import EditingMode
+
+from patch import __version__, models, urls, utils
+from patch.analytics import Analytics
+from patch.args import get_parser
+from patch.coders import Coder
+from patch.coders.base_coder import UnknownEditFormat
+from patch.commands import Commands, SwitchCoder
+from patch.copypaste import ClipboardWatcher
+from patch.deprecated import handle_deprecated_model_args
+from patch.format_settings import format_settings, scrub_sensitive_info
+from patch.history import ChatSummary
+from patch.io import InputOutput
+from patch.llm import litellm  # noqa: F401; properly init litellm on launch
+from patch.models import ModelSettings
+from patch.onboarding import offer_openrouter_oauth, select_default_model
+from patch.repo import ANY_GIT_ERROR, GitRepo
+from patch.report import report_uncaught_exceptions
+from patch.versioncheck import check_version, install_from_main_branch, install_upgrade
+from patch.watch import FileWatcher
+
+from .dump import dump  # noqa: F401
+
+
+def check_config_files_for_yes(config_files):
+    found = False
+    for config_file in config_files:
+        if Path(config_file).exists():
+            try:
+                with open(config_file, "r") as f:
+                    for line in f:
+                        if line.strip().startswith("yes:"):
+                            print("Configuration error detected.")
+                            print(f"The file {config_file} contains a line starting with 'yes:'")
+                            print("Please replace 'yes:' with 'yes-always:' in this file.")
+                            found = True
+            except Exception:
+                pass
+    return found
+
+
+def get_git_root():
+    """Try and guess the git repo, since the conf.yml can be at the repo root"""
+    try:
+        repo = git.Repo(search_parent_directories=True)
+        return repo.working_tree_dir
+    except (git.InvalidGitRepositoryError, FileNotFoundError):
+        return None
+
+
+def guessed_wrong_repo(io, git_root, fnames, git_dname):
+    """After we parse the args, we can determine the real repo. Did we guess wrong?"""
+
+    try:
+        check_repo = Path(GitRepo(io, fnames, git_dname).root).resolve()
+    except (OSError,) + ANY_GIT_ERROR:
+        return
+
+    # we had no guess, rely on the "true" repo result
+    if not git_root:
+        return str(check_repo)
+
+    git_root = Path(git_root).resolve()
+    if check_repo == git_root:
+        return
+
+    return str(check_repo)
+
+
+def make_new_repo(git_root, io):
+    try:
+        repo = git.Repo.init(git_root)
+        check_gitignore(git_root, io, False)
+    except ANY_GIT_ERROR as err:  # issue #1233
+        io.tool_error(f"Unable to create git repo in {git_root}")
+        io.tool_output(str(err))
+        return
+
+    io.tool_output(f"Git repository created in {git_root}")
+    return repo
+
+
+def setup_git(git_root, io):
+    if git is None:
+        return
+
+    try:
+        cwd = Path.cwd()
+    except OSError:
+        cwd = None
+
+    repo = None
+
+    if git_root:
+        try:
+            repo = git.Repo(git_root)
+        except ANY_GIT_ERROR:
+            pass
+    elif cwd == Path.home():
+        io.tool_warning(
+            "You should probably run Patch in your project's directory, not your home dir."
+        )
+        return
+    elif cwd and io.confirm_ask(
+        "No git repo found, create one to track Patch's changes (recommended)?"
+    ):
+        git_root = str(cwd.resolve())
+        repo = make_new_repo(git_root, io)
+
+    if not repo:
+        return
+
+    try:
+        user_name = repo.git.config("--get", "user.name") or None
+    except git.exc.GitCommandError:
+        user_name = None
+
+    try:
+        user_email = repo.git.config("--get", "user.email") or None
+    except git.exc.GitCommandError:
+        user_email = None
+
+    if user_name and user_email:
+        return repo.working_tree_dir
+
+    with repo.config_writer() as git_config:
+        if not user_name:
+            git_config.set_value("user", "name", "Your Name")
+            io.tool_warning('Update git name with: git config user.name "Your Name"')
+        if not user_email:
+            git_config.set_value("user", "email", "you@example.com")
+            io.tool_warning('Update git email with: git config user.email "you@example.com"')
+
+    return repo.working_tree_dir
+
+
+def check_gitignore(git_root, io, ask=True):
+    if not git_root:
+        return
+
+    try:
+        repo = git.Repo(git_root)
+        patterns_to_add = []
+
+        if not repo.ignored(".patch"):
+            patterns_to_add.append(".patch*")
+
+        env_path = Path(git_root) / ".env"
+        if env_path.exists() and not repo.ignored(".env"):
+            patterns_to_add.append(".env")
+
+        if not patterns_to_add:
+            return
+
+        gitignore_file = Path(git_root) / ".gitignore"
+        if gitignore_file.exists():
+            try:
+                content = io.read_text(gitignore_file)
+                if content is None:
+                    return
+                if not content.endswith("\n"):
+                    content += "\n"
+            except OSError as e:
+                io.tool_error(f"Error when trying to read {gitignore_file}: {e}")
+                return
+        else:
+            content = ""
+    except ANY_GIT_ERROR:
+        return
+
+    if ask:
+        io.tool_output("You can skip this check with --no-gitignore")
+        if not io.confirm_ask(f"Add {', '.join(patterns_to_add)} to .gitignore (recommended)?"):
+            return
+
+    content += "\n".join(patterns_to_add) + "\n"
+
+    try:
+        io.write_text(gitignore_file, content)
+        io.tool_output(f"Added {', '.join(patterns_to_add)} to .gitignore")
+    except OSError as e:
+        io.tool_error(f"Error when trying to write to {gitignore_file}: {e}")
+        io.tool_output(
+            "Try running with appropriate permissions or manually add these patterns to .gitignore:"
+        )
+        for pattern in patterns_to_add:
+            io.tool_output(f"  {pattern}")
+
+
+def check_streamlit_install(io):
+    return utils.check_pip_install_extra(
+        io,
+        "streamlit",
+        "You need to install the Patch browser feature",
+        ["patch-chat[browser]"],
+    )
+
+
+def write_streamlit_credentials():
+    from streamlit.file_util import get_streamlit_file_path
+
+    # See https://github.com/PierrunoYT/patch/issues/772
+
+    credential_path = Path(get_streamlit_file_path()) / "credentials.toml"
+    if not os.path.exists(credential_path):
+        empty_creds = '[general]\nemail = ""\n'
+
+        os.makedirs(os.path.dirname(credential_path), exist_ok=True)
+        with open(credential_path, "w") as f:
+            f.write(empty_creds)
+    else:
+        print("Streamlit credentials already exist.")
+
+
+def launch_gui(args):
+    from streamlit.web import cli
+
+    from patch import gui
+
+    print()
+    print("CONTROL-C to exit...")
+
+    # Necessary so streamlit does not prompt the user for an email address.
+    write_streamlit_credentials()
+
+    target = gui.__file__
+
+    st_args = ["run", target]
+
+    st_args += [
+        "--browser.gatherUsageStats=false",
+        "--runner.magicEnabled=false",
+        "--server.runOnSave=false",
+    ]
+
+    # https://github.com/PierrunoYT/patch/issues/2193
+    is_dev = "-dev" in str(__version__)
+
+    if is_dev:
+        print("Watching for file changes.")
+    else:
+        st_args += [
+            "--global.developmentMode=false",
+            "--server.fileWatcherType=none",
+            "--client.toolbarMode=viewer",  # minimal?
+        ]
+
+    st_args += ["--"] + args
+
+    cli.main(st_args)
+
+    # from click.testing import CliRunner
+    # runner = CliRunner()
+    # from streamlit.web import bootstrap
+    # bootstrap.load_config_options(flag_options={})
+    # cli.main_run(target, args)
+    # sys.argv = ['streamlit', 'run', '--'] + args
+
+
+def parse_lint_cmds(lint_cmds, io):
+    err = False
+    res = dict()
+    for lint_cmd in lint_cmds:
+        if re.match(r"^[a-z]+:.*", lint_cmd):
+            pieces = lint_cmd.split(":")
+            lang = pieces[0]
+            cmd = lint_cmd[len(lang) + 1 :]
+            lang = lang.strip()
+        else:
+            lang = None
+            cmd = lint_cmd
+
+        cmd = cmd.strip()
+
+        if cmd:
+            res[lang] = cmd
+        else:
+            io.tool_error(f'Unable to parse --lint-cmd "{lint_cmd}"')
+            io.tool_output('The arg should be "language: cmd --args ..."')
+            io.tool_output('For example: --lint-cmd "python: flake8 --select=E9"')
+            err = True
+    if err:
+        return
+    return res
+
+
+# The repository under edit is untrusted input: the whole point of the tool is
+# to be pointed at code you have not reviewed yet. These settings either run a
+# shell command, load arbitrary files, or weaken transport security, so they are
+# refused when they arrive from a config/env file inside that repository.
+# Pass --trust-repo-config (command line only) to opt back in.
+UNSAFE_CONFIG_KEYS = {
+    "test",
+    "test-cmd",
+    "lint",
+    "lint-cmd",
+    "auto-test",
+    "auto-lint",
+    "load",
+    "notifications-command",
+    "editor",
+    "verify-ssl",
+    "git-commit-verify",
+    # Listed here so a repository cannot grant itself trust from its own
+    # .patch.conf.yml or .env.
+    "trust-repo-config",
+}
+
+# Variables that redirect where prompts and source code are sent, or that
+# substitute credentials.
+UNSAFE_ENV_VARS = {
+    "ALL_PROXY",
+    "CURL_CA_BUNDLE",
+    "HTTPS_PROXY",
+    "HTTP_PROXY",
+    "REQUESTS_CA_BUNDLE",
+    "SSL_CERT_FILE",
+}
+
+UNSAFE_ENV_SUFFIXES = ("_API_BASE", "_BASE_URL", "_API_URL", "_ENDPOINT")
+
+
+def config_key_to_dest(key):
+    return str(key).strip().lower().replace("-", "_")
+
+
+def env_flag_is_set(name):
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return value.strip().lower() in ("1", "true", "yes", "on")
+
+
+def is_unsafe_env_var(name):
+    upper = str(name).strip().upper()
+
+    if upper in UNSAFE_ENV_VARS:
+        return True
+    if upper.endswith(UNSAFE_ENV_SUFFIXES):
+        return True
+
+    # PATCH_TEST_CMD, PATCH_LINT_CMD, PATCH_LOAD, ... reach argparse through
+    # auto_env_var_prefix and are exactly as dangerous as the yaml keys.
+    if upper.startswith("PATCH_"):
+        dest = upper[len("PATCH_") :].lower()
+        if dest in {config_key_to_dest(key) for key in UNSAFE_CONFIG_KEYS}:
+            return True
+
+    return False
+
+
+def is_trusted_config_path(fname, default_file, command_line_file=None):
+    """Is this config/env file the user's own, rather than the repository's?
+
+    Only the home-directory copy and a path the user named explicitly on the
+    command line are trusted. Anything auto-discovered in the cwd or the git
+    root ships with the code being edited.
+    """
+    try:
+        resolved = Path(fname).resolve()
+    except (OSError, RuntimeError):
+        return False
+
+    candidates = [Path.home() / default_file, Path.home() / ".patch" / "oauth-keys.env"]
+    if command_line_file:
+        candidates.append(Path(command_line_file))
+
+    for candidate in candidates:
+        try:
+            if resolved == Path(candidate).resolve():
+                return True
+        except (OSError, RuntimeError):
+            pass
+
+    return False
+
+
+def unsafe_keys_in_config(fname):
+    try:
+        with open(fname, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+    except Exception:
+        return set()
+
+    if not isinstance(data, dict):
+        return set()
+
+    return {key for key in data if str(key).strip().lower() in UNSAFE_CONFIG_KEYS}
+
+
+def key_given_on_command_line(key, argv):
+    dest = config_key_to_dest(key)
+    flag = dest.replace("_", "-")
+    variants = {f"--{flag}", f"--no-{flag}", f"--{dest}"}
+
+    for arg in argv or []:
+        if str(arg).split("=", 1)[0] in variants:
+            return True
+
+    return False
+
+
+def sanitize_repo_config(args, parser, config_files, argv, printer=print):
+    """Drop execution-capable settings that came from a repo-local config file.
+
+    Values given on the command line always win, so an explicit --test-cmd is
+    left alone; only auto-discovered repository config is stripped.
+    """
+    blocked = {}
+
+    for fname in config_files:
+        if is_trusted_config_path(
+            fname, Path(".patch.conf.yml"), getattr(args, "config_file", None)
+        ):
+            continue
+        for key in unsafe_keys_in_config(fname):
+            if key_given_on_command_line(key, argv):
+                continue
+            blocked.setdefault(config_key_to_dest(key), set()).add(str(fname))
+
+    for dest, files in sorted(blocked.items()):
+        if not hasattr(args, dest):
+            continue
+        setattr(args, dest, parser.get_default(dest))
+        for fname in sorted(files):
+            printer(f"Ignoring untrusted setting '{dest}' from repository config {fname}")
+
+    if blocked:
+        printer("Pass --trust-repo-config to allow settings from this repository's config.")
+
+    return set(blocked)
+
+
+def generate_search_path_list(default_file, git_root, command_line_file):
+    files = []
+    files.append(Path.home() / default_file)  # homedir
+    if git_root:
+        files.append(Path(git_root) / default_file)  # git root
+    files.append(default_file)
+    if command_line_file:
+        files.append(command_line_file)
+
+    resolved_files = []
+    for fn in files:
+        try:
+            resolved_files.append(Path(fn).resolve())
+        except OSError:
+            pass
+
+    files = resolved_files
+    files.reverse()
+    uniq = []
+    for fn in files:
+        if fn not in uniq:
+            uniq.append(fn)
+    uniq.reverse()
+    files = uniq
+    files = list(map(str, files))
+    files = list(dict.fromkeys(files))
+
+    return files
+
+
+def register_models(git_root, model_settings_fname, io, verbose=False):
+    model_settings_files = generate_search_path_list(
+        ".patch.model.settings.yml", git_root, model_settings_fname
+    )
+
+    try:
+        files_loaded = models.register_models(model_settings_files)
+        if len(files_loaded) > 0:
+            if verbose:
+                io.tool_output("Loaded model settings from:")
+                for file_loaded in files_loaded:
+                    io.tool_output(f"  - {file_loaded}")  # noqa: E221
+        elif verbose:
+            io.tool_output("No model settings files loaded")
+    except Exception as e:
+        io.tool_error(f"Error loading Patch model settings: {e}")
+        return 1
+
+    if verbose:
+        io.tool_output("Searched for model settings files:")
+        for file in model_settings_files:
+            io.tool_output(f"  - {file}")
+
+    return None
+
+
+def load_dotenv_files(git_root, dotenv_fname, encoding="utf-8", trust_repo=False, printer=print):
+    # Standard .env file search path
+    dotenv_files = generate_search_path_list(
+        ".env",
+        git_root,
+        dotenv_fname,
+    )
+
+    # Explicitly add the OAuth keys file to the beginning of the list
+    oauth_keys_file = Path.home() / ".patch" / "oauth-keys.env"
+    if oauth_keys_file.exists():
+        # Insert at the beginning so it's loaded first (and potentially overridden)
+        dotenv_files.insert(0, str(oauth_keys_file.resolve()))
+        # Remove duplicates if it somehow got included by generate_search_path_list
+        dotenv_files = list(dict.fromkeys(dotenv_files))
+
+    loaded = []
+    for fname in dotenv_files:
+        try:
+            if not Path(fname).exists():
+                continue
+
+            if trust_repo or is_trusted_config_path(fname, Path(".env"), dotenv_fname):
+                load_dotenv(fname, override=True, encoding=encoding)
+            else:
+                load_untrusted_dotenv(fname, encoding, printer)
+
+            loaded.append(fname)
+        except OSError as e:
+            print(f"OSError loading {fname}: {e}")
+        except Exception as e:
+            print(f"Error loading {fname}: {e}")
+    return loaded
+
+
+def load_untrusted_dotenv(fname, encoding, printer=print):
+    """Apply a repository-local .env, minus the vars that redirect or impersonate.
+
+    Blocking only the dangerous names keeps the common case working -- a project
+    .env that sets a model or an API key still loads -- while removing the
+    exfiltration primitive (pointing *_API_BASE at an attacker endpoint).
+    """
+    blocked = []
+
+    for key, value in dotenv_values(fname, encoding=encoding).items():
+        if is_unsafe_env_var(key):
+            blocked.append(key)
+            continue
+        if value is not None:
+            os.environ[key] = value
+
+    for key in sorted(blocked):
+        printer(f"Ignoring untrusted env var '{key}' from repository .env {fname}")
+
+    if blocked:
+        printer("Pass --trust-repo-config to allow env vars from this repository.")
+
+    return blocked
+
+
+def register_litellm_models(git_root, model_metadata_fname, io, verbose=False):
+    model_metadata_files = []
+
+    # Add the resource file path
+    resource_metadata = importlib_resources.files("patch.resources").joinpath("model-metadata.json")
+    model_metadata_files.append(str(resource_metadata))
+
+    model_metadata_files += generate_search_path_list(
+        ".patch.model.metadata.json", git_root, model_metadata_fname
+    )
+
+    try:
+        model_metadata_files_loaded = models.register_litellm_models(model_metadata_files)
+        if len(model_metadata_files_loaded) > 0 and verbose:
+            io.tool_output("Loaded model metadata from:")
+            for model_metadata_file in model_metadata_files_loaded:
+                io.tool_output(f"  - {model_metadata_file}")  # noqa: E221
+    except Exception as e:
+        io.tool_error(f"Error loading model metadata models: {e}")
+        return 1
+
+
+def sanity_check_repo(repo, io):
+    if not repo:
+        return True
+
+    if not repo.repo.working_tree_dir:
+        io.tool_error("The git repo does not seem to have a working tree?")
+        return False
+
+    bad_ver = False
+    try:
+        repo.get_tracked_files()
+        if not repo.git_repo_error:
+            return True
+        error_msg = str(repo.git_repo_error)
+    except UnicodeDecodeError as exc:
+        error_msg = (
+            "Failed to read the Git repository. This issue is likely caused by a path encoded "
+            f'in a format different from the expected encoding "{sys.getfilesystemencoding()}".\n'
+            f"Internal error: {str(exc)}"
+        )
+    except ANY_GIT_ERROR as exc:
+        error_msg = str(exc)
+        bad_ver = "version in (1, 2)" in error_msg
+    except AssertionError as exc:
+        error_msg = str(exc)
+        bad_ver = True
+
+    if bad_ver:
+        io.tool_error("Patch only works with git repos with version number 1 or 2.")
+        io.tool_output("You may be able to convert your repo: git update-index --index-version=2")
+        io.tool_output("Or run patch --no-git to proceed without using git.")
+        io.offer_url(urls.git_index_version, "Open documentation url for more info?")
+        return False
+
+    io.tool_error("Unable to read git repository, it may be corrupt?")
+    io.tool_output(error_msg)
+    return False
+
+
+def main(argv=None, input=None, output=None, force_git_root=None, return_coder=False):
+    report_uncaught_exceptions()
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    if git is None:
+        git_root = None
+    elif force_git_root:
+        git_root = force_git_root
+    else:
+        git_root = get_git_root()
+
+    conf_fname = Path(".patch.conf.yml")
+
+    default_config_files = [Path.home() / conf_fname]  # homedir
+
+    if git_root:
+        git_conf = Path(git_root) / conf_fname  # git root
+        if git_conf not in default_config_files:
+            default_config_files.append(git_conf)
+    try:
+        cwd_conf = conf_fname.resolve()  # CWD
+        if cwd_conf not in default_config_files:
+            default_config_files.append(cwd_conf)
+    except OSError:
+        pass
+    default_config_files = list(map(str, default_config_files))
+
+    parser = get_parser(default_config_files, git_root)
+    try:
+        args, unknown = parser.parse_known_args(argv)
+    except AttributeError as e:
+        if all(word in str(e) for word in ["bool", "object", "has", "no", "attribute", "strip"]):
+            if check_config_files_for_yes(default_config_files):
+                return 1
+        raise e
+
+    if args.verbose:
+        print("Config files search order, if no --config:")
+        for file in default_config_files:
+            exists = "(exists)" if Path(file).exists() else ""
+            print(f"  - {file} {exists}")
+
+    parser = get_parser(default_config_files, git_root)
+
+    args, unknown = parser.parse_known_args(argv)
+
+    # Read from argv and the ambient environment only. Both belong to the user,
+    # and neither has been touched by the repository's .env yet -- it is loaded
+    # just below. PATCH_TRUST_REPO_CONFIG is itself on the blocked list, so a
+    # repository cannot grant itself trust from its own .env or config.
+    trust_repo_config = "--trust-repo-config" in (argv or []) or env_flag_is_set(
+        "PATCH_TRUST_REPO_CONFIG"
+    )
+
+    # Load the .env file specified in the arguments
+    loaded_dotenvs = load_dotenv_files(
+        git_root, args.env_file, args.encoding, trust_repo=trust_repo_config
+    )
+
+    # Parse again to include any arguments that might have been defined in .env
+    args = parser.parse_args(argv)
+
+    if not trust_repo_config:
+        sanitize_repo_config(args, parser, default_config_files, argv)
+
+    if args.shell_completions:
+        # Ensure parser.prog is set for shtab, though it should be by default
+        parser.prog = "patch"
+        print(shtab.complete(parser, shell=args.shell_completions))
+        sys.exit(0)
+
+    if git is None:
+        args.git = False
+
+    if args.analytics_disable:
+        print("Analytics have been permanently disabled.")
+
+    if not args.verify_ssl:
+        import httpx
+
+        os.environ["SSL_VERIFY"] = ""
+        litellm._load_litellm()
+        litellm._lazy_module.client_session = httpx.Client(verify=False)
+        litellm._lazy_module.aclient_session = httpx.AsyncClient(verify=False)
+        # Set verify_ssl on the model_info_manager
+        models.model_info_manager.set_verify_ssl(False)
+
+    if args.timeout:
+        models.request_timeout = args.timeout
+
+    if args.dark_mode:
+        args.user_input_color = "#32FF32"
+        args.tool_error_color = "#FF3333"
+        args.tool_warning_color = "#FFFF00"
+        args.assistant_output_color = "#00FFFF"
+        args.code_theme = "monokai"
+
+    if args.light_mode:
+        args.user_input_color = "green"
+        args.tool_error_color = "red"
+        args.tool_warning_color = "#FFA500"
+        args.assistant_output_color = "blue"
+        args.code_theme = "default"
+
+    if return_coder and args.yes_always is None:
+        args.yes_always = True
+
+    editing_mode = EditingMode.VI if args.vim else EditingMode.EMACS
+
+    def get_io(pretty):
+        return InputOutput(
+            pretty,
+            args.yes_always,
+            args.input_history_file,
+            args.chat_history_file,
+            input=input,
+            output=output,
+            user_input_color=args.user_input_color,
+            tool_output_color=args.tool_output_color,
+            tool_warning_color=args.tool_warning_color,
+            tool_error_color=args.tool_error_color,
+            completion_menu_color=args.completion_menu_color,
+            completion_menu_bg_color=args.completion_menu_bg_color,
+            completion_menu_current_color=args.completion_menu_current_color,
+            completion_menu_current_bg_color=args.completion_menu_current_bg_color,
+            assistant_output_color=args.assistant_output_color,
+            code_theme=args.code_theme,
+            dry_run=args.dry_run,
+            encoding=args.encoding,
+            line_endings=args.line_endings,
+            llm_history_file=args.llm_history_file,
+            editingmode=editing_mode,
+            fancy_input=args.fancy_input,
+            multiline_mode=args.multiline,
+            notifications=args.notifications,
+            notifications_command=args.notifications_command,
+        )
+
+    io = get_io(args.pretty)
+    try:
+        io.rule()
+    except UnicodeEncodeError as err:
+        if not io.pretty:
+            raise err
+        io = get_io(False)
+        io.tool_warning("Terminal does not support pretty output (UnicodeDecodeError)")
+
+    # Process any environment variables set via --set-env
+    if args.set_env:
+        for env_setting in args.set_env:
+            try:
+                name, value = env_setting.split("=", 1)
+                os.environ[name.strip()] = value.strip()
+            except ValueError:
+                io.tool_error(f"Invalid --set-env format: {env_setting}")
+                io.tool_output("Format should be: ENV_VAR_NAME=value")
+                return 1
+
+    # Process any API keys set via --api-key
+    if args.api_key:
+        for api_setting in args.api_key:
+            try:
+                provider, key = api_setting.split("=", 1)
+                env_var = f"{provider.strip().upper()}_API_KEY"
+                os.environ[env_var] = key.strip()
+            except ValueError:
+                io.tool_error(f"Invalid --api-key format: {api_setting}")
+                io.tool_output("Format should be: provider=key")
+                return 1
+
+    if args.anthropic_api_key:
+        os.environ["ANTHROPIC_API_KEY"] = args.anthropic_api_key
+
+    if args.openai_api_key:
+        os.environ["OPENAI_API_KEY"] = args.openai_api_key
+
+    # Handle deprecated model shortcut args
+    handle_deprecated_model_args(args, io)
+    if args.openai_api_base:
+        os.environ["OPENAI_API_BASE"] = args.openai_api_base
+    if args.openai_api_version:
+        io.tool_warning(
+            "--openai-api-version is deprecated, use --set-env OPENAI_API_VERSION=<value>"
+        )
+        os.environ["OPENAI_API_VERSION"] = args.openai_api_version
+    if args.openai_api_type:
+        io.tool_warning("--openai-api-type is deprecated, use --set-env OPENAI_API_TYPE=<value>")
+        os.environ["OPENAI_API_TYPE"] = args.openai_api_type
+    if args.openai_organization_id:
+        io.tool_warning(
+            "--openai-organization-id is deprecated, use --set-env OPENAI_ORGANIZATION=<value>"
+        )
+        os.environ["OPENAI_ORGANIZATION"] = args.openai_organization_id
+
+    analytics = Analytics(
+        logfile=args.analytics_log,
+        permanently_disable=args.analytics_disable,
+        posthog_host=args.analytics_posthog_host,
+        posthog_project_api_key=args.analytics_posthog_project_api_key,
+    )
+    if args.analytics is not False:
+        if analytics.need_to_ask(args.analytics):
+            io.tool_output(
+                "Patch respects your privacy and never collects your code, chat messages, keys or"
+                " personal info."
+            )
+            io.tool_output(f"For more info: {urls.analytics}")
+            disable = not io.confirm_ask(
+                "Allow collection of anonymous analytics to help improve Patch?"
+            )
+
+            analytics.asked_opt_in = True
+            if disable:
+                analytics.disable(permanently=True)
+                io.tool_output("Analytics have been permanently disabled.")
+
+            analytics.save_data()
+            io.tool_output()
+
+        # This is a no-op if the user has opted out
+        analytics.enable()
+
+    analytics.event("launched")
+
+    if args.gui and not return_coder:
+        if not check_streamlit_install(io):
+            analytics.event("exit", reason="Streamlit not installed")
+            return
+        analytics.event("gui session")
+        launch_gui(argv)
+        analytics.event("exit", reason="GUI session ended")
+        return
+
+    if args.verbose:
+        for fname in loaded_dotenvs:
+            io.tool_output(f"Loaded {fname}")
+
+    all_files = args.files + (args.file or [])
+    fnames = [str(Path(fn).resolve()) for fn in all_files]
+    read_only_fnames = []
+    for fn in args.read or []:
+        path = Path(fn).expanduser().resolve()
+        if path.is_dir():
+            read_only_fnames.extend(str(f) for f in path.rglob("*") if f.is_file())
+        else:
+            read_only_fnames.append(str(path))
+
+    if len(all_files) > 1:
+        good = True
+        for fname in all_files:
+            if Path(fname).is_dir():
+                io.tool_error(f"{fname} is a directory, not provided alone.")
+                good = False
+        if not good:
+            io.tool_output(
+                "Provide either a single directory of a git repo, or a list of one or more files."
+            )
+            analytics.event("exit", reason="Invalid directory input")
+            return 1
+
+    git_dname = None
+    if len(all_files) == 1:
+        if Path(all_files[0]).is_dir():
+            if args.git:
+                git_dname = str(Path(all_files[0]).resolve())
+                fnames = []
+            else:
+                io.tool_error(f"{all_files[0]} is a directory, but --no-git selected.")
+                analytics.event("exit", reason="Directory with --no-git")
+                return 1
+
+    # We can't know the git repo for sure until after parsing the args.
+    # If we guessed wrong, reparse because that changes things like
+    # the location of the config.yml and history files.
+    if args.git and not force_git_root and git is not None:
+        right_repo_root = guessed_wrong_repo(io, git_root, fnames, git_dname)
+        if right_repo_root:
+            analytics.event("exit", reason="Recursing with correct repo")
+            return main(argv, input, output, right_repo_root, return_coder=return_coder)
+
+    if args.just_check_update:
+        update_available = check_version(io, just_check=True, verbose=args.verbose)
+        analytics.event("exit", reason="Just checking update")
+        return 0 if not update_available else 1
+
+    if args.install_main_branch:
+        success = install_from_main_branch(io)
+        analytics.event("exit", reason="Installed main branch")
+        return 0 if success else 1
+
+    if args.upgrade:
+        success = install_upgrade(io)
+        analytics.event("exit", reason="Upgrade completed")
+        return 0 if success else 1
+
+    if args.check_update:
+        check_version(io, verbose=args.verbose)
+
+    if args.git:
+        git_root = setup_git(git_root, io)
+        if args.gitignore:
+            check_gitignore(git_root, io)
+
+    if args.verbose:
+        show = format_settings(parser, args)
+        io.tool_output(show)
+
+    cmd_line = " ".join(sys.argv)
+    cmd_line = scrub_sensitive_info(args, cmd_line)
+    io.tool_output(cmd_line, log_only=True)
+
+    is_first_run = is_first_run_of_new_version(io, verbose=args.verbose)
+    check_and_load_imports(io, is_first_run, verbose=args.verbose)
+
+    if register_models(git_root, args.model_settings_file, io, verbose=args.verbose):
+        return 1
+    if register_litellm_models(git_root, args.model_metadata_file, io, verbose=args.verbose):
+        return 1
+
+    if args.list_models:
+        models.print_matching_models(io, args.list_models)
+        analytics.event("exit", reason="Listed models")
+        return 0
+
+    # Process any command line aliases
+    if args.alias:
+        for alias_def in args.alias:
+            # Split on first colon only
+            parts = alias_def.split(":", 1)
+            if len(parts) != 2:
+                io.tool_error(f"Invalid alias format: {alias_def}")
+                io.tool_output("Format should be: alias:model-name")
+                analytics.event("exit", reason="Invalid alias format error")
+                return 1
+            alias, model = parts
+            models.MODEL_ALIASES[alias.strip()] = model.strip()
+
+    selected_model_name = select_default_model(args, io, analytics)
+    if not selected_model_name:
+        # Error message and analytics event are handled within select_default_model
+        # It might have already offered OAuth if no model/keys were found.
+        # If it failed here, we exit.
+        return 1
+    args.model = selected_model_name  # Update args with the selected model
+
+    # Check if an OpenRouter model was selected/specified but the key is missing
+    if args.model.startswith("openrouter/") and not os.environ.get("OPENROUTER_API_KEY"):
+        io.tool_warning(
+            f"The specified model '{args.model}' requires an OpenRouter API key, which was not"
+            " found."
+        )
+        # Attempt OAuth flow because the specific model needs it
+        if offer_openrouter_oauth(io, analytics):
+            # OAuth succeeded, the key should now be in os.environ.
+            # Check if the key is now present after the flow.
+            if os.environ.get("OPENROUTER_API_KEY"):
+                io.tool_output(
+                    "OpenRouter successfully connected."
+                )  # Inform user connection worked
+            else:
+                # This case should ideally not happen if offer_openrouter_oauth succeeded
+                # but check defensively.
+                io.tool_error(
+                    "OpenRouter authentication seemed successful, but the key is still missing."
+                )
+                analytics.event(
+                    "exit",
+                    reason="OpenRouter key missing after successful OAuth for specified model",
+                )
+                return 1
+        else:
+            # OAuth failed or was declined by the user
+            io.tool_error(
+                f"Unable to proceed without an OpenRouter API key for model '{args.model}'."
+            )
+            io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
+            analytics.event(
+                "exit",
+                reason="OpenRouter key missing for specified model and OAuth failed/declined",
+            )
+            return 1
+
+    main_model = models.Model(
+        args.model,
+        weak_model=args.weak_model,
+        editor_model=args.editor_model,
+        editor_edit_format=args.editor_edit_format,
+        verbose=args.verbose,
+    )
+
+    # Check if deprecated remove_reasoning is set
+    if main_model.remove_reasoning is not None:
+        io.tool_warning(
+            "Model setting 'remove_reasoning' is deprecated, please use 'reasoning_tag' instead."
+        )
+
+    # Set reasoning effort and thinking tokens if specified
+    if args.reasoning_effort is not None:
+        # Apply if check is disabled or model explicitly supports it
+        if not args.check_model_accepts_settings or (
+            main_model.accepts_settings and "reasoning_effort" in main_model.accepts_settings
+        ):
+            main_model.set_reasoning_effort(args.reasoning_effort)
+
+    if args.thinking_tokens is not None:
+        # Apply if check is disabled or model explicitly supports it
+        if not args.check_model_accepts_settings or (
+            main_model.accepts_settings and "thinking_tokens" in main_model.accepts_settings
+        ):
+            main_model.set_thinking_tokens(args.thinking_tokens)
+
+    # Show warnings about unsupported settings that are being ignored
+    if args.check_model_accepts_settings:
+        settings_to_check = [
+            {"arg": args.reasoning_effort, "name": "reasoning_effort"},
+            {"arg": args.thinking_tokens, "name": "thinking_tokens"},
+        ]
+
+        for setting in settings_to_check:
+            if setting["arg"] is not None and (
+                not main_model.accepts_settings
+                or setting["name"] not in main_model.accepts_settings
+            ):
+                io.tool_warning(
+                    f"Warning: {main_model.name} does not support '{setting['name']}', ignoring."
+                )
+                io.tool_output(
+                    f"Use --no-check-model-accepts-settings to force the '{setting['name']}'"
+                    " setting."
+                )
+
+    if args.copy_paste and args.edit_format is None:
+        if main_model.edit_format in ("diff", "whole", "diff-fenced"):
+            main_model.edit_format = "editor-" + main_model.edit_format
+
+    if args.verbose:
+        io.tool_output("Model metadata:")
+        io.tool_output(json.dumps(main_model.info, indent=4))
+
+        io.tool_output("Model settings:")
+        for attr in sorted(fields(ModelSettings), key=lambda x: x.name):
+            val = getattr(main_model, attr.name)
+            val = json.dumps(val, indent=4)
+            io.tool_output(f"{attr.name}: {val}")
+
+    lint_cmds = parse_lint_cmds(args.lint_cmd, io)
+    if lint_cmds is None:
+        analytics.event("exit", reason="Invalid lint command format")
+        return 1
+
+    if args.show_model_warnings:
+        problem = models.sanity_check_models(io, main_model)
+        if problem:
+            analytics.event("model warning", main_model=main_model)
+            io.tool_output("You can skip this check with --no-show-model-warnings")
+
+            try:
+                io.offer_url(urls.model_warnings, "Open documentation url for more info?")
+                io.tool_output()
+            except KeyboardInterrupt:
+                analytics.event("exit", reason="Keyboard interrupt during model warnings")
+                return 1
+
+    repo = None
+    if args.git:
+        try:
+            repo = GitRepo(
+                io,
+                fnames,
+                git_dname,
+                args.patchignore,
+                models=main_model.commit_message_models(),
+                attribute_author=args.attribute_author,
+                attribute_committer=args.attribute_committer,
+                attribute_commit_message_author=args.attribute_commit_message_author,
+                attribute_commit_message_committer=args.attribute_commit_message_committer,
+                commit_prompt=args.commit_prompt,
+                subtree_only=args.subtree_only,
+                git_commit_verify=args.git_commit_verify,
+                attribute_co_authored_by=args.attribute_co_authored_by,  # Pass the arg
+            )
+        except FileNotFoundError:
+            pass
+
+    if not args.skip_sanity_check_repo:
+        if not sanity_check_repo(repo, io):
+            analytics.event("exit", reason="Repository sanity check failed")
+            return 1
+
+    if repo and not args.skip_sanity_check_repo:
+        num_files = len(repo.get_tracked_files())
+        analytics.event("repo", num_files=num_files)
+    else:
+        analytics.event("no-repo")
+
+    commands = Commands(
+        io,
+        None,
+        voice_language=args.voice_language,
+        voice_input_device=args.voice_input_device,
+        voice_format=args.voice_format,
+        verify_ssl=args.verify_ssl,
+        args=args,
+        parser=parser,
+        verbose=args.verbose,
+        editor=args.editor,
+        original_read_only_fnames=read_only_fnames,
+    )
+
+    summarizer = ChatSummary(
+        [main_model.weak_model, main_model],
+        args.max_chat_history_tokens or main_model.max_chat_history_tokens,
+    )
+
+    if args.cache_prompts and args.map_refresh == "auto":
+        args.map_refresh = "files"
+
+    if not main_model.streaming:
+        if args.stream:
+            io.tool_warning(
+                f"Warning: Streaming is not supported by {main_model.name}. Disabling streaming."
+            )
+        args.stream = False
+
+    if args.map_tokens is None:
+        map_tokens = main_model.get_repo_map_tokens()
+    else:
+        map_tokens = args.map_tokens
+
+    # Track auto-commits configuration
+    analytics.event("auto_commits", enabled=bool(args.auto_commits))
+
+    try:
+        coder = Coder.create(
+            main_model=main_model,
+            edit_format=args.edit_format,
+            io=io,
+            repo=repo,
+            fnames=fnames,
+            read_only_fnames=read_only_fnames,
+            show_diffs=args.show_diffs,
+            auto_commits=args.auto_commits,
+            dirty_commits=args.dirty_commits,
+            dry_run=args.dry_run,
+            map_tokens=map_tokens,
+            verbose=args.verbose,
+            stream=args.stream,
+            use_git=args.git,
+            restore_chat_history=args.restore_chat_history,
+            auto_lint=args.auto_lint,
+            auto_test=args.auto_test,
+            lint_cmds=lint_cmds,
+            test_cmd=args.test_cmd,
+            commands=commands,
+            summarizer=summarizer,
+            analytics=analytics,
+            map_refresh=args.map_refresh,
+            cache_prompts=args.cache_prompts,
+            map_mul_no_files=args.map_multiplier_no_files,
+            num_cache_warming_pings=args.cache_keepalive_pings,
+            suggest_shell_commands=args.suggest_shell_commands,
+            chat_language=args.chat_language,
+            commit_language=args.commit_language,
+            detect_urls=args.detect_urls,
+            auto_copy_context=args.copy_paste,
+            auto_accept_architect=args.auto_accept_architect,
+            add_gitignore_files=args.add_gitignore_files,
+        )
+    except UnknownEditFormat as err:
+        io.tool_error(str(err))
+        io.offer_url(urls.edit_formats, "Open documentation about edit formats?")
+        analytics.event("exit", reason="Unknown edit format")
+        return 1
+    except ValueError as err:
+        io.tool_error(str(err))
+        analytics.event("exit", reason="ValueError during coder creation")
+        return 1
+
+    if return_coder:
+        analytics.event("exit", reason="Returning coder object")
+        return coder
+
+    ignores = []
+    if git_root:
+        ignores.append(str(Path(git_root) / ".gitignore"))
+    if args.patchignore:
+        ignores.append(args.patchignore)
+
+    if args.watch_files:
+        file_watcher = FileWatcher(
+            coder,
+            gitignores=ignores,
+            verbose=args.verbose,
+            analytics=analytics,
+            root=str(Path.cwd()) if args.subtree_only else None,
+        )
+        coder.file_watcher = file_watcher
+
+    if args.copy_paste:
+        analytics.event("copy-paste mode")
+        ClipboardWatcher(coder.io, verbose=args.verbose)
+
+    coder.show_announcements()
+
+    if args.show_prompts:
+        coder.cur_messages += [
+            dict(role="user", content="Hello!"),
+        ]
+        messages = coder.format_messages().all_messages()
+        utils.show_messages(messages)
+        analytics.event("exit", reason="Showed prompts")
+        return
+
+    if args.lint:
+        coder.commands.cmd_lint(fnames=fnames)
+
+    if args.test:
+        if not args.test_cmd:
+            io.tool_error("No --test-cmd provided.")
+            analytics.event("exit", reason="No test command provided")
+            return 1
+        coder.commands.cmd_test(args.test_cmd)
+        if io.placeholder:
+            coder.run(io.placeholder)
+
+    if args.commit:
+        if args.dry_run:
+            io.tool_output("Dry run enabled, skipping commit.")
+        else:
+            coder.commands.cmd_commit()
+
+    if args.lint or args.test or args.commit:
+        analytics.event("exit", reason="Completed lint/test/commit")
+        return
+
+    if args.show_repo_map:
+        repo_map = coder.get_repo_map()
+        if repo_map:
+            io.tool_output(repo_map)
+        analytics.event("exit", reason="Showed repo map")
+        return
+
+    if args.apply:
+        content = io.read_text(args.apply)
+        if content is None:
+            analytics.event("exit", reason="Failed to read apply content")
+            return
+        coder.partial_response_content = content
+        # For testing #2879
+        # from patch.coders.base_coder import all_fences
+        # coder.fence = all_fences[1]
+        coder.apply_updates()
+        analytics.event("exit", reason="Applied updates")
+        return
+
+    if args.apply_clipboard_edits:
+        args.edit_format = main_model.editor_edit_format
+        args.message = "/paste"
+
+    if args.show_release_notes is True:
+        io.tool_output(f"Opening release notes: {urls.release_notes}")
+        io.tool_output()
+        webbrowser.open(urls.release_notes)
+    elif args.show_release_notes is None and is_first_run:
+        io.tool_output()
+        io.offer_url(
+            urls.release_notes,
+            "Would you like to see what's new in this version?",
+            allow_never=False,
+        )
+
+    if git_root and Path.cwd().resolve() != Path(git_root).resolve():
+        io.tool_warning(
+            "Note: in-chat filenames are always relative to the git working dir, not the current"
+            " working dir."
+        )
+
+        io.tool_output(f"Cur working dir: {Path.cwd()}")
+        io.tool_output(f"Git working dir: {git_root}")
+
+    if args.stream and args.cache_prompts:
+        io.tool_warning("Cost estimates may be inaccurate when using streaming and caching.")
+
+    if args.load:
+        commands.cmd_load(args.load)
+
+    if args.message:
+        io.add_to_input_history(args.message)
+        io.tool_output()
+        try:
+            coder.run(with_message=args.message)
+        except SwitchCoder:
+            pass
+        analytics.event("exit", reason="Completed --message")
+        return
+
+    if args.message_file:
+        try:
+            message_from_file = io.read_text(args.message_file)
+            io.tool_output()
+            coder.run(with_message=message_from_file)
+        except FileNotFoundError:
+            io.tool_error(f"Message file not found: {args.message_file}")
+            analytics.event("exit", reason="Message file not found")
+            return 1
+        except IOError as e:
+            io.tool_error(f"Error reading message file: {e}")
+            analytics.event("exit", reason="Message file IO error")
+            return 1
+
+        analytics.event("exit", reason="Completed --message-file")
+        return
+
+    if args.exit:
+        analytics.event("exit", reason="Exit flag set")
+        return
+
+    analytics.event("cli session", main_model=main_model, edit_format=main_model.edit_format)
+
+    while True:
+        try:
+            coder.ok_to_warm_cache = bool(args.cache_keepalive_pings)
+            coder.run()
+            analytics.event("exit", reason="Completed main CLI coder.run")
+            return
+        except SwitchCoder as switch:
+            coder.ok_to_warm_cache = False
+
+            # Set the placeholder if provided
+            if hasattr(switch, "placeholder") and switch.placeholder is not None:
+                io.placeholder = switch.placeholder
+
+            kwargs = dict(io=io, from_coder=coder)
+            kwargs.update(switch.kwargs)
+            if "show_announcements" in kwargs:
+                del kwargs["show_announcements"]
+
+            coder = Coder.create(**kwargs)
+
+            if switch.kwargs.get("show_announcements") is not False:
+                coder.show_announcements()
+
+
+def is_first_run_of_new_version(io, verbose=False):
+    """Check if this is the first run of a new version/executable combination"""
+    installs_file = Path.home() / ".patch" / "installs.json"
+    key = (__version__, sys.executable)
+
+    # Never show notes for .dev versions
+    if ".dev" in __version__:
+        return False
+
+    if verbose:
+        io.tool_output(
+            f"Checking imports for version {__version__} and executable {sys.executable}"
+        )
+        io.tool_output(f"Installs file: {installs_file}")
+
+    try:
+        if installs_file.exists():
+            with open(installs_file, "r") as f:
+                installs = json.load(f)
+            if verbose:
+                io.tool_output("Installs file exists and loaded")
+        else:
+            installs = {}
+            if verbose:
+                io.tool_output("Installs file does not exist, creating new dictionary")
+
+        is_first_run = str(key) not in installs
+
+        if is_first_run:
+            installs[str(key)] = True
+            installs_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(installs_file, "w") as f:
+                json.dump(installs, f, indent=4)
+
+        return is_first_run
+
+    except Exception as e:
+        io.tool_warning(f"Error checking version: {e}")
+        if verbose:
+            io.tool_output(f"Full exception details: {traceback.format_exc()}")
+        return True  # Safer to assume it's a first run if we hit an error
+
+
+def check_and_load_imports(io, is_first_run, verbose=False):
+    try:
+        if is_first_run:
+            if verbose:
+                io.tool_output(
+                    "First run for this version and executable, loading imports synchronously"
+                )
+            try:
+                load_slow_imports(swallow=False)
+            except Exception as err:
+                io.tool_error(str(err))
+                io.tool_output("Error loading required imports. Did you install Patch properly?")
+                io.offer_url(urls.install_properly, "Open documentation url for more info?")
+                sys.exit(1)
+
+            if verbose:
+                io.tool_output("Imports loaded and installs file updated")
+        else:
+            if verbose:
+                io.tool_output("Not first run, loading imports in background thread")
+            thread = threading.Thread(target=load_slow_imports)
+            thread.daemon = True
+            thread.start()
+
+    except Exception as e:
+        io.tool_warning(f"Error in loading imports: {e}")
+        if verbose:
+            io.tool_output(f"Full exception details: {traceback.format_exc()}")
+
+
+def load_slow_imports(swallow=True):
+    # These imports are deferred in various ways to
+    # improve startup time.
+    # This func is called either synchronously or in a thread
+    # depending on whether it's been run before for this version and executable.
+
+    try:
+        import httpx  # noqa: F401
+        import litellm  # noqa: F401
+        import networkx  # noqa: F401
+        import numpy  # noqa: F401
+    except Exception as e:
+        if not swallow:
+            raise e
+
+
+if __name__ == "__main__":
+    status = main()
+    sys.exit(status)