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

patchllm/cli/entrypoint.py

@@ -0,0 +1,120 @@
+import argparse
+import textwrap
+import os
+import sys
+from pathlib import Path
+from rich.console import Console
+
+from .handlers import (
+    handle_init, handle_scope_management, handle_file_io, 
+    handle_main_task_flow, handle_voice_flow
+)
+from ..utils import load_from_py_file
+
+console = Console()
+
+def main():
+    """Main entry point for the patchllm command-line tool."""
+    from dotenv import load_dotenv
+    load_dotenv()
+    
+    scopes_file_path = os.getenv("PATCHLLM_SCOPES_FILE", "./scopes.py")
+    recipes_file_path = os.getenv("PATCHLLM_RECIPES_FILE", "./recipes.py")
+
+    parser = argparse.ArgumentParser(
+        description="A CLI tool to apply code changes using an LLM.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+
+    patch_group = parser.add_argument_group('Core Patching Flow')
+    scope_group = parser.add_argument_group('Scope Management')
+    code_io = parser.add_argument_group('Code I/O')
+    options_group = parser.add_argument_group('General Options')
+
+    patch_group.add_argument(
+        "-c", "--chat", action="store_true",
+        help="[DEPRECATED] Start the agentic TUI. This is now the default action."
+    )
+    patch_group.add_argument(
+        "-in", "--interactive", action="store_true",
+        help="Interactively build the context by selecting files and folders."
+    )
+    patch_group.add_argument(
+        "-s", "--scope", type=str, default=None,
+        help=textwrap.dedent("""\
+        Name of the scope to use (static or dynamic).
+        Dynamic: @structure, @git, @git:staged, @git:unstaged, @git:branch[:base], 
+                 @git:lastcommit, @git:conflicts, @recent, @dir:<path>, 
+                 @related:<file>, @search:"<term>", @error:"<traceback>"
+        """))
+    patch_group.add_argument(
+        "-r", "--recipe", type=str, default=None,
+        help="Name of the recipe to use from your 'recipes.py' file."
+    )
+    patch_group.add_argument("-t", "--task", type=str, help="The task instructions for the assistant.")
+    patch_group.add_argument("-p", "--patch", action="store_true", help="Query the LLM and apply file updates.")
+
+    scope_group.add_argument("-i", "--init", action="store_true", help="Create a default 'scopes.py' file.")
+    scope_group.add_argument("-sl", "--list-scopes", action="store_true", help="List all available scopes.")
+    scope_group.add_argument("-ss", "--show-scope", type=str, help="Display the settings for a specific scope.")
+    scope_group.add_argument("-sa", "--add-scope", type=str, help="Add a new scope with default settings.")
+    scope_group.add_argument("-sr", "--remove-scope", type=str, help="Remove a scope.")
+    scope_group.add_argument("-su", "--update-scope", nargs='+', help="Update a scope. Usage: -su <scope> key=\"['val']\"")
+
+    code_io.add_argument("-co", "--context-out", nargs='?', const="context.md", default=None, help="Export context to a file.")
+    code_io.add_argument("-ci", "--context-in", type=str, default=None, help="Import context from a file.")
+    code_io.add_argument("-tf", "--to-file", nargs='?', const="response.md", default=None, help="Save LLM response to a file.")
+    code_io.add_argument("-tc", "--to-clipboard", action="store_true", help="Copy LLM response to clipboard.")
+    code_io.add_argument("-ff", "--from-file", type=str, default=None, help="Apply updates from a file.")
+    code_io.add_argument("-fc", "--from-clipboard", action="store_true", help="Apply updates from the clipboard.")
+    
+    options_group.add_argument("-m", "--model", type=str, default="gemini/gemini-1.5-flash", help="Model name to use.")
+    options_group.add_argument("-v", "--voice", type=str, default="False", help="Enable voice interaction (True/False).")
+    options_group.add_argument("-g", "--guidelines", nargs='?', const=True, default=None, help="Prepend guidelines to the context.")
+
+    args = parser.parse_args()
+
+    try:
+        scopes = load_from_py_file(scopes_file_path, "scopes")
+    except FileNotFoundError:
+        scopes = {}
+        if not any([args.list_scopes, args.show_scope, args.add_scope, args.init, len(sys.argv) == 1]):
+             console.print(f"⚠️  Scope file '{scopes_file_path}' not found. You can create one with --init.", style="yellow")
+    except Exception as e:
+        console.print(f"❌ Error loading scopes file: {e}", style="red")
+        return
+
+    try:
+        recipes = load_from_py_file(recipes_file_path, "recipes")
+    except FileNotFoundError:
+        recipes = {}
+        if args.recipe:
+            console.print(f"⚠️  Recipes file '{recipes_file_path}' not found.", style="yellow")
+    except Exception as e:
+        console.print(f"❌ Error loading recipes file: {e}", style="red")
+        return
+
+    # If no arguments are provided (or the deprecated --chat is used), start the agentic TUI.
+    if len(sys.argv) == 1 or args.chat:
+        from ..tui.interface import run_tui
+        run_tui(args, scopes, recipes, scopes_file_path)
+        return
+
+    if args.init:
+        handle_init(scopes_file_path)
+        return
+
+    if any([args.list_scopes, args.show_scope, args.add_scope, args.remove_scope, args.update_scope]):
+        handle_scope_management(args, scopes, scopes_file_path, parser)
+        return
+        
+    if any([args.from_file, args.from_clipboard]):
+        handle_file_io(args)
+        return
+
+    if args.voice.lower() == 'true':
+        handle_voice_flow(args, scopes, parser)
+        return
+
+    # Fallback to the original, non-interactive workflow for other flags.
+    handle_main_task_flow(args, scopes, recipes, parser)

patchllm/cli/handlers.py

@@ -0,0 +1,192 @@
+import pprint
+import ast
+import textwrap
+import re
+import argparse
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+
+from ..utils import write_scopes_to_file
+from ..parser import paste_response
+from ..patcher import apply_external_patch
+from ..scopes.builder import build_context_from_files, helpers
+from ..llm import run_llm_query
+from .helpers import get_system_prompt, _collect_context
+
+console = Console()
+
+def handle_init(scopes_file_path):
+    if Path(scopes_file_path).exists():
+        console.print(f"⚠️  '{scopes_file_path}' already exists. Aborting.", style="yellow")
+        return
+    default_scopes = {"base": {"path": ".", "include_patterns": ["**/*"], "exclude_patterns": []}}
+    write_scopes_to_file(scopes_file_path, default_scopes)
+    console.print(f"✅ Successfully created '{scopes_file_path}'.", style="green")
+
+def handle_scope_management(args, scopes, scopes_file_path, parser):
+    """Handles all commands related to managing scopes."""
+    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.")
+        else:
+            for scope_name in sorted(scopes.keys()):
+                console.print(f"  - {scope_name}")
+
+    elif args.show_scope:
+        scope_data = scopes.get(args.show_scope)
+        if scope_data:
+            console.print(Panel(pprint.pformat(scope_data, indent=2), title=f"[bold cyan]Scope: '{args.show_scope}'[/]"))
+        else:
+            console.print(f"❌ Scope '[bold]{args.show_scope}[/]' not found.", style="red")
+
+    elif args.add_scope:
+        if args.add_scope in scopes:
+            console.print(f"❌ Scope '[bold]{args.add_scope}[/]' already exists.", style="red")
+            return
+        scopes[args.add_scope] = {"path": ".", "include_patterns": ["**/*"], "exclude_patterns": []}
+        write_scopes_to_file(scopes_file_path, scopes)
+        console.print(f"✅ Scope '[bold]{args.add_scope}[/]' added.", style="green")
+
+
+    elif args.remove_scope:
+        if args.remove_scope not in scopes:
+            console.print(f"❌ Scope '[bold]{args.remove_scope}[/]' not found.", style="red")
+            return
+        del scopes[args.remove_scope]
+        write_scopes_to_file(scopes_file_path, scopes)
+        console.print(f"✅ Scope '[bold]{args.remove_scope}[/]' removed.", style="green")
+
+    elif args.update_scope:
+        if len(args.update_scope) < 2:
+            parser.error("--update-scope requires a scope name and at least one 'key=value' pair.")
+        scope_name = args.update_scope[0]
+        updates = args.update_scope[1:]
+        if scope_name not in scopes:
+            console.print(f"❌ Scope '[bold]{scope_name}[/]' not found.", style="red")
+            return
+        try:
+            for update in updates:
+                key, value_str = update.split('=', 1)
+                value = ast.literal_eval(value_str)
+                scopes[scope_name][key.strip()] = value
+            write_scopes_to_file(scopes_file_path, scopes)
+        except (ValueError, SyntaxError) as e:
+            console.print(f"❌ Error parsing update values: {e}", style="red")
+
+def handle_file_io(args):
+    """Handles commands that read from files or clipboard to apply patches."""
+    content_to_patch = None
+    if args.from_clipboard:
+        try:
+            import pyperclip
+            content_to_patch = pyperclip.paste()
+            if not content_to_patch:
+                console.print("⚠️ Clipboard is empty.", style="yellow")
+                return
+        except ImportError:
+            console.print("❌ 'pyperclip' is required. `pip install pyperclip`", style="red")
+            return
+    elif args.from_file:
+        try:
+            content_to_patch = Path(args.from_file).read_text(encoding="utf-8")
+        except Exception as e:
+            console.print(f"❌ Failed to read from file {args.from_file}: {e}", style="red")
+            return
+
+    if content_to_patch:
+        base_path = Path(".").resolve()
+        apply_external_patch(content_to_patch, base_path)
+
+def handle_main_task_flow(args, scopes, recipes, parser):
+    """Handles the primary workflow of building context and querying the LLM."""
+    system_prompt = get_system_prompt()
+    history = [{"role": "system", "content": system_prompt}]
+    
+    task = args.task
+    if args.recipe:
+        if args.task:
+            console.print(f"⚠️ Both --task and --recipe provided. Using explicit --task.", style="yellow")
+        else:
+            task = recipes.get(args.recipe)
+            if not task:
+                parser.error(f"Recipe '{args.recipe}' not found in recipes file.")
+
+    context = None
+    if args.context_in:
+        context = Path(args.context_in).read_text()
+    else:
+        context_object = _collect_context(args, scopes)
+        context = context_object.get("context") if context_object else None
+        if context is None and not args.guidelines:
+             if any([args.scope, args.interactive]):
+                 return
+             if task:
+                 parser.error("A scope (-s), interactive (-in), or context-in (-ci) is required for a task or recipe.")
+
+    if args.guidelines:
+        guidelines_content = system_prompt if args.guidelines is True else args.guidelines
+        context = f"{guidelines_content}\n\n{context}" if context else guidelines_content
+
+    if args.context_out and context:
+        Path(args.context_out).write_text(context)
+
+    if task:
+        action_flags = [args.patch, args.to_file is not None, args.to_clipboard]
+        if sum(action_flags) > 1:
+            parser.error("Please specify only one action: --patch, --to-file, or --to-clipboard.")
+        if sum(action_flags) == 0:
+            parser.error("A task or recipe was provided, but no action was specified (e.g., --patch).")
+
+        if not context:
+            console.print("Proceeding with task but without any file context.", style="yellow")
+
+        llm_response = run_llm_query(task, args.model, history, context)
+        
+        if llm_response:
+            if args.patch:
+                paste_response(llm_response)
+            elif args.to_file is not None:
+                Path(args.to_file).write_text(llm_response)
+            elif args.to_clipboard:
+                try:
+                    import pyperclip
+                    pyperclip.copy(llm_response)
+                    console.print("✅ Copied to clipboard.", style="green")
+                except ImportError:
+                    console.print("❌ 'pyperclip' is required. `pip install pyperclip`", style="red")
+
+def handle_voice_flow(args, scopes, parser):
+    """Handles the voice-activated workflow."""
+    try:
+        from ..voice.listener import listen, speak
+    except ImportError:
+        console.print("❌ Voice dependencies are not installed.", style="red")
+        console.print("   Install with: pip install 'patchllm[voice]'", style="cyan")
+        return
+
+    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_object = _collect_context(args, scopes)
+        context = context_object.get("context") if context_object else None
+        if context is None:
+            speak("Context building failed. Exiting.")
+            return
+
+        system_prompt = get_system_prompt()
+        history = [{"role": "system", "content": system_prompt}]
+        
+        llm_response = run_llm_query(task, args.model, history, context)
+        if llm_response:
+            paste_response(llm_response)
+            speak("Changes applied.")
+    else:
+        speak("Cancelled.")

patchllm/cli/helpers.py

@@ -0,0 +1,72 @@
+import textwrap
+from pathlib import Path
+from rich.console import Console
+
+from ..scopes.builder import build_context, build_context_from_files
+
+console = Console()
+
+def get_system_prompt():
+    """Returns the system prompt for the LLM."""
+    return 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:
+        1. Before providing any file blocks, you MUST include a `<change_summary>` block. This block should contain a brief, high-level, natural language explanation of the changes you are about to make. Do not describe the changes file-by-file in this summary.
+        2. Your output should contain one or more file blocks. For each file-block:
+           a. Only include code for files that need to be updated / edited.
+           b. 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.
+           c. Do not include verbose inline comments explaining what every small change does. Try to keep comments concise but informative, if any.
+           d. 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.
+           e. Do not use diffs.
+        3. Make sure each file-block is returned in the following exact format. No additional text, comments, or explanations should be outside these blocks.
+        
+        Example of a complete and valid response:
+        <change_summary>
+        I will add a new `GET /health` endpoint to the main application file to provide a simple health check. I will also add a new test case to verify that this endpoint returns a 200 OK status.
+        </change_summary>
+        <file_path:/absolute/path/to/your/app.py>
+        ```python
+        # The full, complete content of /absolute/path/to/your/app.py goes here.
+        app = Flask(__name__)
+
+        @app.route('/health')
+        def health_check():
+            return "OK", 200
+        ```
+        <file_path:/absolute/path/to/your/test_app.py>
+        ```python
+        # The full, complete content of /absolute/path/to/your/test_app.py goes here.
+        def test_health_check(client):
+            response = client.get('/health')
+            assert response.status_code == 200
+        ```
+    """)
+
+def _collect_context(args, scopes):
+    """Helper to determine and build the context from args."""
+    base_path = Path(".").resolve()
+    context_object = None
+
+    if args.interactive:
+        try:
+            from ..interactive.selector import select_files_interactively
+            selected_files = select_files_interactively(base_path)
+            if selected_files:
+                context_object = build_context_from_files(selected_files, base_path)
+        except ImportError:
+            console.print("❌ 'InquirerPy' is required for interactive mode.", style="red")
+            console.print("   Install it with: pip install 'patchllm[interactive]'", style="cyan")
+            return None
+    elif args.scope:
+        context_object = build_context(args.scope, scopes, base_path)
+
+    if context_object:
+        tree = context_object.get("tree", "")
+        console.print("\n--- Context Summary ---", style="bold")
+        console.print(tree)
+        
+        return context_object
+    
+    if any([args.interactive, args.scope]):
+        console.print("--- Context building failed or returned no files. ---", style="yellow")
+    return None

patchllm/interactive/selector.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+from InquirerPy import prompt
+from InquirerPy.validator import EmptyInputValidator
+from rich.console import Console
+import re
+
+from ..scopes.constants import DEFAULT_EXCLUDE_EXTENSIONS, STRUCTURE_EXCLUDE_DIRS
+
+console = Console()
+
+def _build_choices_recursively(current_path: Path, base_path: Path, indent: str = "") -> list[str]:
+    """
+    Recursively builds a list of formatted strings representing files and folders
+    for the InquirerPy checklist, creating a visual tree structure.
+    """
+    choices = []
+    
+    try:
+        items_to_process = [p for p in current_path.iterdir() if p.name not in STRUCTURE_EXCLUDE_DIRS]
+        sorted_items = sorted(items_to_process, key=lambda p: (p.is_file(), p.name.lower()))
+    except FileNotFoundError:
+        return []
+
+    for i, item in enumerate(sorted_items):
+        is_last = i == len(sorted_items) - 1
+        connector = "└── " if is_last else "├── "
+        relative_item_path = item.relative_to(base_path)
+
+        if item.is_dir():
+            choices.append(f"{indent}{connector}📁 {relative_item_path}/")
+            new_indent = indent + ("    " if is_last else "│   ")
+            choices.extend(_build_choices_recursively(item, base_path, new_indent))
+        
+        elif item.is_file():
+            if item.suffix.lower() not in DEFAULT_EXCLUDE_EXTENSIONS:
+                choices.append(f"{indent}{connector}📄 {relative_item_path}")
+                
+    return choices
+
+def select_files_interactively(base_path: Path) -> list[Path]:
+    """
+    Displays an interactive checklist with a folder/file tree for the user to select from.
+    Returns a list of absolute paths for the selected files, expanding any selected folders.
+    """
+    choices = _build_choices_recursively(base_path, base_path)
+    if not choices:
+        console.print("No selectable files or folders found in this project.", style="yellow")
+        return []
+        
+    questions = [
+        {
+            "type": "fuzzy",
+            "name": "selected_items",
+            "message": "Fuzzy search and select files/folders for the context:",
+            "choices": choices,
+            "validate": EmptyInputValidator("You must select at least one item."),
+            "transformer": lambda result: f"{len(result)} item(s) selected",
+            "long_instruction": "Press <tab> or <ctrl+space> to select, <enter> to confirm.",
+            "border": True,
+            "cycle": False,
+            "multiselect": True,
+        }
+    ]
+    
+    try:
+        console.print("\n--- Interactive File Selection ---", style="bold")
+        result = prompt(questions, vi_mode=True)
+        
+        selected_choices = result.get("selected_items") if result else []
+        if not selected_choices:
+            return []
+
+        path_extraction_pattern = re.compile(r"[📁📄]\s(.*)")
+        
+        selected_paths_str = []
+        for selection in selected_choices:
+            match = path_extraction_pattern.search(selection)
+            if match:
+                selected_paths_str.append(match.group(1).rstrip('/'))
+        
+        final_files = set()
+        
+        for path_str in selected_paths_str:
+            full_path = (base_path / path_str).resolve()
+            
+            if full_path.is_dir():
+                for file_in_dir in full_path.rglob('*'):
+                    if file_in_dir.is_file() and file_in_dir.suffix.lower() not in DEFAULT_EXCLUDE_EXTENSIONS:
+                        final_files.add(file_in_dir)
+            elif full_path.is_file():
+                final_files.add(full_path)
+                
+        return sorted(list(final_files))
+
+    except KeyboardInterrupt:
+        console.print("\nSelection cancelled by user.", style="yellow")
+        return []
+    except Exception as e:
+        console.print(f"An error occurred during interactive selection: {e}", style="red")
+        return []

patchllm/llm.py

@@ -0,0 +1,39 @@
+import litellm
+from rich.console import Console
+
+console = Console()
+
+def run_llm_query(messages: list[dict], model_name: str) -> str | None:
+    """
+    Sends a list of messages to the LLM and returns the response.
+    This function is stateless and does not modify any history object.
+
+    Args:
+        messages (list[dict]): The full list of messages for the API call.
+        model_name (str): The name of the model to query.
+
+    Returns:
+        The text content of the assistant's response, or None if an error occurs.
+    """
+    console.print("\n--- Sending Prompt to LLM... ---", style="bold")
+    
+    try:
+        # Using litellm's built-in retry and timeout features.
+        # This helps prevent getting stuck if the connection drops.
+        response = litellm.completion(
+            model=model_name, 
+            messages=messages,
+            timeout=120,  # 120-second timeout for the API call
+            max_retries=3  # Retry up to 3 times on failure
+        )
+        
+        assistant_response = response.choices[0].message.content
+        if not assistant_response or not assistant_response.strip():
+            console.print("⚠️  Response is empty.", style="yellow")
+            return None
+        
+        return assistant_response
+    except Exception as e:
+        # Using rich.print to handle complex exception objects better
+        console.print(f"❌ LLM communication error after retries: {e}", style="bold red")
+        return None