patchllm 0.1.0__py3-none-any.whl

patchllm/context.py

@@ -0,0 +1,175 @@
+import os
+import glob
+import textwrap
+import sys
+from pathlib import Path
+
+# --- Default Settings & Templates ---
+
+DEFAULT_EXCLUDE_EXTENSIONS = [
+    # General
+    ".log", ".lock", ".env", ".bak", ".tmp", ".swp", ".swo", ".db", ".sqlite3",
+    # Python
+    ".pyc", ".pyo", ".pyd",
+    # JS/Node
+    ".next", ".svelte-kit",
+    # OS-specific
+    ".DS_Store",
+    # Media/Binary files
+    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp",
+    ".mp3", ".mp4", ".mov", ".avi", ".pdf",
+    ".o", ".so", ".dll", ".exe",
+    # Unity specific
+    ".meta",
+]
+
+BASE_TEMPLATE = textwrap.dedent('''
+    Source Tree:
+    ------------
+    ```
+    {{source_tree}}
+    ```
+
+    Relevant Files:
+    ---------------
+    {{files_content}}
+''')
+
+# --- Helper Functions (File Discovery, Filtering, Tree Generation) ---
+
+def find_files(base_path: Path, include_patterns: list[str], exclude_patterns: list[str] | None = None) -> list[Path]:
+    """Finds all files using glob patterns, handling both relative and absolute paths."""
+    if exclude_patterns is None:
+        exclude_patterns = []
+
+    def _get_files_from_patterns(patterns: list[str]) -> set[Path]:
+        """Helper to process a list of glob patterns and return matching file paths."""
+        files = set()
+        for pattern_str in patterns:
+            pattern_path = Path(pattern_str)
+            # If the pattern is absolute, use it as is. Otherwise, join it with the base_path.
+            search_path = pattern_path if pattern_path.is_absolute() else base_path / pattern_path
+            
+            for match in glob.glob(str(search_path), recursive=True):
+                path_obj = Path(match).resolve()
+                if path_obj.is_file():
+                    files.add(path_obj)
+        return files
+
+    included_files = _get_files_from_patterns(include_patterns)
+    excluded_files = _get_files_from_patterns(exclude_patterns)
+
+    return sorted(list(included_files - excluded_files))
+
+
+def filter_files_by_keyword(file_paths: list[Path], search_words: list[str]) -> list[Path]:
+    """Returns files from a list that contain any of the specified search words."""
+    if not search_words:
+        return file_paths
+    
+    matching_files = []
+    for file_path in file_paths:
+        try:
+            # Using pathlib's read_text for cleaner code
+            if any(word in file_path.read_text(encoding='utf-8', errors='ignore') for word in search_words):
+                matching_files.append(file_path)
+        except Exception as e:
+            print(f"Warning: Could not read {file_path} for keyword search: {e}", file=sys.stderr)
+    return matching_files
+
+
+def generate_source_tree(base_path: Path, file_paths: list[Path]) -> str:
+    """Generates a string representation of the file paths as a tree."""
+    if not file_paths:
+        return "No files found matching the criteria."
+    
+    tree = {}
+    for path in file_paths:
+        try:
+            # Create a path relative to the intended base_path for the tree structure
+            rel_path = path.relative_to(base_path)
+        except ValueError:
+            # This occurs if a file (from an absolute pattern) is outside the base_path.
+            # In this case, we use the absolute path as a fallback.
+            rel_path = path
+            
+        level = tree
+        for part in rel_path.parts:
+            level = level.setdefault(part, {})
+
+    def _format_tree(tree_dict, indent=""):
+        lines = []
+        items = sorted(tree_dict.items(), key=lambda i: (not i[1], i[0]))
+        for i, (name, node) in enumerate(items):
+            last = i == len(items) - 1
+            connector = "└── " if last else "├── "
+            lines.append(f"{indent}{connector}{name}")
+            if node:
+                new_indent = indent + ("    " if last else "│   ")
+                lines.extend(_format_tree(node, new_indent))
+        return lines
+
+    return f"{base_path.name}\n" + "\n".join(_format_tree(tree))
+
+
+# --- Main Context Building Function ---
+
+def build_context(config: dict) -> dict | None:
+    """
+    Builds the context string from files specified in the config.
+
+    Args:
+        config (dict): The configuration for file searching.
+
+    Returns:
+        dict: A dictionary with the source tree and formatted context, or None.
+    """
+    # Resolve the base path immediately to get a predictable absolute path.
+    base_path = Path(config.get("path", ".")).resolve()
+    
+    include_patterns = config.get("include_patterns", [])
+    exclude_patterns = config.get("exclude_patterns", [])
+    exclude_extensions = config.get("exclude_extensions", DEFAULT_EXCLUDE_EXTENSIONS)
+    search_words = config.get("search_words", [])
+
+    # Step 1: Find files
+    relevant_files = find_files(base_path, include_patterns, exclude_patterns)
+
+    # Step 2: Filter by extension
+    count_before_ext = len(relevant_files)
+    norm_ext = {ext.lower() for ext in exclude_extensions}
+    relevant_files = [p for p in relevant_files if p.suffix.lower() not in norm_ext]
+    if count_before_ext > len(relevant_files):
+        print(f"Filtered {count_before_ext - len(relevant_files)} files by extension.")
+
+    # Step 3: Filter by keyword
+    if search_words:
+        count_before_kw = len(relevant_files)
+        relevant_files = filter_files_by_keyword(relevant_files, search_words)
+        print(f"Filtered {count_before_kw - len(relevant_files)} files by keyword search.")
+
+    if not relevant_files:
+        print("\nNo files matched the specified criteria.")
+        return None
+
+    print(f"\nFinal count of relevant files: {len(relevant_files)}.")
+
+    # Generate source tree and file content blocks
+    source_tree_str = generate_source_tree(base_path, relevant_files)
+    
+    file_contents = []
+    for file_path in relevant_files:
+        try:
+            display_path = file_path.as_posix()
+            content = file_path.read_text(encoding='utf-8')
+            file_contents.append(f"<file_path:{display_path}>\n```\n{content}\n```")
+        except Exception as e:
+            print(f"Warning: Could not read file {file_path}: {e}", file=sys.stderr)
+
+    files_content_str = "\n\n".join(file_contents)
+
+    # Assemble the final context using the base template
+    final_context = BASE_TEMPLATE.replace("{{source_tree}}", source_tree_str)
+    final_context = final_context.replace("{{files_content}}", files_content_str)
+    
+    return {"tree": source_tree_str, "context": final_context}

