patch-chat 0.1.0__py3-none-any.whl

patch/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))

patch/urls.py

@@ -0,0 +1,17 @@
+website = "https://getpatch.dev/"
+documentation = "https://github.com/PierrunoYT/patch#readme"
+add_all_files = documentation
+edit_errors = "https://github.com/PierrunoYT/patch/issues/new"
+git = documentation
+enable_playwright = documentation
+model_warnings = documentation
+token_limits = documentation
+llms = documentation
+large_repos = documentation
+github_issues = "https://github.com/PierrunoYT/patch/issues/new"
+git_index_version = documentation
+install_properly = documentation
+analytics = "https://github.com/PierrunoYT/patch#security-boundaries"
+release_notes = "https://github.com/PierrunoYT/patch/blob/main/CHANGELOG.md"
+edit_formats = documentation
+models_and_keys = documentation

patch/utils.py

@@ -0,0 +1,365 @@
+import os
+import platform
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import oslex
+
+from patch.dump import dump  # noqa: F401
+from patch.waiting import Spinner
+
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp", ".pdf"}
+
+
+class IgnorantTemporaryDirectory:
+    def __init__(self):
+        if sys.version_info >= (3, 10):
+            self.temp_dir = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+        else:
+            self.temp_dir = tempfile.TemporaryDirectory()
+
+    def __enter__(self):
+        return self.temp_dir.__enter__()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.cleanup()
+
+    def cleanup(self):
+        try:
+            self.temp_dir.cleanup()
+        except (OSError, PermissionError, RecursionError):
+            pass  # Ignore errors (Windows and potential recursion)
+
+    def __getattr__(self, item):
+        return getattr(self.temp_dir, item)
+
+
+class ChdirTemporaryDirectory(IgnorantTemporaryDirectory):
+    def __init__(self):
+        try:
+            self.cwd = os.getcwd()
+        except FileNotFoundError:
+            self.cwd = None
+
+        super().__init__()
+
+    def __enter__(self):
+        res = super().__enter__()
+        os.chdir(Path(self.temp_dir.name).resolve())
+        return res
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.cwd:
+            try:
+                os.chdir(self.cwd)
+            except FileNotFoundError:
+                pass
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+
+class GitTemporaryDirectory(ChdirTemporaryDirectory):
+    def __enter__(self):
+        dname = super().__enter__()
+        self.repo = make_repo(dname)
+        return dname
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        del self.repo
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+
+def make_repo(path=None):
+    import git
+
+    if not path:
+        path = "."
+    repo = git.Repo.init(path)
+    repo.config_writer().set_value("user", "name", "Test User").release()
+    repo.config_writer().set_value("user", "email", "testuser@example.com").release()
+
+    return repo
+
+
+def is_image_file(file_name):
+    """
+    Check if the given file name has an image file extension.
+
+    :param file_name: The name of the file to check.
+    :return: True if the file is an image, False otherwise.
+    """
+    return Path(file_name).suffix.lower() in IMAGE_EXTENSIONS
+
+
+def safe_abs_path(res):
+    "Gives an abs path, which safely returns a full (not 8.3) windows path"
+    try:
+        res = Path(res).resolve()
+    except (RuntimeError, OSError):
+        res = Path(res).absolute()
+    return str(res)
+
+
+def path_is_within(path, root):
+    """Is `path` inside `root` after fully resolving both?
+
+    Resolving both sides is what makes this a real containment check rather
+    than a lexical one: it collapses `..` segments and follows symlinks, so a
+    traversal path, an absolute path, and a symlink pointing outside the tree
+    are all rejected. A string prefix test is not sufficient -- it accepts
+    `/work/repo-secret` for the root `/work/repo`.
+    """
+    try:
+        root = Path(root).resolve()
+        path = Path(path).resolve()
+    except (RuntimeError, OSError):
+        return False
+
+    return path == root or root in path.parents
+
+
+def format_content(role, content):
+    formatted_lines = []
+    for line in content.splitlines():
+        formatted_lines.append(f"{role} {line}")
+    return "\n".join(formatted_lines)
+
+
+def format_messages(messages, title=None):
+    output = []
+    if title:
+        output.append(f"{title.upper()} {'*' * 50}")
+
+    for msg in messages:
+        output.append("-------")
+        role = msg["role"].upper()
+        content = msg.get("content")
+        if isinstance(content, list):  # Handle list content (e.g., image messages)
+            for item in content:
+                if isinstance(item, dict):
+                    for key, value in item.items():
+                        if isinstance(value, dict) and "url" in value:
+                            output.append(f"{role} {key.capitalize()} URL: {value['url']}")
+                        else:
+                            output.append(f"{role} {key}: {value}")
+                else:
+                    output.append(f"{role} {item}")
+        elif isinstance(content, str):  # Handle string content
+            output.append(format_content(role, content))
+        function_call = msg.get("function_call")
+        if function_call:
+            output.append(f"{role} Function Call: {function_call}")
+
+    return "\n".join(output)
+
+
+def show_messages(messages, title=None, functions=None):
+    formatted_output = format_messages(messages, title)
+    print(formatted_output)
+
+    if functions:
+        dump(functions)
+
+
+def split_chat_history_markdown(text, include_tool=False):
+    messages = []
+    user = []
+    assistant = []
+    tool = []
+    lines = text.splitlines(keepends=True)
+
+    def append_msg(role, lines):
+        lines = "".join(lines)
+        if lines.strip():
+            messages.append(dict(role=role, content=lines))
+
+    for line in lines:
+        if line.startswith("# "):
+            continue
+        if line.startswith("> "):
+            append_msg("assistant", assistant)
+            assistant = []
+            append_msg("user", user)
+            user = []
+            tool.append(line[2:])
+            continue
+        # if line.startswith("#### /"):
+        #    continue
+
+        if line.startswith("#### "):
+            append_msg("assistant", assistant)
+            assistant = []
+            append_msg("tool", tool)
+            tool = []
+
+            content = line[5:]
+            user.append(content)
+            continue
+
+        append_msg("user", user)
+        user = []
+        append_msg("tool", tool)
+        tool = []
+
+        assistant.append(line)
+
+    append_msg("assistant", assistant)
+    append_msg("user", user)
+
+    if not include_tool:
+        messages = [m for m in messages if m["role"] != "tool"]
+
+    return messages
+
+
+def get_pip_install(args):
+    cmd = [
+        sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        "--upgrade-strategy",
+        "only-if-needed",
+    ]
+    cmd += args
+    return cmd
+
+
+def run_install(cmd):
+    print()
+    print("Installing:", printable_shell_command(cmd))
+
+    # First ensure pip is available
+    ensurepip_cmd = [sys.executable, "-m", "ensurepip", "--upgrade"]
+    try:
+        subprocess.run(ensurepip_cmd, capture_output=True, check=False)
+    except Exception:
+        pass  # Continue even if ensurepip fails
+
+    try:
+        output = []
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            encoding=sys.stdout.encoding,
+            errors="replace",
+        )
+        spinner = Spinner("Installing...")
+
+        while True:
+            char = process.stdout.read(1)
+            if not char:
+                break
+
+            output.append(char)
+            spinner.step()
+
+        spinner.end()
+        return_code = process.wait()
+        output = "".join(output)
+
+        if return_code == 0:
+            print("Installation complete.")
+            print()
+            return True, output
+
+    except subprocess.CalledProcessError as e:
+        print(f"\nError running pip install: {e}")
+
+    print("\nInstallation failed.\n")
+
+    return False, output
+
+
+def find_common_root(abs_fnames):
+    try:
+        if len(abs_fnames) == 1:
+            return safe_abs_path(os.path.dirname(list(abs_fnames)[0]))
+        elif abs_fnames:
+            return safe_abs_path(os.path.commonpath(list(abs_fnames)))
+    except OSError:
+        pass
+
+    try:
+        return safe_abs_path(os.getcwd())
+    except FileNotFoundError:
+        # Fallback if cwd is deleted
+        return "."
+
+
+def format_tokens(count):
+    if count < 1000:
+        return f"{count}"
+    elif count < 10000:
+        return f"{count / 1000:.1f}k"
+    else:
+        return f"{round(count / 1000)}k"
+
+
+def touch_file(fname):
+    fname = Path(fname)
+    try:
+        fname.parent.mkdir(parents=True, exist_ok=True)
+        fname.touch()
+        return True
+    except OSError:
+        return False
+
+
+def check_pip_install_extra(io, module, prompt, pip_install_cmd, self_update=False):
+    if module:
+        try:
+            __import__(module)
+            return True
+        except (ImportError, ModuleNotFoundError, RuntimeError):
+            pass
+
+    cmd = get_pip_install(pip_install_cmd)
+
+    if prompt:
+        io.tool_warning(prompt)
+
+    if self_update and platform.system() == "Windows":
+        io.tool_output("Run this command to update:")
+        print()
+        print(printable_shell_command(cmd))  # plain print so it doesn't line-wrap
+        return
+
+    if not io.confirm_ask("Run pip install?", default="y", subject=printable_shell_command(cmd)):
+        return
+
+    success, output = run_install(cmd)
+    if success:
+        if not module:
+            return True
+        try:
+            __import__(module)
+            return True
+        except (ImportError, ModuleNotFoundError, RuntimeError) as err:
+            io.tool_error(str(err))
+            pass
+
+    io.tool_error(output)
+
+    print()
+    print("Install failed, try running this command manually:")
+    print(printable_shell_command(cmd))
+
+
+def printable_shell_command(cmd_list):
+    """
+    Convert a list of command arguments to a properly shell-escaped string.
+
+    Args:
+        cmd_list (list): List of command arguments.
+
+    Returns:
+        str: Shell-escaped command string.
+    """
+    return oslex.join(cmd_list)

