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

tests/test_executor.py

@@ -0,0 +1,60 @@
+import pytest
+from unittest.mock import patch
+from patchllm.agent.executor import execute_step
+
+@patch('patchllm.agent.executor.run_llm_query')
+def test_execute_step_with_text_only(mock_run_llm_query):
+    """Tests that execute_step sends a simple text prompt when no images are present."""
+    mock_run_llm_query.return_value = (
+        "<change_summary>Summary of changes.</change_summary>\n"
+        "<file_path:/a.txt>\n```\n...```"
+    )
+    
+    result = execute_step("test instruction", [], "test context", None, "gemini/gemini-1.5-flash")
+    
+    mock_run_llm_query.assert_called_once()
+    messages = mock_run_llm_query.call_args[0][0]
+    user_message = messages[-1]
+    
+    assert user_message["role"] == "user"
+    assert isinstance(user_message["content"], list)
+    assert len(user_message["content"]) == 1
+    assert user_message["content"][0]["type"] == "text"
+    assert "test instruction" in user_message["content"][0]["text"]
+    assert "test context" in user_message["content"][0]["text"]
+    
+    assert result is not None
+    assert result["change_summary"] == "Summary of changes."
+
+@patch('patchllm.agent.executor.run_llm_query')
+def test_execute_step_with_images(mock_run_llm_query):
+    """Tests that execute_step constructs a multimodal prompt when images are present."""
+    mock_run_llm_query.return_value = (
+        "<change_summary>Image-related changes.</change_summary>\n"
+        "<file_path:/a.txt>\n```\n...```"
+    )
+    
+    mock_image_data = [{
+        "mime_type": "image/png",
+        "content_base64": "base64string"
+    }]
+    
+    result = execute_step("test instruction", [], "test context", mock_image_data, "gemini/gemini-1.5-flash")
+    
+    mock_run_llm_query.assert_called_once()
+    messages = mock_run_llm_query.call_args[0][0]
+    user_message = messages[-1]
+    
+    assert user_message["role"] == "user"
+    assert isinstance(user_message["content"], list)
+    assert len(user_message["content"]) == 2 # 1 for text, 1 for image
+    
+    text_part = user_message["content"][0]
+    assert text_part["type"] == "text"
+    
+    image_part = user_message["content"][1]
+    assert image_part["type"] == "image_url"
+    assert image_part["image_url"]["url"] == "data:image/png;base64,base64string"
+
+    assert result is not None
+    assert result["change_summary"] == "Image-related changes."

tests/test_interactive.py

@@ -0,0 +1,64 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+import os
+import re
+
+pytest.importorskip("InquirerPy")
+
+from patchllm.cli.entrypoint import main
+from patchllm.interactive.selector import _build_choices_recursively
+
+def test_build_choices_recursively(temp_project):
+    choices = _build_choices_recursively(temp_project, temp_project)
+    path_extraction_pattern = re.compile(r"([📁📄]\s.*)")
+    plain_choices = set()
+    for choice in choices:
+        match = path_extraction_pattern.search(choice)
+        if match:
+            plain_choices.add(match.group(1).strip())
+
+    assert "📁 src/" in plain_choices
+    assert "📄 main.py" in plain_choices
+    assert "📄 src/component.js" in plain_choices
+    assert not any("data.log" in choice for choice in plain_choices)
+
+@patch('patchllm.interactive.selector.prompt', new_callable=MagicMock)
+def test_interactive_flag_flow_files_with_fuzzy(mock_prompt, temp_project):
+    selected_items = ['├── 📄 main.py', '│   └── 📄 src/styles.css']
+    mock_prompt.return_value = {"selected_items": selected_items}
+    
+    output_file = temp_project / "context_output.md"
+    original_cwd = os.getcwd()
+    os.chdir(temp_project)
+    try:
+        with patch('sys.argv', ['patchllm', '--interactive', '--context-out', str(output_file)]):
+            main()
+    finally:
+        os.chdir(original_cwd)
+        
+    assert output_file.exists()
+    content = output_file.read_text()
+    assert "<file_path:" + (temp_project / 'main.py').as_posix() in content
+    assert "<file_path:" + (temp_project / 'src/styles.css').as_posix() in content
+    assert "utils.py" not in content
+
+@patch('patchllm.interactive.selector.prompt', new_callable=MagicMock)
+def test_interactive_flag_flow_folder_with_fuzzy(mock_prompt, temp_project):
+    selected_items = ['└── 📁 src/']
+    mock_prompt.return_value = {"selected_items": selected_items}
+    
+    output_file = temp_project / "context_output.md"
+    original_cwd = os.getcwd()
+    os.chdir(temp_project)
+    try:
+        with patch('sys.argv', ['patchllm', '--interactive', '--context-out', str(output_file)]):
+            main()
+    finally:
+        os.chdir(original_cwd)
+        
+    assert output_file.exists()
+    content = output_file.read_text()
+    assert "<file_path:" + (temp_project / 'src/component.js').as_posix() in content
+    assert "<file_path:" + (temp_project / 'src/styles.css').as_posix() in content
+    assert "main.py" not in content