patchllm/listener.py

@@ -0,0 +1,28 @@
+import speech_recognition as sr
+import pyttsx3
+
+recognizer = sr.Recognizer()
+tts_engine = pyttsx3.init()
+
+def speak(text):
+    print("🤖 Speaking:", text)
+    tts_engine.say(text)
+    tts_engine.runAndWait()
+
+def listen(prompt=None, timeout=5):
+    with sr.Microphone() as source:
+        if prompt:
+            speak(prompt)
+        print("🎙 Listening...")
+        try:
+            audio = recognizer.listen(source, timeout=timeout)
+            text = recognizer.recognize_google(audio)
+            print(f"🗣 Recognized: {text}")
+            return text
+        except sr.WaitTimeoutError:
+            speak("No speech detected.")
+        except sr.UnknownValueError:
+            speak("Sorry, I didn’t catch that.")
+        except sr.RequestError:
+            speak("Speech recognition failed. Check your internet.")
+    return None

patchllm/main.py

@@ -0,0 +1,230 @@
+import sys
+
+from context import build_context
+from parser import paste_response
+from utils import load_from_py_file
+import textwrap
+import argparse
+import litellm
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Assistant:
+    """
+    An assistant that builds context, interacts with an LLM, and applies code changes.
+    """
+    def __init__(
+            self, 
+            model_name="gemini/gemini-2.5-flash",
+            configs_file = "./configs.py",
+        ):
+        """
+        Initializes the Assistant.
+        Args:
+            model_name (str): The alias for the generative model to use (must be a litellm supported model string).
+            configs_file (str): The path to the configurations file.
+        """
+        self.model_name = model_name
+        self.configs = load_from_py_file(configs_file, "configs")
+        system_prompt = textwrap.dedent("""
+            You are an expert pair programmer. Your purpose is to help users by modifying files based on their instructions.
+
+            Follow these rules strictly:
+            Your output should be a single file including all the updated files. For each file-block:
+            1. Only include code for files that need to be updated / edited.
+            2. For updated files, do not exclude any code even if it is unchanged code; assume the file code will be copy-pasted full in the file.
+            3. Do not include verbose inline comments explaining what every small change does. Try to keep comments concise but informative, if any.
+            4. Only update the relevant parts of each file relative to the provided task; do not make irrelevant edits even if you notice areas of improvements elsewhere.
+            5. Do not use diffs.
+            6. Make sure each file-block is returned in the following exact format. No additional text, comments, or explanations should be outside these blocks.
+
+            Expected format for a modified or new file:
+            <file_path:/absolute/path/to/your/file.py>
+            ```python
+            # The full, complete content of /absolute/path/to/your/file.py goes here.
+            def example_function():
+                return "Hello, World!"
+            ```
+
+            Example of multiple files:
+            <file_path:/home/user/project/src/main.py>
+            ```python
+            print("Main application start")
+            ```
+
+            <file_path:/home/user/project/tests/test_main.py>
+            ```python
+            def test_main():
+                assert True
+            ```
+        """)
+        self.history = [{"role": "system", "content": system_prompt}]
+
+    def collect(self, config_name):
+        """Builds the code context from a provided configuration dictionary."""
+        print("\n--- Building Code Context... ---")
+        selected_config = self.configs.get(config_name)
+        if selected_config is None:
+            raise KeyError(f"Context config '{config_name}' not found in provided configs file.")
+        context_object = build_context(selected_config)
+        if context_object:
+            tree, context = context_object.values()
+            print("--- Context Building Finished. The following files were extracted ---", file=sys.stderr)
+            print(tree)
+            return context
+        else:
+            print("--- Context Building Failed (No files found) ---", file=sys.stderr)
+            return None
+
+    def update(self, task_instructions, context=None):
+        """
+        Assembles the final prompt and sends it to the LLM to generate code, 
+        then in-place update the files from the response.
+        Args:
+            task_instructions (str): Specific instructions for this run.
+            context (str, optional): The code context. If None, only the task is sent.
+        """        
+        print("\n--- Sending Prompt to LLM... ---")
+        final_prompt = task_instructions
+        if context:
+            final_prompt = f"{context}\n\n{task_instructions}"
+        
+        self.history.append({"role": "user", "content": final_prompt})
+        
+        try:
+            response = litellm.completion(model=self.model_name, messages=self.history)
+            
+            # Extract the message content from the response
+            assistant_response_content = response.choices[0].message.content
+            
+            # Add the assistant's response to the history for future context
+            self.history.append({"role": "assistant", "content": assistant_response_content})
+
+            if not assistant_response_content or not assistant_response_content.strip():
+                print("Response is empty. Nothing to paste.")
+                return
+            
+            print("\n--- Updating files ---")
+            paste_response(assistant_response_content)
+            print("--- File Update Process Finished ---")
+
+        except Exception as e:
+            # If an error occurs, remove the last user message to keep history clean
+            self.history.pop()
+            raise RuntimeError(f"An error occurred while communicating with the LLM via litellm: {e}") from e
+
+    def write(self, file_path, context):
+        """Utility function to write the context to a file"""
+        print("Exporting context..")
+        with open(file_path, "w") as file:
+            file.write(context)
+        print(f'Context exported to {file_path.split("/")[-1]}')
+
+    def read(self, file_path):
+        """Utility function to read and return the content of a file."""
+        print("Importing from file..")
+        try:
+            with open(file_path, "r") as file:
+                print("Finished reading")
+                content = file.read()
+            return content
+        except Exception as e:
+            raise RuntimeError(f"Failed to read from file {file_path}: {e}") from e
+        
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run the Assistant tool to apply code changes using an LLM."
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        default=None,
+        help="Name of the config key to use from the configs.py file."
+    )
+    parser.add_argument(
+        "--task",
+        type=str,
+        default=None,
+        help="The task instructions to guide the assistant."
+    )
+    parser.add_argument(
+        "--context-out",
+        type=str,
+        default=None,
+        help="Optional path to export the generated context to a file."
+    )
+    parser.add_argument(
+        "--context-in",
+        type=str,
+        default=None,
+        help="Optional path to import a previously saved context from a file."
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="gemini/gemini-2.5-flash",
+        help="Optional model name to override the default model."
+    )
+    parser.add_argument(
+        "--from-file",
+        type=str,
+        default=None,
+        help="File path for a file with pre-formatted updates."
+    )
+    parser.add_argument(
+        "--update",
+        type=str,
+        default="True",
+        help="Whether to pass the input context to the llm to update the files."
+    )
+    parser.add_argument(
+        "--voice",
+        type=str,
+        default="False",
+        help="Whether to interact with the script using voice commands."
+    )
+
+    args = parser.parse_args()
+
+    assistant = Assistant(model_name=args.model)
+
+    # Handle voice input
+    if args.voice not in ["False", "false"]:
+        from listener import listen, speak
+
+        speak("Say your task instruction.")
+        task = listen()
+        if not task:
+            speak("No instruction heard. Exiting.")
+            return
+
+        speak(f"You said: {task}. Should I proceed?")
+        confirm = listen()
+        if confirm and "yes" in confirm.lower():
+            context = assistant.collect(args.config)
+            assistant.update(task_instructions=task, context=context)
+            speak("Changes applied.")
+        else:
+            speak("Cancelled.")
+        return
+
+    # Parse updates from a local file
+    if args.from_file:
+        updates = assistant.read(args.from_file)
+        paste_response(updates)
+        return
+
+    # Otherwise generate updates from llm response
+    if args.context_in:
+        context = assistant.read(args.context_in)
+    else:
+        context = assistant.collect(args.config)
+        if args.context_out:
+            assistant.write(args.context_out, context)
+    if not args.update in ["False", "false"]:
+        assistant.update(task_instructions=args.task, context=context)
+
+if __name__ == "__main__":
+    main()