patch/versioncheck.py

@@ -0,0 +1,113 @@
+import os
+import sys
+import time
+from pathlib import Path
+
+import packaging.version
+
+import patch
+from patch import utils
+from patch.dump import dump  # noqa: F401
+
+VERSION_CHECK_FNAME = Path.home() / ".patch" / "caches" / "versioncheck"
+
+
+def install_from_main_branch(io):
+    """
+    Install the latest version of Patch from the main branch of the GitHub repository.
+    """
+
+    return utils.check_pip_install_extra(
+        io,
+        None,
+        "Install the development version of Patch from the main branch?",
+        ["git+https://github.com/PierrunoYT/patch.git"],
+        self_update=True,
+    )
+
+
+def install_upgrade(io, latest_version=None):
+    """
+    Install the latest version of Patch from PyPI.
+    """
+
+    if latest_version:
+        new_ver_text = f"Newer Patch version v{latest_version} is available."
+    else:
+        new_ver_text = "Install latest version of Patch?"
+
+    docker_image = os.environ.get("PATCH_DOCKER_IMAGE")
+    if docker_image:
+        text = f"""
+{new_ver_text} To upgrade, run:
+
+    docker pull {docker_image}
+"""
+        io.tool_warning(text)
+        return True
+
+    success = utils.check_pip_install_extra(
+        io,
+        None,
+        new_ver_text,
+        ["patch-chat"],
+        self_update=True,
+    )
+
+    if success:
+        io.tool_output("Re-run patch to use new version.")
+        sys.exit()
+
+    return
+
+
+def check_version(io, just_check=False, verbose=False):
+    if not just_check and VERSION_CHECK_FNAME.exists():
+        day = 60 * 60 * 24
+        since = time.time() - os.path.getmtime(VERSION_CHECK_FNAME)
+        if 0 < since < day:
+            if verbose:
+                hours = since / 60 / 60
+                io.tool_output(f"Too soon to check version: {hours:.1f} hours")
+            return
+
+    # To keep startup fast, avoid importing this unless needed
+    import requests
+
+    try:
+        response = requests.get("https://pypi.org/pypi/patch-chat/json", timeout=(5, 15))
+        data = response.json()
+        latest_version = data["info"]["version"]
+        current_version = patch.__version__
+
+        if just_check or verbose:
+            io.tool_output(f"Current version: {current_version}")
+            io.tool_output(f"Latest version: {latest_version}")
+
+        is_update_available = packaging.version.parse(latest_version) > packaging.version.parse(
+            current_version
+        )
+    except Exception as err:
+        io.tool_error(f"Error checking pypi for new version: {err}")
+        return False
+    finally:
+        VERSION_CHECK_FNAME.parent.mkdir(parents=True, exist_ok=True)
+        VERSION_CHECK_FNAME.touch()
+
+    ###
+    # is_update_available = True
+
+    if just_check or verbose:
+        if is_update_available:
+            io.tool_output("Update available")
+        else:
+            io.tool_output("No update available")
+
+    if just_check:
+        return is_update_available
+
+    if not is_update_available:
+        return False
+
+    install_upgrade(io, latest_version)
+    return True