tests/test_parser.py

@@ -0,0 +1,70 @@
+from pathlib import Path
+from patchllm.parser import paste_response, summarize_changes, _parse_file_blocks, parse_change_summary
+
+def test_parse_file_blocks_simple():
+    response = "<file_path:/app/main.py>\n```python\nprint('hello')\n```"
+    result = _parse_file_blocks(response)
+    assert len(result) == 1
+    path, content = result[0]
+    assert path == Path("/app/main.py").resolve()
+    assert content == "print('hello')"
+
+def test_parse_change_summary():
+    """Tests that the change summary is correctly extracted."""
+    response_with_summary = (
+        "<change_summary>\nThis is the summary.\n</change_summary>\n"
+        "<file_path:/app/main.py>\n```python\nprint('hello')\n```"
+    )
+    summary = parse_change_summary(response_with_summary)
+    assert summary == "This is the summary."
+
+    response_no_summary = "<file_path:/app/main.py>\n```python\nprint('hello')\n```"
+    summary_none = parse_change_summary(response_no_summary)
+    assert summary_none is None
+
+def test_paste_response_updates_file(tmp_path):
+    file_path = tmp_path / "test.txt"
+    file_path.write_text("old content")
+    response = f"<file_path:{file_path.as_posix()}>\n```\nnew content\n```"
+    paste_response(response)
+    assert file_path.read_text() == "new content"
+
+def test_paste_response_skip_unchanged_file(tmp_path, capsys):
+    file_path = tmp_path / "unchanged.txt"
+    content = "no changes here"
+    file_path.write_text(content)
+    response = f"<file_path:{file_path.as_posix()}>\n```\n{content}\n```"
+    paste_response(response)
+    captured = capsys.readouterr()
+    # --- CORRECTION: The function now just updates, it doesn't "skip" ---
+    assert "Updated" in captured.out
+    assert file_path.read_text() == content
+
+def test_paste_response_create_in_new_directory(tmp_path):
+    new_dir = tmp_path / "new_dir"
+    new_file = new_dir / "file.txt"
+    content = "some text"
+    assert not new_dir.exists()
+    response = f"<file_path:{new_file.as_posix()}>\n```\n{content}\n```"
+    paste_response(response)
+    assert new_dir.is_dir()
+    assert new_file.read_text() == content
+
+def test_summarize_changes(tmp_path):
+    created_file = tmp_path / "new.txt"
+    modified_file = tmp_path / "old.txt"
+    modified_file.touch()
+    response = (
+        f"<file_path:{created_file.as_posix()}>\n```\ncontent\n```\n"
+        f"<file_path:{modified_file.as_posix()}>\n```\ncontent\n```"
+    )
+    summary = summarize_changes(response)
+    assert created_file.as_posix() in summary["created"]
+    assert modified_file.as_posix() in summary["modified"]
+
+def test_paste_response_no_matches(capsys):
+    response = "No valid file blocks."
+    paste_response(response)
+    captured = capsys.readouterr()
+    # --- CORRECTION: Update assertion to match new warning message ---
+    assert "Could not find any file blocks to apply" in captured.out

tests/test_patcher.py