patchllm/parser.py

@@ -0,0 +1,72 @@
+import re
+from pathlib import Path
+
+def paste_response(response_content):
+    """
+    Parses a response containing code blocks and writes them to files,
+    handling both absolute and relative paths safely.
+
+    Args:
+        response_content (str): The string response from the LLM.
+    """
+    pattern = re.compile(
+        r"<file_path:([^>]+?)>\s*```(?:.*?)\n(.*?)\n```",
+        re.DOTALL | re.MULTILINE
+    )
+
+    matches = pattern.finditer(response_content)
+    files_processed = 0
+    found_matches = False
+
+    for match in matches:
+        found_matches = True
+        file_path_str = match.group(1).strip()
+        code_content = match.group(2)
+
+        if not file_path_str:
+            print("Warning: Found a code block with an empty file path. Skipping.")
+            continue
+
+        print(f"Found path in response: '{file_path_str}'")
+        raw_path = Path(file_path_str)
+        
+        # Determine the final target path.
+        # If the path from the LLM is absolute, use it directly.
+        # If it's relative, resolve it against the current working directory.
+        if raw_path.is_absolute():
+            target_path = raw_path
+        else:
+            target_path = Path.cwd() / raw_path
+
+        # Normalize the path to resolve any ".." or "." segments.
+        target_path = target_path.resolve()
+
+        try:
+            # Ensure parent directory exists
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # If file exists, compare content to avoid unnecessary overwrites
+            if target_path.exists():
+                with open(target_path, 'r', encoding='utf-8') as existing_file:
+                    if existing_file.read() == code_content:
+                        print(f"  -> No changes for '{target_path}', skipping.")
+                        continue
+
+            # Write the extracted code to the file
+            with open(target_path, 'w', encoding='utf-8') as outfile:
+                outfile.write(code_content)
+
+            print(f"  -> Wrote {len(code_content)} bytes to '{target_path}'")
+            files_processed += 1
+
+        except OSError as e:
+            print(f"  -> Error writing file '{target_path}': {e}")
+        except Exception as e:
+            print(f"  -> An unexpected error occurred for file '{target_path}': {e}")
+
+    if not found_matches:
+        print("\nNo file paths and code blocks matching the expected format were found in the response.")
+    elif files_processed > 0:
+        print(f"\nSuccessfully processed {files_processed} file(s).")
+    else:
+        print("\nFound matching blocks, but no files were written.")

