patchllm 0.1.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

patchllm/__init__.py

@@ -1 +0,0 @@
-from .main import Assistant

patchllm/context.py

@@ -1,8 +1,11 @@
-import os
 import glob
 import textwrap
-import sys
+import subprocess
+import shutil
 from pathlib import Path
+from rich.console import Console
+
+console = Console()
 
 # --- Default Settings & Templates ---
 
@@ -29,12 +32,19 @@ BASE_TEMPLATE = textwrap.dedent('''
     ```
     {{source_tree}}
     ```
-
+    {{url_contents}}
     Relevant Files:
     ---------------
     {{files_content}}
 ''')
 
+URL_CONTENT_TEMPLATE = textwrap.dedent('''
+    URL Contents:
+    -------------
+    {{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]:
@@ -70,11 +80,10 @@ def filter_files_by_keyword(file_paths: list[Path], search_words: list[str]) ->
     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)
+            console.print(f"⚠️  Could not read {file_path} for keyword search: {e}", style="yellow")
     return matching_files
 
 
@@ -86,11 +95,8 @@ def generate_source_tree(base_path: Path, file_paths: list[Path]) -> str:
     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
@@ -112,25 +118,80 @@ def generate_source_tree(base_path: Path, file_paths: list[Path]) -> str:
     return f"{base_path.name}\n" + "\n".join(_format_tree(tree))
 
 
+def fetch_and_process_urls(urls: list[str]) -> str:
+    """Downloads and converts a list of URLs to text, returning a formatted string."""
+    if not urls:
+        return ""
+
+    try:
+        import html2text
+    except ImportError:
+        console.print("⚠️  To use the URL feature, please install the required extras:", style="yellow")
+        console.print("   pip install patchllm[url]", style="cyan")
+        return ""
+
+    downloader = None
+    if shutil.which("curl"):
+        downloader = "curl"
+    elif shutil.which("wget"):
+        downloader = "wget"
+
+    if not downloader:
+        console.print("⚠️  Cannot fetch URL content: 'curl' or 'wget' not found in PATH.", style="yellow")
+        return ""
+
+    h = html2text.HTML2Text()
+    h.ignore_links = True
+    h.ignore_images = True
+    
+    all_url_contents = []
+
+    console.print("\n--- Fetching URL Content... ---", style="bold")
+    for url in urls:
+        try:
+            console.print(f"Fetching [cyan]{url}[/cyan]...")
+            if downloader == "curl":
+                command = ["curl", "-s", "-L", url]
+            else: # wget
+                command = ["wget", "-q", "-O", "-", url]
+
+            result = subprocess.run(command, capture_output=True, text=True, check=True, timeout=15)
+            html_content = result.stdout
+            text_content = h.handle(html_content)
+            all_url_contents.append(f"<url_content:{url}>\n```\n{text_content}\n```")
+
+        except subprocess.CalledProcessError as e:
+            console.print(f"❌ Failed to fetch {url}: {e.stderr}", style="red")
+        except subprocess.TimeoutExpired:
+            console.print(f"❌ Failed to fetch {url}: Request timed out.", style="red")
+        except Exception as e:
+            console.print(f"❌ An unexpected error occurred while fetching {url}: {e}", style="red")
+
+    if not all_url_contents:
+        return ""
+    
+    content_str = "\n\n".join(all_url_contents)
+    return URL_CONTENT_TEMPLATE.replace("{{content}}", content_str)
+
 # --- Main Context Building Function ---
 
-def build_context(config: dict) -> dict | None:
+def build_context(scope: dict) -> dict | None:
     """
-    Builds the context string from files specified in the config.
+    Builds the context string from files specified in the scope.
 
     Args:
-        config (dict): The configuration for file searching.
+        scope (dict): The scope 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()
+    base_path = Path(scope.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", [])
+    include_patterns = scope.get("include_patterns", [])
+    exclude_patterns = scope.get("exclude_patterns", [])
+    exclude_extensions = scope.get("exclude_extensions", DEFAULT_EXCLUDE_EXTENSIONS)
+    search_words = scope.get("search_words", [])
+    urls = scope.get("urls", [])
 
     # Step 1: Find files
     relevant_files = find_files(base_path, include_patterns, exclude_patterns)
@@ -140,20 +201,18 @@ def build_context(config: dict) -> dict | None:
     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.")
+        console.print(f"Filtered {count_before_ext - len(relevant_files)} files by extension.", style="cyan")
 
     # 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.")
+        console.print(f"Filtered {count_before_kw - len(relevant_files)} files by keyword search.", style="cyan")
 
-    if not relevant_files:
-        print("\nNo files matched the specified criteria.")
+    if not relevant_files and not urls:
+        console.print("\n⚠️  No files or URLs matched the specified criteria.", style="yellow")
         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)
     
@@ -164,12 +223,16 @@ def build_context(config: dict) -> dict | None:
             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)
+            console.print(f"⚠️  Could not read file {file_path}: {e}", style="yellow")
 
     files_content_str = "\n\n".join(file_contents)
 
+    # Fetch and process URL contents
+    url_contents_str = fetch_and_process_urls(urls)
+
     # Assemble the final context using the base template
     final_context = BASE_TEMPLATE.replace("{{source_tree}}", source_tree_str)
+    final_context = final_context.replace("{{url_contents}}", url_contents_str)
     final_context = final_context.replace("{{files_content}}", files_content_str)
     
     return {"tree": source_tree_str, "context": final_context}

patchllm/listener.py

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

patchllm/main.py

@@ -1,235 +1,326 @@
-import sys
+import textwrap
+import argparse
+import litellm
+import pprint
+import os
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.panel import Panel
 
 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
+console = Console()
 
-load_dotenv()
+# --- Core Functions ---
 
-class Assistant:
+def collect_context(scope_name, scopes):
+    """Builds the code context from a provided scope dictionary."""
+    console.print("\n--- Building Code Context... ---", style="bold")
+    if not scopes:
+        raise FileNotFoundError("Could not find a 'scopes.py' file.")
+    selected_scope = scopes.get(scope_name)
+    if selected_scope is None:
+        raise KeyError(f"Context scope '{scope_name}' not found in provided scopes file.")
+    
+    context_object = build_context(selected_scope)
+    if context_object:
+        tree, context = context_object.values()
+        console.print("--- Context Building Finished. The following files were extracted ---", style="bold")
+        console.print(tree)
+        return context
+    else:
+        console.print("--- Context Building Failed (No files found) ---", style="yellow")
+        return None
+
+def run_llm_query(task_instructions, model_name, history, context=None):
     """
-    An assistant that builds context, interacts with an LLM, and applies code changes.
+    Assembles the final prompt, sends it to the LLM, and returns the response.
     """
-    def __init__(
-            self, 
-            model_name="gemini/gemini-2.5-flash",
-            configs: dict = None,
-            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 (Dict[str]): A dictionary of configurations to use for building the code context.
-            configs_file (str): The path to the configurations file.
-        """
-        self.model_name = model_name
-        if configs:
-            self.configs = configs
-        else:
-            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)
+    console.print("\n--- Sending Prompt to LLM... ---", style="bold")
+    final_prompt = task_instructions
+    if context:
+        final_prompt = f"{context}\n\n{task_instructions}"
+    
+    history.append({"role": "user", "content": final_prompt})
+    
+    try:
+        with console.status("[bold cyan]Waiting for LLM response...", spinner="dots"):
+            response = litellm.completion(model=model_name, messages=history)
+        
+        assistant_response_content = response.choices[0].message.content
+        history.append({"role": "assistant", "content": assistant_response_content})
+
+        if not assistant_response_content or not assistant_response_content.strip():
+            console.print("⚠️  Response is empty. Nothing to process.", style="yellow")
             return None
+        
+        return assistant_response_content
 
-    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}"
+    except Exception as e:
+        history.pop() # Keep history clean on error
+        raise RuntimeError(f"An error occurred while communicating with the LLM via litellm: {e}") from e
+
+def write_to_file(file_path, content):
+    """Utility function to write content to a file."""
+    console.print(f"Writing to {file_path}..", style="cyan")
+    try:
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write(content)
+        console.print(f'✅ Content saved to {file_path}', style="green")
+    except Exception as e:
+        raise RuntimeError(f"Failed to write to file {file_path}: {e}") from e
+
+def read_from_file(file_path):
+    """Utility function to read and return the content of a file."""
+    console.print(f"Importing from {file_path}..", style="cyan")
+    try:
+        with open(file_path, "r", encoding="utf-8") as file:
+            content = file.read()
+            console.print("✅ Finished reading file.", style="green")
+            return content
+    except Exception as e:
+        raise RuntimeError(f"Failed to read from file {file_path}: {e}") from e
+
+def create_new_scope(scopes, scopes_file_str):
+    """Interactively creates a new scope and saves it to the specified scopes file."""
+    console.print(f"\n--- Creating a new scope in '{scopes_file_str}' ---", style="bold")
+    
+    try:
+        name = console.input("[bold]Enter a name for the new scope: [/]").strip()
+        if not name:
+            console.print("❌ Scope name cannot be empty.", style="red")
+            return
+
+        if name in scopes:
+            overwrite = console.input(f"Scope '[bold]{name}[/]' already exists. Overwrite? (y/n): ").lower()
+            if overwrite not in ['y', 'yes']:
+                console.print("Operation cancelled.", style="yellow")
+                return
+
+        path = console.input("[bold]Enter the base path[/] (e.g., '.' for current directory): ").strip() or "."
         
-        self.history.append({"role": "user", "content": final_prompt})
+        console.print("\nEnter comma-separated glob patterns for files to include.")
+        include_raw = console.input('[cyan]> (e.g., "[bold]**/*.py, src/**/*.js[/]"): [/]').strip()
+        include_patterns = [p.strip() for p in include_raw.split(',') if p.strip()]
+
+        console.print("\nEnter comma-separated glob patterns for files to exclude (optional).")
+        exclude_raw = console.input('[cyan]> (e.g., "[bold]**/tests/*, venv/*[/]"): [/]').strip()
+        exclude_patterns = [p.strip() for p in exclude_raw.split(',') if p.strip()]
         
-        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})
+        new_scope_data = {
+            "path": path,
+            "include_patterns": include_patterns,
+            "exclude_patterns": exclude_patterns
+        }
 
-            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 ---")
+        scopes[name] = new_scope_data
 
-        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
+        with open(scopes_file_str, "w", encoding="utf-8") as f:
+            f.write("# scopes.py\n")
+            f.write("scopes = ")
+            f.write(pprint.pformat(scopes, indent=4))
+            f.write("\n")
         
+        console.print(f"\n✅ Successfully created and saved scope '[bold]{name}[/]' in '[bold]{scopes_file_str}[/]'.", style="green")
+
+    except KeyboardInterrupt:
+        console.print("\n\n⚠️ Scope creation cancelled by user.", style="yellow")
+        return
+
 def main():
+    """
+    Main entry point for the patchllm command-line tool.
+    """
+    load_dotenv()
+    
+    scopes_file_path = os.getenv("PATCHLLM_SCOPES_FILE", "./scopes.py")
+
     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."
+        description="A CLI tool to apply code changes using an LLM.",
+        formatter_class=argparse.RawTextHelpFormatter
     )
 
+    # --- Group: Core Patching Flow ---
+    patch_group = parser.add_argument_group('Core Patching Flow')
+    patch_group.add_argument("-s", "--scope", type=str, default=None, help="Name of the scope to use from the scopes file.")
+    patch_group.add_argument("-t", "--task", type=str, default=None, help="The task instructions to guide the assistant.")
+    patch_group.add_argument("-p", "--patch", action="store_true", help="Query the LLM and directly apply the file updates from the response. Requires --task.")
+
+    # --- Group: Scope Management ---
+    scope_group = parser.add_argument_group('Scope Management')
+    scope_group.add_argument("-i", "--init", action="store_true", help="Create a new scope interactively.")
+    scope_group.add_argument("-sl", "--list-scopes", action="store_true", help="List all available scopes from the scopes file and exit.")
+    scope_group.add_argument("-ss", "--show-scope", type=str, help="Display the settings for a specific scope and exit.")
+
+    # --- Group: I/O Utils---
+    code_io = parser.add_argument_group('Code I/O')
+    code_io.add_argument("-co", "--context-out", nargs='?', const="context.md", default=None, help="Export the generated context to a file. Defaults to 'context.md'.")
+    code_io.add_argument("-ci", "--context-in", type=str, default=None, help="Import a previously saved context from a file.")
+    code_io.add_argument("-tf", "--to-file", nargs='?', const="response.md", default=None, help="Query the LLM and save the response to a file. Requires --task. Defaults to 'response.md'.")
+    code_io.add_argument("-tc", "--to-clipboard", action="store_true", help="Query the LLM and save the response to the clipboard. Requires --task.")
+    code_io.add_argument("-ff", "--from-file", type=str, default=None, help="Apply code updates directly from a file.")
+    code_io.add_argument("-fc", "--from-clipboard", action="store_true", help="Apply code updates directly from the clipboard.")
+    
+    # --- Group: General Options ---
+    options_group = parser.add_argument_group('General Options')
+    options_group.add_argument("-m", "--model", type=str, default="gemini/gemini-2.5-flash", help="Model name to use (e.g., 'gpt-4o', 'claude-3-sonnet').")
+    options_group.add_argument("-v", "--voice", type=str, default="False", help="Enable voice interaction for providing task instructions. (True/False)")
+    
     args = parser.parse_args()
 
-    assistant = Assistant(model_name=args.model)
+    try:
+        scopes = load_from_py_file(scopes_file_path, "scopes")
+    except FileNotFoundError:
+        scopes = {}
+        if not any([args.init, args.list_scopes, args.show_scope]):
+             console.print(f"⚠️  Scope file '{scopes_file_path}' not found. You can create one with the --init flag.", style="yellow")
 
-    # Handle voice input
+
+    if args.list_scopes:
+        console.print(f"Available scopes in '[bold]{scopes_file_path}[/]':", style="bold")
+        if not scopes:
+            console.print(f"  -> No scopes found or '{scopes_file_path}' is missing.")
+        else:
+            for scope_name in scopes:
+                console.print(f"  - {scope_name}")
+        return
+
+    if args.show_scope:
+        scope_name = args.show_scope
+        if not scopes:
+            console.print(f"⚠️  Scope file '{scopes_file_path}' not found or is empty.", style="yellow")
+            return
+        
+        scope_data = scopes.get(scope_name)
+        if scope_data:
+            pretty_scope = pprint.pformat(scope_data, indent=2)
+            console.print(
+                Panel(
+                    pretty_scope,
+                    title=f"[bold cyan]Scope: '{scope_name}'[/]",
+                    subtitle=f"[dim]from {scopes_file_path}[/dim]",
+                    border_style="blue"
+                )
+            )
+        else:
+            console.print(f"❌ Scope '[bold]{scope_name}[/]' not found in '{scopes_file_path}'.", style="red")
+        return
+
+    if args.init:
+        create_new_scope(scopes, scopes_file_path)
+        return
+
+    if args.from_clipboard:
+        try:
+            import pyperclip
+            updates = pyperclip.paste()
+            if updates:
+                console.print("--- Parsing updates from clipboard ---", style="bold")
+                paste_response(updates)
+            else:
+                console.print("⚠️ Clipboard is empty. Nothing to parse.", style="yellow")
+        except ImportError:
+            console.print("❌ The 'pyperclip' library is required for clipboard functionality.", style="red")
+            console.print("Please install it using: pip install pyperclip", style="cyan")
+        except Exception as e:
+            console.print(f"❌ An error occurred while reading from the clipboard: {e}", style="red")
+        return
+
+    if args.from_file:
+        updates = read_from_file(args.from_file)
+        paste_response(updates)
+        return
+        
+    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!"
+        ```
+    """)
+    history = [{"role": "system", "content": system_prompt}]
+    
+    context = None
     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.")
+            if not args.scope:
+                parser.error("A --scope name is required when using --voice.")
+            context = collect_context(args.scope, scopes)
+            llm_response = run_llm_query(task, args.model, history, context)
+            if llm_response:
+                paste_response(llm_response)
+                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
+    # --- Main LLM Task Logic ---
+    if args.task:
+        action_flags = [args.patch, args.to_file is not None, args.to_clipboard]
+        if sum(action_flags) == 0:
+            parser.error("A task was provided, but no action was specified. Use --patch, --to-file, or --to-clipboard.")
+        if sum(action_flags) > 1:
+            parser.error("Please specify only one action: --patch, --to-file, or --to-clipboard.")
 
-    # 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 args.context_in:
+            context = read_from_file(args.context_in)
+        else:
+            if not args.scope:
+                parser.error("A --scope name is required to build context for a task.")
+            context = collect_context(args.scope, scopes)
+            if context and args.context_out:
+                write_to_file(args.context_out, context)
+
+        if not context:
+            console.print("Proceeding with task but without any file context.", style="yellow")
+
+        llm_response = run_llm_query(args.task, args.model, history, context)
+
+        if llm_response:
+            if args.patch:
+                console.print("\n--- Updating files ---", style="bold")
+                paste_response(llm_response)
+                console.print("--- File Update Process Finished ---", style="bold")
+            
+            elif args.to_file is not None:
+                write_to_file(args.to_file, llm_response)
+
+            elif args.to_clipboard:
+                try:
+                    import pyperclip
+                    pyperclip.copy(llm_response)
+                    console.print("✅ Copied LLM response to clipboard.", style="green")
+                except ImportError:
+                    console.print("❌ The 'pyperclip' library is required for clipboard functionality.", style="red")
+                    console.print("Please install it using: pip install pyperclip", style="cyan")
+                except Exception as e:
+                    console.print(f"❌ An error occurred while copying to the clipboard: {e}", style="red")
+    
+    elif args.scope and args.context_out:
+        context = collect_context(args.scope, scopes)
+        if context:
+            write_to_file(args.context_out, context)
 
 if __name__ == "__main__":
     main()

patchllm/parser.py

@@ -1,5 +1,10 @@
 import re
 from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
 
 def paste_response(response_content):
     """
@@ -15,7 +20,10 @@ def paste_response(response_content):
     )
 
     matches = pattern.finditer(response_content)
-    files_processed = 0
+    
+    files_written = []
+    files_skipped = []
+    files_failed = []
     found_matches = False
 
     for match in matches:
@@ -24,49 +32,54 @@ def paste_response(response_content):
         code_content = match.group(2)
 
         if not file_path_str:
-            print("Warning: Found a code block with an empty file path. Skipping.")
+            console.print("⚠️ Found a code block with an empty file path. Skipping.", style="yellow")
             continue
 
-        print(f"Found path in response: '{file_path_str}'")
+        console.print(f"Found path in response: '[cyan]{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.")
+                        console.print(f"  -> No changes for '[cyan]{target_path}[/]', skipping.", style="dim")
+                        files_skipped.append(target_path)
                         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
+            console.print(f"  -> ✅ Wrote {len(code_content)} bytes to '[cyan]{target_path}[/]'", style="green")
+            files_written.append(target_path)
 
         except OSError as e:
-            print(f"  -> Error writing file '{target_path}': {e}")
+            console.print(f"  -> ❌ Error writing file '[cyan]{target_path}[/]': {e}", style="red")
+            files_failed.append(target_path)
         except Exception as e:
-            print(f"  -> An unexpected error occurred for file '{target_path}': {e}")
+            console.print(f"  -> ❌ An unexpected error occurred for file '[cyan]{target_path}[/]': {e}", style="red")
+            files_failed.append(target_path)
 
+    summary_text = Text()
     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).")
+        summary_text.append("No file paths and code blocks matching the expected format were found in the response.", style="yellow")
     else:
-        print("\nFound matching blocks, but no files were written.")
+        if files_written:
+            summary_text.append(f"Successfully wrote {len(files_written)} file(s).\n", style="green")
+        if files_skipped:
+            summary_text.append(f"Skipped {len(files_skipped)} file(s) (no changes).\n", style="cyan")
+        if files_failed:
+            summary_text.append(f"Failed to write {len(files_failed)} file(s).\n", style="red")
+        
+        if not any([files_written, files_skipped, files_failed]):
+             summary_text.append("Found matching blocks, but no files were processed.", style="yellow")
+
+    console.print(Panel(summary_text, title="[bold]Summary[/bold]", border_style="blue"))

patchllm-0.2.2.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: patchllm
+Version: 0.2.2
+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
+Requires-Dist: python-dotenv
+Requires-Dist: rich
+Provides-Extra: voice
+Requires-Dist: SpeechRecognition; extra == "voice"
+Requires-Dist: pyttsx3; extra == "voice"
+Provides-Extra: url
+Requires-Dist: html2text; extra == "url"
+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 is a command-line tool that lets you flexibly build LLM context from your codebase using glob patterns, URLs, and keyword searches. It then automatically applies file edits directly from the LLM's response.
+
+## Usage
+PatchLLM is designed to be used directly from your terminal. The core workflow is to define a **scope** of files, provide a **task**, and choose an **action** (like patching files directly).
+
+### 1. Initialize a Scope
+The easiest way to get started is to run the interactive initializer. This will create a `scopes.py` file for you, which holds your saved scopes.
+
+```bash
+patchllm --init
+```
+
+This will guide you through creating your first scope, including setting a base path and file patterns. You can add multiple scopes to this file for different projects or tasks.
+
+A generated `scopes.py` might look like this:
+```python
+# scopes.py
+scopes = {
+    "default": {
+        "path": ".",
+        "include_patterns": ["**/*.py"],
+        "exclude_patterns": ["**/tests/*", "venv/*"],
+        "urls": ["https://docs.python.org/3/library/argparse.html"]
+    },
+    "docs": {
+        "path": "./docs",
+        "include_patterns": ["**/*.md"],
+    }
+}
+```
+
+### 2. Run a Task
+Use the `patchllm` command with a scope, a task, and an action flag like `--patch` (`-p`).
+
+```bash
+# Apply a change using the 'default' scope and the --patch action
+patchllm -s default -t "Add type hints to the main function in main.py" -p
+```
+
+The tool will then:
+1.  Build a context from the files and URLs matching your `default` scope.
+2.  Send the context and your task to the configured LLM.
+3.  Parse the response and automatically write the changes to the relevant files.
+
+### All Commands & Options
+
+#### Core Patching Flow
+*   `-s, --scope <name>`: Name of the scope to use from your `scopes.py` file.
+*   `-t, --task "<instruction>"`: The task instruction for the LLM.
+*   `-p, --patch`: Query the LLM and directly apply the file updates from the response. **This is the main action flag.**
+
+#### Scope Management
+*   `-i, --init`: Create a new scope interactively.
+*   `-sl, --list-scopes`: List all available scopes from your `scopes.py` file.
+*   `-ss, --show-scope <name>`: Display the settings for a specific scope.
+
+#### I/O & Context Management
+*   `-co, --context-out [filename]`: Export the generated context to a file (defaults to `context.md`) instead of running a task.
+*   `-ci, --context-in <filename>`: Use a previously saved context file as input for a task.
+*   `-tf, --to-file [filename]`: Send the LLM response to a file (defaults to `response.md`) instead of patching directly.
+*   `-tc, --to-clipboard`: Copy the LLM response to the clipboard.
+*   `-ff, --from-file <filename>`: Apply patches from a local file instead of an LLM response.
+*   `-fc, --from-clipboard`: Apply patches directly from your clipboard content.
+
+#### General Options
+*   `--model <model_name>`: Specify a different model (e.g., `gpt-4o`). Defaults to `gemini/gemini-1.5-flash`.
+*   `--voice`: Enable voice recognition to provide the task instruction.
+
+### Setup
+
+PatchLLM uses [LiteLLM](https://github.com/BerriAI/litellm) under the hood. Please refer to their documentation for setting up API keys (e.g., `OPENAI_API_KEY`, `GEMINI_API_KEY`) in a `.env` file and for a full list of available models.
+
+To use the voice feature (`--voice`), you will need to install extra dependencies:
+```bash
+pip install "speechrecognition>=3.10" "pyttsx3>=2.90"
+# Note: speechrecognition may require PyAudio, which might have system-level dependencies.
+```
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

patchllm-0.2.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+patchllm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+patchllm/context.py,sha256=_05amx0WgmHGhJrjB72K-QaWEP6u7vIAanhNjqL7YtQ,8503
+patchllm/listener.py,sha256=VjQ_CrSRT4-PolXAAradPKyt8NSUaUQwvgPNH7Oi9q0,968
+patchllm/main.py,sha256=y5OGNXEvRWTlUpxj9N6j3Ryhko-XVy_NkQ5axhCzljI,14944
+patchllm/parser.py,sha256=DNcf9iUH8umExfK78CSIwac1Bbu7K9iE3754y7CvYzs,3229
+patchllm/utils.py,sha256=hz28hd017gRGT632VQAYLPdX0KAS1GLvZzeUDCKbLc0,647
+patchllm-0.2.2.dist-info/licenses/LICENSE,sha256=vZxgIRNxffjkTV2NWLemgYjDRu0hSMTyFXCZ1zEWbUc,1077
+patchllm-0.2.2.dist-info/METADATA,sha256=xr-iByWSfelUa5xwGgd7G_mROO17ZtxU9QVILbfZQEc,5689
+patchllm-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+patchllm-0.2.2.dist-info/entry_points.txt,sha256=xm-W7FKOQd3o9RgK_4krVnO2sC8phpYxDCobf0htLiU,48
+patchllm-0.2.2.dist-info/top_level.txt,sha256=SLIZj9EhBXbSnYrbnV8EjL-OfNz-hXRwABCPCjE5Fas,9
+patchllm-0.2.2.dist-info/RECORD,,

patchllm-0.1.1.dist-info/METADATA

@@ -1,87 +0,0 @@
-Metadata-Version: 2.4
-Name: patchllm
-Version: 0.1.1
-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
-Requires-Dist: python-dotenv
-Provides-Extra: voice
-Requires-Dist: SpeechRecognition; extra == "voice"
-Requires-Dist: pyttsx3; extra == "voice"
-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.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-patchllm/__init__.py,sha256=rtpA9Og8Jm6IVwPB2r0xA57nririqM09DuvaIV6JipQ,27
-patchllm/context.py,sha256=zUrXf5l3cdxAbmxB7IjbShTAWA_ZEMBz8OGlaB-cofE,6450
-patchllm/listener.py,sha256=EdcceJCLEoSftX1dVSWxtwBsLaII2lcZ0VnllHwCGWI,845
-patchllm/main.py,sha256=ed7CNEt8UlOw2GmE-LVLMyVZddTBKR1R0U3YBrRg6UM,8782
-patchllm/parser.py,sha256=4wipa6deoE2gUIhYrvUZcbKTIr5j6lw5Z6bOItUH6YI,2629
-patchllm/utils.py,sha256=hz28hd017gRGT632VQAYLPdX0KAS1GLvZzeUDCKbLc0,647
-patchllm-0.1.1.dist-info/licenses/LICENSE,sha256=vZxgIRNxffjkTV2NWLemgYjDRu0hSMTyFXCZ1zEWbUc,1077
-patchllm-0.1.1.dist-info/METADATA,sha256=q-jcWSBhahwklDhaDyydRGFxX25co-tY3wyWhNAiuRI,3547
-patchllm-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-patchllm-0.1.1.dist-info/entry_points.txt,sha256=xm-W7FKOQd3o9RgK_4krVnO2sC8phpYxDCobf0htLiU,48
-patchllm-0.1.1.dist-info/top_level.txt,sha256=SLIZj9EhBXbSnYrbnV8EjL-OfNz-hXRwABCPCjE5Fas,9
-patchllm-0.1.1.dist-info/RECORD,,