@@ -0,0 +1,71 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+import subprocess
+import textwrap
+import shutil
+
+from patchllm.patcher import apply_external_patch
+
+patch_installed = shutil.which("patch") is not None
+
+@pytest.fixture
+def temp_project_for_patching(tmp_path):
+    proj = tmp_path / "patch_proj"
+    proj.mkdir()
+    (proj / "main.py").write_text("def hello():\n    print('old world')")
+    (proj / "utils.py").write_text("# Initial utility file")
+    
+    subprocess.run(["git", "init"], cwd=proj, check=True, capture_output=True)
+    subprocess.run(["git", "add", "."], cwd=proj, check=True, capture_output=True)
+    subprocess.run(["git", "commit", "-m", "initial"], cwd=proj, check=True, capture_output=True)
+    return proj
+
+@pytest.mark.skipif(not patch_installed, reason="The 'patch' command-line utility is not installed.")
+def test_apply_patch_with_diff_format(temp_project_for_patching):
+    diff_content = """--- a/main.py
++++ b/main.py
+@@ -1,2 +1,2 @@
+ def hello():
+-    print('old world')
++    print('new world')
+"""
+    
+    main_py = temp_project_for_patching / "main.py"
+    original_content = main_py.read_text()
+    
+    apply_external_patch(diff_content, temp_project_for_patching)
+    
+    new_content = main_py.read_text()
+    assert original_content != new_content
+    assert "print('new world')" in new_content
+
+def test_apply_patch_with_patchllm_format(temp_project_for_patching):
+    main_py = temp_project_for_patching / "main.py"
+    patchllm_content = f"<file_path:{main_py.as_posix()}>\n```python\ndef hello():\n    print('patched world')\n```"
+    
+    apply_external_patch(patchllm_content, temp_project_for_patching)
+    
+    assert "print('patched world')" in main_py.read_text()
+
+@patch('patchllm.patcher.prompt')
+def test_apply_patch_interactive_flow(mock_prompt, temp_project_for_patching):
+    mock_prompt.side_effect = [
+        {"file": "utils.py"},
+        {"confirm": True}
+    ]
+
+    ambiguous_content = textwrap.dedent("""
+        Sure, here is the code you requested for the utility file:
+        ```python
+        def new_utility_function():
+            return True
+        ```
+        I hope this helps!
+    """)
+    utils_py = temp_project_for_patching / "utils.py"
+    
+    apply_external_patch(ambiguous_content, temp_project_for_patching)
+
+    assert "def new_utility_function():" in utils_py.read_text()
+    assert mock_prompt.call_count == 2

tests/test_planner.py

@@ -0,0 +1,53 @@
+import pytest
+from unittest.mock import patch
+from patchllm.agent.planner import generate_plan_and_history, generate_refined_plan
+
+@patch('patchllm.agent.planner.run_llm_query')
+def test_generate_plan_and_history(mock_run_llm_query):
+    """
+    Tests that the planner returns the initial history and response correctly.
+    """
+    mock_llm_response = "1. First, modify the main.py file."
+    mock_run_llm_query.return_value = mock_llm_response
+    
+    history, response = generate_plan_and_history("some goal", "some tree", "mock-model")
+    
+    assert response == mock_llm_response
+    assert len(history) == 3 # System, User, Assistant
+    assert history[2]['role'] == 'assistant'
+    assert "## Goal:\nsome goal" in history[1]['content']
+    assert "## Project Structure:\n```\nsome tree\n```" in history[1]['content']
+
+@patch('patchllm.agent.planner.run_llm_query')
+def test_generate_refined_plan(mock_run_llm_query):
+    """
+    Tests that the refine function correctly constructs a prompt with history and feedback.
+    """
+    initial_history = [
+        {"role": "system", "content": "You are a planner."},
+        {"role": "user", "content": "My goal is X."},
+        {"role": "assistant", "content": "1. Do step 1."}
+    ]
+    feedback = "Actually, let's do step 2 first."
+
+    mock_run_llm_query.return_value = "1. Do step 2.\n2. Do step 1."
+    
+    generate_refined_plan(initial_history, feedback, "mock-model")
+
+    mock_run_llm_query.assert_called_once()
+    sent_messages = mock_run_llm_query.call_args[0][0]
+    
+    # The sent messages should be the full history plus the new user feedback/instruction
+    assert len(sent_messages) == 4
+    assert sent_messages[0]['role'] == 'system'
+    assert sent_messages[2]['content'] == "1. Do step 1."
+    assert "## User Feedback:\nActually, let's do step 2 first." in sent_messages[3]['content']
+
+@patch('patchllm.agent.planner.run_llm_query')
+def test_generate_plan_handles_no_response(mock_run_llm_query):
+    """
+    Tests that the planner returns None if the LLM gives an empty response.
+    """
+    mock_run_llm_query.return_value = None
+    _, response = generate_plan_and_history("goal", "tree", "model")
+    assert response is None