patchllm/utils.py

@@ -0,0 +1,18 @@
+import importlib.util
+from pathlib import Path
+
+def load_from_py_file(file_path, dict_name):
+    """Dynamically loads a dictionary from a Python file."""
+    path = Path(file_path)
+    if not path.is_file():
+        raise FileNotFoundError(f"The file '{path}' was not found.")
+    
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    dictionary = getattr(module, dict_name, None)
+    if not isinstance(dictionary, dict):
+        raise TypeError(f"The file '{path}' must contain a dictionary named '{dict_name}'.")
+    
+    return dictionary

patchllm-0.1.0.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: patchllm
+Version: 0.1.0
+Summary: Lightweight tool to manage contexts and update code with LLMs
+Author: nassimberrada
+License: MIT License
+        
+        Copyright (c) 2025 nassimberrada
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the “Software”), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm
+Dynamic: license-file
+
+<p align="center">
+  <picture>
+    <source srcset="./assets/logo_dark.png" media="(prefers-color-scheme: dark)">
+    <source srcset="./assets/logo_light.png" media="(prefers-color-scheme: light)">
+    <img src="./assets/logo_light.png" alt="PatchLLM Logo" height="200">
+  </picture>
+</p>
+
+## About
+PatchLLM lets you flexibly build LLM context from your codebase using search patterns, and automatically edit files from the LLM response in a couple lines of code. 
+
+## Usage
+Here's a basic example of how to use the `Assistant` class:
+
+```python
+from main import Assistant
+
+assistant = Assistant()
+
+context = assistant.collect(config_name="default")
+>> The following files were extracted:
+>> my_project
+>> ├── README.md
+>> ├── configs.py
+>> ├── context.py
+>> ├── main.py
+>> ├── parser.py
+>> ├── requirements.txt
+>> ├── systems.py
+>> └── utils.py
+
+assistant.update("Fix any bug in these files", context=context)
+>> Wrote 5438 bytes to '/my_project/context.py'
+>> Wrote 1999 bytes to '/my_project/utils.py'
+>> Wrote 2345 bytes to '/my_project/main.py'
+```
+
+You can decide which files to include / exclude from the prompt by adding a config in `configs.py`, specifying:
+ - `path`: The root path from which to perform the file search
+ - `include_patterns`: A list of glob patterns for files to include. e.g `[./**/*]`
+ - `exclude_patterns`: A list of glob patterns for files to exlucde. e.g `[./*.md]`
+ - `search_word`: A list of keywords included in the target files. e.g  `["config"]`
+ - `exclude_extensions`: A list of file extensions to exclude. e.g `[.jpg]`
+
+### Setup
+
+PatchLLM uses [LiteLLM](https://github.com/BerriAI/litellm) under the hood. Please refer to their documentation for environment variable naming and available models.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

patchllm-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+patchllm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+patchllm/context.py,sha256=zUrXf5l3cdxAbmxB7IjbShTAWA_ZEMBz8OGlaB-cofE,6450
+patchllm/listener.py,sha256=EdcceJCLEoSftX1dVSWxtwBsLaII2lcZ0VnllHwCGWI,845
+patchllm/main.py,sha256=-11bAS-bx2SfGx14KCCZhuwrfh_FDcQ80cwUfYrszY8,8569
+patchllm/parser.py,sha256=4wipa6deoE2gUIhYrvUZcbKTIr5j6lw5Z6bOItUH6YI,2629
+patchllm/utils.py,sha256=hz28hd017gRGT632VQAYLPdX0KAS1GLvZzeUDCKbLc0,647
+patchllm-0.1.0.dist-info/licenses/LICENSE,sha256=vZxgIRNxffjkTV2NWLemgYjDRu0hSMTyFXCZ1zEWbUc,1077
+patchllm-0.1.0.dist-info/METADATA,sha256=BtSvIfjwiWqvv-1d_GPBf1n7ao9R2YY3m8Qd_Rr4c6A,3404
+patchllm-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+patchllm-0.1.0.dist-info/entry_points.txt,sha256=_jqCdL7snk6RZfqiSzP_XttWYAPNw_UdnAEqYS-rrd8,48
+patchllm-0.1.0.dist-info/top_level.txt,sha256=SLIZj9EhBXbSnYrbnV8EjL-OfNz-hXRwABCPCjE5Fas,9
+patchllm-0.1.0.dist-info/RECORD,,

patchllm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

patchllm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+yourtool = patchllm.main:main

patchllm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 nassimberrada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

patchllm-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+patchllm