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

patchllm/scopes/constants.py

@@ -0,0 +1,70 @@
+import re
+import textwrap
+
+# --- Constants for File Exclusion ---
+
+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
+    ".mp3", ".mp4", ".mov", ".avi", ".pdf",
+    ".o", ".so", ".dll", ".exe",
+    # Unity specific
+    ".meta",
+]
+
+STRUCTURE_EXCLUDE_DIRS = ['.git', '__pycache__', 'node_modules', '.venv', 'dist', 'build']
+
+# --- Templates ---
+
+BASE_TEMPLATE = textwrap.dedent('''
+    Source Tree:
+    ------------
+    ```
+    {{source_tree}}
+    ```
+    {{url_contents}}
+    Relevant Files:
+    ---------------
+    {{files_content}}
+''')
+
+URL_CONTENT_TEMPLATE = textwrap.dedent('''
+    URL Contents:
+    -------------
+    {{content}}
+''')
+
+STRUCTURE_TEMPLATE = textwrap.dedent('''
+    Project Structure Outline:
+    --------------------------
+    {{structure_content}}
+''')
+
+# --- Language Patterns for @structure ---
+
+LANGUAGE_PATTERNS = {
+    'python': {
+        'extensions': ['.py'],
+        'patterns': [
+            ('imports', re.compile(r"^\s*(?:from\s+[\w\.]+\s+)?import\s+[\w\.\*,\s\(\)]+")),
+            ('class', re.compile(r"^\s*class\s+.*?:")),
+            ('function', re.compile(r"^\s*(?:async\s+)?def\s+.*?\(.*?\).*?:")),
+        ]
+    },
+    'javascript': {
+        'extensions': ['.js', '.jsx', '.ts', '.tsx'],
+        'patterns': [
+            ('imports', re.compile(r"^\s*import\s+.*from\s+.*|^\s*(?:const|let|var)\s+.*?=\s*require\(.*")),
+            ('class', re.compile(r"^\s*(?:export\s+)?class\s+\w+.*\{.*\}")),
+            # --- FIX: Modified regex to capture the entire line for single-line functions ---
+            ('function', re.compile(r"^\s*(?:export\s+)?(?:async\s+)?function\s+\w+\(.*\)\s*\{.*|^\s*(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async)?\s*\(.*\)\s*=>\s*\{?.*")),
+        ]
+    }
+}

patchllm/scopes/helpers.py