tests/test_recipes.py

@@ -0,0 +1,111 @@
+import pytest
+import subprocess
+import textwrap
+from pathlib import Path
+
+@pytest.fixture
+def temp_project(tmp_path):
+    """Creates a temporary project structure for testing."""
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+
+    (project_dir / "main.py").write_text("import utils\n\ndef hello():\n    print('hello')")
+    (project_dir / "utils.py").write_text("def helper_function():\n    return 1")
+    (project_dir / "README.md").write_text("# Test Project")
+
+    src_dir = project_dir / "src"
+    src_dir.mkdir()
+    (src_dir / "component.js").write_text("console.log('component');")
+    (src_dir / "styles.css").write_text("body { color: red; }")
+
+    tests_dir = project_dir / "tests"
+    tests_dir.mkdir()
+    (tests_dir / "test_utils.py").write_text("from .. import utils\n\ndef test_helper():\n    assert utils.helper_function() == 1")
+    
+    (project_dir / "data.log").write_text("some log data")
+
+    return project_dir
+
+@pytest.fixture
+def git_project(temp_project):
+    """Initializes the temp_project as a Git repository."""
+    subprocess.run(["git", "init"], cwd=temp_project, check=True, capture_output=True)
+    subprocess.run(["git", "config", "user.name", "Test User"], cwd=temp_project, check=True)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=temp_project, check=True)
+    subprocess.run(["git", "add", "."], cwd=temp_project, check=True)
+    subprocess.run(["git", "commit", "-m", "Initial commit"], cwd=temp_project, check=True, capture_output=True)
+    return temp_project
+
+@pytest.fixture
+def temp_scopes_file(tmp_path):
+    """Creates a temporary scopes.py file for testing."""
+    scopes_content = """
+scopes = {
+    'base': {
+        'path': '.',
+        'include_patterns': ['**/*.py'],
+        'exclude_patterns': ['tests/**'],
+    },
+    'search_scope': {
+        'path': '.',
+        'include_patterns': ['**/*'],
+        'search_words': ['hello']
+    },
+    'js_and_css': {
+        'path': 'src',
+        'include_patterns': ['**/*.js', '**/*.css']
+    }
+}
+"""
+    scopes_file = tmp_path / "scopes.py"
+    scopes_file.write_text(scopes_content)
+    return scopes_file
+
+@pytest.fixture
+def temp_recipes_file(tmp_path):
+    """Creates a temporary recipes.py file for testing."""
+    recipes_content = """
+recipes = {
+    "add_tests": "Please write comprehensive pytest unit tests for the functions in the provided file.",
+    "add_docs": "Generate Google-style docstrings for all public functions and classes.",
+}
+"""
+    recipes_file = tmp_path / "recipes.py"
+    recipes_file.write_text(recipes_content)
+    return recipes_file
+
+@pytest.fixture
+def mixed_project(tmp_path):
+    """Creates a project with both Python and JS files for structure testing."""
+    proj_dir = tmp_path / "mixed_project"
+    
+    py_api_dir = proj_dir / "api"
+    py_api_dir.mkdir(parents=True)
+    (py_api_dir / "main.py").write_text(textwrap.dedent("""
+        import os
+        from .models import User
+        class APIServer:
+            def start(self): pass
+        async def get_user(id: int) -> User:
+            # A comment
+            return User()
+        """))
+    (py_api_dir / "models.py").write_text(textwrap.dedent("""
+        from db import Base
+        class User(Base): pass
+        """))
+
+    js_src_dir = proj_dir / "frontend" / "src"
+    js_src_dir.mkdir(parents=True)
+    (js_src_dir / "index.js").write_text(textwrap.dedent("""
+        import React from "react";
+        export class App extends React.Component { render() { return <h1>Hello</h1>; } }
+        export const arrowFunc = () => { console.log('test'); }
+        """))
+    (js_src_dir / "utils.ts").write_text(textwrap.dedent("""
+        export async function fetchData(url: string): Promise<any> { }
+        """))
+    
+    (proj_dir / "README.md").write_text("# Mixed Project")
+
+    return proj_dir

tests/test_scopes.py