@@ -0,0 +1,147 @@
+import glob
+import textwrap
+import subprocess
+import shutil
+from pathlib import Path
+from rich.console import Console
+import base64
+import mimetypes
+
+from .constants import BASE_TEMPLATE, URL_CONTENT_TEMPLATE
+
+console = Console()
+
+SUPPORTED_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
+
+def find_files(base_path: Path, include_patterns: list[str], exclude_patterns: list[str] = None) -> list[Path]:
+    """Finds all files using glob patterns."""
+    exclude_patterns = exclude_patterns or []
+    included_files = set()
+    for pattern in include_patterns:
+        search_path = base_path / pattern
+        for match in glob.glob(str(search_path), recursive=True):
+            path_obj = Path(match)
+            if path_obj.is_file():
+                included_files.add(path_obj.resolve())
+
+    excluded_files = set()
+    for pattern in exclude_patterns:
+        search_path = base_path / pattern
+        for match in glob.glob(str(search_path), recursive=True):
+            path_obj = Path(match)
+            if path_obj.is_file():
+                excluded_files.add(path_obj.resolve())
+    
+    return sorted(list(included_files - excluded_files))
+
+def filter_files_by_keyword(file_paths: list[Path], search_words: list[str]) -> list[Path]:
+    """Returns files that contain any of the search words."""
+    if not search_words:
+        return file_paths
+    matching_files = []
+    for file_path in file_paths:
+        try:
+            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:
+            pass
+    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."""
+    tree = {}
+    for path in file_paths:
+        try:
+            rel_path = path.relative_to(base_path)
+            level = tree
+            for part in rel_path.parts:
+                level = level.setdefault(part, {})
+        except ValueError:
+            continue
+
+    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):
+            connector = "└── " if i == len(items) - 1 else "├── "
+            lines.append(f"{indent}{connector}{name}")
+            if node:
+                new_indent = indent + ("    " if i == len(items) - 1 else "│   ")
+                lines.extend(_format_tree(node, new_indent))
+        return lines
+
+    return f"{base_path.name}\n" + "\n".join(_format_tree(tree))
+
+def _format_context(file_paths: list[Path], urls: list[str], base_path: Path) -> dict | None:
+    """Helper to format the final context string and preserve the file list."""
+    source_tree_str = generate_source_tree(base_path, file_paths)
+    file_contents = []
+    image_files_data = []
+
+    for file_path in file_paths:
+        if file_path.suffix.lower() in SUPPORTED_IMAGE_EXTENSIONS:
+            try:
+                mime_type, _ = mimetypes.guess_type(file_path)
+                if mime_type and mime_type.startswith('image/'):
+                    with open(file_path, "rb") as f:
+                        content_base64 = base64.b64encode(f.read()).decode('utf-8')
+                    image_files_data.append({
+                        "path": file_path,
+                        "mime_type": mime_type,
+                        "content_base64": content_base64
+                    })
+            except Exception as e:
+                console.print(f"⚠️  Could not process image file {file_path}: {e}", style="yellow")
+        else:
+            try:
+                content = file_path.read_text(encoding='utf-8', errors='ignore')
+                file_contents.append(f"<file_path:{file_path.as_posix()}>\n```\n{content}\n```")
+            except Exception as e:
+                console.print(f"⚠️  Could not read file {file_path}: {e}", style="yellow")
+
+    files_content_str = "\n\n".join(file_contents)
+    url_contents_str = fetch_and_process_urls(urls)
+
+    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)
+    
+    # --- CORRECTION: Return the original, pristine list of Path objects ---
+    return {
+        "tree": source_tree_str,
+        "context": final_context,
+        "files": file_paths,
+        "images": image_files_data
+    }
+
+def fetch_and_process_urls(urls: list[str]) -> str:
+    """Downloads and converts a list of URLs to text."""
+    if not urls: return ""
+    try:
+        import html2text
+    except ImportError:
+        console.print("⚠️  'html2text' is required. Install with: pip install 'patchllm[url]'", style="yellow")
+        return ""
+
+    downloader = "curl" if shutil.which("curl") else "wget" if shutil.which("wget") else None
+    if not downloader:
+        console.print("⚠️ 'curl' or 'wget' not found.", style="yellow")
+        return ""
+
+    h = html2text.HTML2Text()
+    h.ignore_links = True
+    h.ignore_images = True
+    all_url_contents = []
+
+    for url in urls:
+        try:
+            command = ["curl", "-s", "-L", url] if downloader == "curl" else ["wget", "-q", "-O", "-", url]
+            result = subprocess.run(command, capture_output=True, text=True, check=True, timeout=15)
+            text_content = h.handle(result.stdout)
+            all_url_contents.append(f"<url_content:{url}>\n```\n{text_content}\n```")
+        except Exception as e:
+            console.print(f"❌ Failed to fetch {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)

patchllm/scopes/resolvers.py

@@ -0,0 +1,82 @@
+import subprocess
+from pathlib import Path
+import re
+import os
+from rich.console import Console
+
+console = Console()
+
+def _run_git_command(command: list[str], base_path: Path) -> list[Path]:
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True, cwd=base_path)
+        files = result.stdout.strip().split('\n')
+        return [base_path / f for f in files if f]
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return []
+
+def resolve_dynamic_scope(scope_name: str, base_path: Path) -> list[Path]:
+    """Resolves a dynamic scope string to a list of file paths."""
+    if scope_name.startswith('@error:"') and scope_name.endswith('"'):
+        traceback = scope_name[len('@error:"'):-1]
+        pattern = r'File "([^"]+)"'
+        matches = re.findall(pattern, traceback)
+        return sorted([Path(f).resolve() for f in matches if Path(f).exists()])
+
+    search_match = re.match(r'@search:"([^"]+)"', scope_name)
+    if search_match:
+        from .helpers import find_files, filter_files_by_keyword
+        all_files = find_files(base_path, ["**/*"])
+        return filter_files_by_keyword(all_files, [search_match.group(1)])
+
+    related_match = re.match(r'@related:(.+)', scope_name)
+    if related_match:
+        start_path = (base_path / related_match.group(1).strip()).resolve()
+        if not start_path.exists(): 
+            return []
+        related_files = {start_path}
+        stem = start_path.stem
+        test_variations = [
+            start_path.parent / f"test_{stem}{start_path.suffix}",
+            base_path / "tests" / f"test_{stem}{start_path.suffix}",
+            start_path.parent.parent / "tests" / start_path.parent.name / f"test_{stem}{start_path.suffix}"
+        ]
+        for path in test_variations:
+            if path.exists():
+                related_files.add(path)
+        sibling_exts = ['.css', '.js', '.html', '.scss', '.py', '.md']
+        for ext in sibling_exts:
+            if ext != start_path.suffix:
+                sibling_path = start_path.with_suffix(ext)
+                if sibling_path.exists():
+                    related_files.add(sibling_path)
+        return sorted(list(related_files))
+
+    dir_match = re.match(r'@dir:(.+)', scope_name)
+    if dir_match:
+        dir_path = (base_path / dir_match.group(1).strip()).resolve()
+        if not dir_path.is_dir(): return []
+        return sorted([f for f in dir_path.iterdir() if f.is_file()])
+
+    branch_match = re.match(r'@git:branch(?::(.+))?', scope_name)
+    if branch_match:
+        base_branch = branch_match.group(1) or os.environ.get("GIT_BASE_BRANCH", "main")
+        return _run_git_command(["git", "diff", "--name-only", f"{base_branch}...HEAD"], base_path)
+
+    git_commands = {
+        "@git": ["git", "diff", "--name-only", "--cached"],
+        "@git:staged": ["git", "diff", "--name-only", "--cached"],
+        "@git:unstaged": ["git", "diff", "--name-only"],
+        "@git:lastcommit": ["git", "show", "--pretty=format:", "--name-only", "HEAD"],
+        "@git:conflicts": ["git", "diff", "--name-only", "--diff-filter=U"],
+    }
+    if scope_name in git_commands:
+        return _run_git_command(git_commands[scope_name], base_path)
+
+    if scope_name == "@recent":
+        all_files = filter(Path.is_file, base_path.rglob('*'))
+        excluded_dirs = ['.git', '__pycache__', 'node_modules', '.venv']
+        filtered_files = [p for p in all_files if not any(excluded in p.parts for excluded in excluded_dirs)]
+        return sorted(filtered_files, key=lambda p: p.stat().st_mtime, reverse=True)[:5]
+
+    console.print(f"❌ Unknown or invalid dynamic scope '{scope_name}'.", style="red")
+    return []

patchllm/scopes/structure.py

@@ -0,0 +1,64 @@
+import re
+from pathlib import Path
+from rich.console import Console
+
+# --- FIX: Removed the unnecessary import that was causing the circular dependency ---
+# from patchllm.scopes.builder import build_context 
+
+from .constants import (
+    STRUCTURE_EXCLUDE_DIRS, 
+    DEFAULT_EXCLUDE_EXTENSIONS,
+    LANGUAGE_PATTERNS,
+    STRUCTURE_TEMPLATE
+)
+
+console = Console()
+
+def _extract_symbols_by_regex(content: str, lang_patterns: list) -> dict:
+    symbols = {"imports": [], "class": [], "function": []}
+    for line in content.splitlines():
+        for symbol_type, pattern in lang_patterns:
+            match = pattern.match(line)
+            if match:
+                symbols[symbol_type].append(match.group(0).strip())
+                break
+    return symbols
+
+def _build_structure_context(base_path: Path) -> dict | None:
+    """Builds a context by extracting symbols from all project files."""
+    all_files = []
+    for p in base_path.rglob('*'):
+        if any(part in STRUCTURE_EXCLUDE_DIRS for part in p.parts):
+            continue
+        if p.is_file() and p.suffix.lower() not in DEFAULT_EXCLUDE_EXTENSIONS:
+            all_files.append(p)
+    
+    structure_outputs = []
+    for file_path in sorted(all_files):
+        lang = None
+        for lang_name, config in LANGUAGE_PATTERNS.items():
+            if file_path.suffix in config['extensions']:
+                lang = lang_name
+                break
+        if lang:
+            try:
+                content = file_path.read_text(encoding='utf-8', errors='ignore')
+                symbols = _extract_symbols_by_regex(content, LANGUAGE_PATTERNS[lang]['patterns'])
+                if any(symbols.values()):
+                    rel_path = file_path.relative_to(base_path)
+                    output = [f"<file_path:{rel_path.as_posix()}>"]
+                    if symbols['imports']:
+                        output.append("[imports]")
+                        output.extend([f"- {s}" for s in symbols['imports']])
+                    if symbols['class'] or symbols['function']:
+                         output.append("[symbols]")
+                         output.extend([f"- {s}" for s in symbols['class']])
+                         output.extend([f"- {s}" for s in symbols['function']])
+                    structure_outputs.append("\n".join(output))
+            except Exception as e:
+                console.print(f"⚠️ Could not process {file_path}: {e}", style="yellow")
+
+    if not structure_outputs: return None
+    final_content = "\n\n".join(structure_outputs)
+    final_context = STRUCTURE_TEMPLATE.replace("{{structure_content}}", final_content)
+    return {"tree": "Project structure view", "context": final_context}

patchllm/tui/completer.py

@@ -0,0 +1,153 @@
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+# A structured definition for all commands, including their display name,
+# description, and the states in which they are available.
+COMMAND_DEFINITIONS = [
+    # Agent Workflow
+    {"command": "/approve", "display": "agent - approve changes", "meta": "Applies the changes from the last run.", "states": ["has_pending_changes"]},
+    {"command": "/diff", "display": "agent - view diff", "meta": "Shows the full diff for the proposed changes.", "states": ["has_pending_changes"]},
+    {"command": "/retry", "display": "agent - retry with feedback", "meta": "Retries the last step with new feedback.", "states": ["has_pending_changes"]},
+    {"command": "/revert", "display": "agent - revert last approval", "meta": "Reverts the changes from the last /approve.", "states": ["can_revert"]},
+    {"command": "/run", "display": "agent - run step", "meta": "Executes the next step. Use '/run all' for all steps.", "states": ["has_plan"]},
+    {"command": "/skip", "display": "agent - skip step", "meta": "Skips the current step and moves to the next.", "states": ["has_plan"]},
+    # Context Management
+    {"command": "/context", "display": "context - set context", "meta": "Replaces the context with files from a scope.", "states": ["initial", "has_goal", "has_plan"]},
+    {"command": "/scopes", "display": "context - manage scopes", "meta": "Opens an interactive menu to manage your saved scopes.", "states": ["initial", "has_goal", "has_plan"]},
+    # Planning Workflow
+    {"command": "/ask", "display": "agent - ask question", "meta": "Ask a question about the plan or code context.", "states": ["has_goal", "has_plan", "has_context"]},
+    {"command": "/plan", "display": "plan - generate or manage", "meta": "Generates a plan or manages the existing one.", "states": ["has_goal", "has_plan"]},
+    {"command": "/refine", "display": "plan - refine with feedback", "meta": "Refine the plan based on new feedback or ideas.", "states": ["has_plan"]},
+    # Task Management
+    {"command": "/task", "display": "task - set goal", "meta": "Sets the high-level goal for the agent.", "states": ["initial", "has_goal", "has_plan"]},
+    # Menu / Session Management
+    {"command": "/exit", "display": "menu - exit session", "meta": "Exits the agent session.", "states": ["initial", "has_goal", "has_plan"]},
+    {"command": "/help", "display": "menu - help", "meta": "Shows the detailed help message.", "states": ["initial", "has_goal", "has_plan"]},
+    {"command": "/show", "display": "menu - show state", "meta": "Shows the current goal, plan, context, history, or step.", "states": ["initial", "has_goal", "has_plan"]},
+    {"command": "/settings", "display": "menu - settings", "meta": "Configure the model and API keys.", "states": ["initial", "has_goal", "has_plan"]},
+]
+
+
+class PatchLLMCompleter(Completer):
+    """
+    A custom completer for prompt_toolkit that provides context-aware suggestions
+    for commands and scopes, including descriptive metadata.
+    """
+    def __init__(self, scopes: dict):
+        self.all_command_defs = sorted(COMMAND_DEFINITIONS, key=lambda x: x['display'])
+        self.scopes = scopes
+        self.static_scopes = sorted(list(scopes.keys()))
+        self.dynamic_scopes = [
+            "@git", "@git:staged", "@git:unstaged", "@git:lastcommit",
+            "@git:conflicts", "@git:branch:", "@recent", "@structure",
+            "@dir:", "@related:", "@search:", "@error:"
+        ]
+        self.all_scopes = sorted(self.static_scopes + self.dynamic_scopes)
+        self.plan_sub_commands = ['--edit ', '--rm ', '--add ']
+        self.show_sub_commands = ['goal', 'plan', 'context', 'history', 'step']
+        
+        # State flags
+        self.has_goal = False
+        self.has_plan = False
+        self.has_pending_changes = False
+        self.can_revert = False
+        self.has_context = False
+
+    def set_session_state(self, has_goal: bool, has_plan: bool, has_pending_changes: bool, can_revert: bool, has_context: bool):
+        """Updates the completer's state from the agent session."""
+        self.has_goal = has_goal
+        self.has_plan = has_plan
+        self.has_pending_changes = has_pending_changes
+        self.can_revert = can_revert
+        self.has_context = has_context
+
+    def get_completions(self, document: Document, complete_event):
+        """
+        Yields completions based on the current user input and agent state.
+        """
+        text = document.text_before_cursor
+        words = text.lstrip().split()
+        word_count = len(words)
+        
+        active_states = {"initial"}
+        if self.has_goal:
+            active_states.add("has_goal")
+        if self.has_plan:
+            active_states.add("has_plan")
+        if self.has_pending_changes:
+            active_states.add("has_pending_changes")
+        if self.can_revert:
+            active_states.add("can_revert")
+        if self.has_context:
+            active_states.add("has_context")
+
+        # Case 1: We are typing the first word (the command)
+        if word_count == 0 or (word_count == 1 and not text.endswith(' ')):
+            command_to_complete = words[0] if words else "/"
+            if command_to_complete.startswith('/'):
+                for definition in self.all_command_defs:
+                    is_valid_state = any(s in active_states for s in definition["states"])
+
+                    if is_valid_state and definition["command"].startswith(command_to_complete):
+                        yield Completion(
+                            definition["command"], 
+                            start_position=-len(command_to_complete),
+                            display=definition["display"],
+                            display_meta=definition["meta"]
+                        )
+            return
+
+        # Special Case: We are typing after /run
+        if words and words[0] == '/run':
+            if word_count == 1 and text.endswith(' '):
+                yield Completion("all", start_position=0, display_meta="Execute all remaining steps.")
+                return
+            if word_count == 2 and not text.endswith(' '):
+                if "all".startswith(words[1]):
+                     yield Completion("all", start_position=-len(words[1]), display_meta="Execute all remaining steps.")
+                return
+
+        # Case 2: We are in a "scope" context
+        if words and words[0] in ['/context']:
+            scope_to_complete = words[1] if word_count > 1 else ""
+            
+            if word_count == 1 and text.endswith(' '):
+                for scope in self.all_scopes:
+                    meta = "Static scope" if scope in self.static_scopes else "Dynamic scope"
+                    yield Completion(scope, start_position=0, display_meta=meta)
+                return
+            
+            if word_count == 2 and not text.endswith(' '):
+                for scope in self.all_scopes:
+                    if scope.startswith(scope_to_complete):
+                        meta = "Static scope" if scope in self.static_scopes else "Dynamic scope"
+                        yield Completion(scope, start_position=-len(scope_to_complete), display_meta=meta)
+                return
+
+        # Case 3: We are in a "plan" management context
+        if words and words[0] == '/plan':
+            if word_count == 1 and text.endswith(' '):
+                for sub_cmd in self.plan_sub_commands:
+                    yield Completion(sub_cmd, start_position=0)
+                return
+            
+            if word_count == 2 and not text.endswith(' '):
+                sub_cmd_to_complete = words[1]
+                for sub_cmd in self.plan_sub_commands:
+                    if sub_cmd.startswith(sub_cmd_to_complete):
+                        yield Completion(sub_cmd, start_position=-len(sub_cmd_to_complete))
+                return
+        
+        # Case 4: We are in a "show" context
+        if words and words[0] == '/show':
+            if word_count == 1 and text.endswith(' '):
+                for sub_cmd in self.show_sub_commands:
+                    yield Completion(sub_cmd, start_position=0)
+                return
+            
+            if word_count == 2 and not text.endswith(' '):
+                sub_cmd_to_complete = words[1]
+                for sub_cmd in self.show_sub_commands:
+                    if sub_cmd.startswith(sub_cmd_to_complete):
+                        yield Completion(sub_cmd, start_position=-len(sub_cmd_to_complete))
+                return