@@ -0,0 +1,47 @@
+import pytest
+from unittest.mock import patch
+from patchllm.cli.entrypoint import main
+from patchllm.utils import load_from_py_file, write_scopes_to_file
+
+def run_main_with_args(args, expect_exit=False):
+    with patch('sys.argv', ['patchllm'] + args):
+        if expect_exit:
+            with pytest.raises(SystemExit):
+                main()
+        else:
+            main()
+
+def test_add_scope(tmp_path):
+    scopes_file = tmp_path / "scopes.py"
+    write_scopes_to_file(scopes_file, {})
+    with patch.dict('os.environ', {'PATCHLLM_SCOPES_FILE': scopes_file.as_posix()}):
+        run_main_with_args(["--add-scope", "new_scope"])
+    scopes = load_from_py_file(scopes_file, "scopes")
+    assert "new_scope" in scopes
+    assert scopes["new_scope"]["path"] == "."
+
+def test_remove_scope(temp_scopes_file):
+    scopes_before = load_from_py_file(temp_scopes_file, "scopes")
+    assert "base" in scopes_before
+    with patch.dict('os.environ', {'PATCHLLM_SCOPES_FILE': temp_scopes_file.as_posix()}):
+        run_main_with_args(["--remove-scope", "base"])
+    scopes_after = load_from_py_file(temp_scopes_file, "scopes")
+    assert "base" not in scopes_after
+
+def test_update_scope(temp_scopes_file):
+    with patch.dict('os.environ', {'PATCHLLM_SCOPES_FILE': temp_scopes_file.as_posix()}):
+        run_main_with_args(["--update-scope", "base", "path='/new/path'"])
+    scopes = load_from_py_file(temp_scopes_file, "scopes")
+    assert scopes["base"]["path"] == "/new/path"
+
+def test_update_scope_add_new_key(temp_scopes_file):
+    with patch.dict('os.environ', {'PATCHLLM_SCOPES_FILE': temp_scopes_file.as_posix()}):
+        run_main_with_args(["--update-scope", "base", "new_key=True"])
+    scopes = load_from_py_file(temp_scopes_file, "scopes")
+    assert scopes["base"]["new_key"] is True
+
+def test_update_scope_invalid_value(temp_scopes_file, capsys):
+    with patch.dict('os.environ', {'PATCHLLM_SCOPES_FILE': temp_scopes_file.as_posix()}):
+        run_main_with_args(["--update-scope", "base", "path=unquoted"])
+    captured = capsys.readouterr()
+    assert "Error parsing update values" in captured.out

tests/test_structure.py

@@ -0,0 +1,48 @@
+import os
+from patchllm.scopes.builder import build_context
+from patchllm.scopes.structure import _extract_symbols_by_regex
+from patchllm.scopes.constants import LANGUAGE_PATTERNS
+
+def test_extract_python_symbols():
+    content = """
+import os
+class MyClass(Parent):
+    def method_one(self, arg1): pass
+async def top_level_async_func(): pass
+    """
+    patterns = LANGUAGE_PATTERNS['python']['patterns']
+    symbols = _extract_symbols_by_regex(content, patterns)
+    assert "import os" in symbols["imports"]
+    assert "class MyClass(Parent):" in symbols["class"]
+    assert "def method_one(self, arg1):" in symbols["function"]
+    assert "async def top_level_async_func():" in symbols["function"]
+
+def test_extract_javascript_symbols():
+    content = """
+import React from 'react';
+export class MyComponent extends React.Component {}
+function helper() {}
+export const arrowFunc = (arg1) => {}
+export async function getData() {}
+    """
+    patterns = LANGUAGE_PATTERNS['javascript']['patterns']
+    symbols = _extract_symbols_by_regex(content, patterns)
+    assert "import React from 'react';" in symbols["imports"]
+    assert "export class MyComponent extends React.Component {}" in symbols["class"]
+    assert "function helper() {}" in symbols["function"]
+    assert "export const arrowFunc = (arg1) => {}" in symbols["function"]
+    assert "export async function getData() {}" in symbols["function"]
+
+def test_build_structure_context(mixed_project):
+    os.chdir(mixed_project)
+    result = build_context("@structure", {}, mixed_project)
+    assert result is not None
+    context = result["context"]
+    assert "<file_path:api/main.py>" in context
+    assert "<file_path:frontend/src/index.js>" in context
+    assert "README.md" not in context
+    assert "class APIServer:" in context
+    assert "async def get_user(id: int) -> User:" in context
+    assert "export class App extends React.Component {" in context
+    assert "export const arrowFunc = () => {" in context
+    assert "Project Structure Outline:" in context