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

tests/test_tui.py

@@ -0,0 +1,397 @@
+import pytest
+from unittest.mock import patch, MagicMock, ANY
+import sys
+import os
+import re
+from pathlib import Path
+
+# This import will only work if prompt_toolkit is installed
+pytest.importorskip("prompt_toolkit")
+# Add skip for the new dependency to avoid errors if not installed
+pytest.importorskip("InquirerPy")
+
+from patchllm.cli.entrypoint import main
+from patchllm.agent.session import AgentSession
+from patchllm.tui.interface import _run_scope_management_tui, _interactive_scope_editor, _edit_string_list_interactive, _edit_patterns_interactive, _run_plan_management_tui
+from patchllm.utils import write_scopes_to_file, load_from_py_file
+from rich.console import Console
+
+@pytest.fixture
+def mock_args():
+    """Provides a mock argparse.Namespace object for tests."""
+    class MockArgs:
+        def __init__(self):
+            self.model = "default-model"
+    return MockArgs()
+
+def test_agent_session_initialization(mock_args):
+    session = AgentSession(args=mock_args, scopes={}, recipes={})
+    assert session.goal is None
+    assert session.plan == []
+
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_launches_and_exits(mock_prompt, temp_project, capsys):
+    os.chdir(temp_project)
+    mock_prompt.return_value = "/exit"
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    captured = capsys.readouterr()
+    assert "Welcome to the PatchLLM Agent" in captured.out
+    assert "Exiting agent session. Goodbye!" in captured.out
+    mock_prompt.assert_called_once()
+
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_help_command(mock_prompt, temp_project, capsys):
+    os.chdir(temp_project)
+    mock_prompt.side_effect = ["/help", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    captured = capsys.readouterr()
+    assert "PatchLLM Agent Commands" in captured.out
+    assert "/context <scope>" in captured.out
+    assert "/plan --edit <N> <text>" in captured.out
+    assert "/skip" in captured.out
+    assert "/settings" in captured.out
+    assert "/show [goal|plan|context|history|step]" in captured.out
+
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_context_command_calls_session(mock_prompt, mock_agent_session, temp_project):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.load_context_from_scope.return_value = "Mocked context summary"
+    mock_prompt.side_effect = ["/context my_scope", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    mock_session_instance.load_context_from_scope.assert_called_once_with("my_scope")
+
+@patch('patchllm.tui.interface._run_settings_tui')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_settings_command(mock_prompt, mock_settings_tui, temp_project):
+    os.chdir(temp_project)
+    mock_prompt.side_effect = ["/settings", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    mock_settings_tui.assert_called_once()
+
+
+@patch('InquirerPy.prompt')
+@patch('patchllm.tui.interface.AgentSession')
+def test_tui_settings_change_model_flow(mock_agent_session, mock_inquirer_prompt, temp_project):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    
+    mock_inquirer_prompt.side_effect = [
+        {"action": f"Change Model (current: {mock_session_instance.args.model})"},
+        {"model": "ollama/test-model"},
+        {"action": "Back to agent"}
+    ]
+    
+    with patch('patchllm.tui.interface.model_list', ['ollama/test-model', 'gemini/flash']):
+        from patchllm.tui.interface import _run_settings_tui, Console
+        _run_settings_tui(mock_session_instance, Console())
+
+    assert mock_session_instance.args.model == "ollama/test-model"
+    mock_session_instance.save_settings.assert_called_once()
+
+
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_plan_edit_command(mock_prompt, mock_agent_session, temp_project):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.plan = ["step 1"]
+    mock_prompt.side_effect = ["/plan --edit 1 this is the new text", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    mock_session_instance.edit_plan_step.assert_called_once_with(1, "this is the new text")
+
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_plan_rm_command(mock_prompt, mock_agent_session, temp_project):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.plan = ["step 1"]
+    mock_prompt.side_effect = ["/plan --rm 1", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    mock_session_instance.remove_plan_step.assert_called_once_with(1)
+
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_plan_add_command(mock_prompt, mock_agent_session, temp_project):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.plan = ["step 1"]
+    mock_prompt.side_effect = ["/plan --add a new step", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    mock_session_instance.add_plan_step.assert_called_once_with("a new step")
+
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_skip_command(mock_prompt, mock_agent_session, temp_project):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.plan = ["step 1"]
+    mock_prompt.side_effect = ["/skip", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    mock_session_instance.skip_step.assert_called_once()
+
+# --- FIX: Removed obsolete test for /add_context command ---
+
+@pytest.mark.parametrize("sub_command, session_data, expected_output, is_empty", [
+    ("plan", {"plan": ["step 1"]}, "Execution Plan", False),
+    ("plan", {"plan": []}, "No plan exists.", True),
+    ("goal", {"goal": "my test goal"}, "Current Goal", False),
+    ("goal", {"goal": None}, "No goal set.", True),
+    ("history", {"action_history": ["did a thing"]}, "Session History", False),
+    ("history", {"action_history": []}, "No actions recorded yet.", True),
+    ("context", {"context_files": [Path("/fake/file.py")]}, "Context Tree", False),
+    ("context", {"context_files": []}, "Context is empty.", True),
+    ("invalid", {}, "Usage: /show", False),
+])
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_show_commands(mock_prompt, mock_agent_session, temp_project, capsys, sub_command, session_data, expected_output, is_empty):
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    
+    # Set up the session state based on parametrized data
+    for key, value in session_data.items():
+        setattr(mock_session_instance, key, value)
+    
+    # If the session state is empty, ensure the mock reflects that
+    if is_empty:
+        for key in session_data.keys():
+             # Handle None for goal specifically
+            setattr(mock_session_instance, key, None if key == 'goal' else [])
+
+    mock_prompt.side_effect = [f"/show {sub_command}", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+    
+    captured = capsys.readouterr()
+    assert expected_output in captured.out
+
+# --- Tests for Interactive Scope Editor ---
+
+@patch('InquirerPy.prompt')
+@patch('patchllm.tui.interface._interactive_scope_editor')
+def test_scope_management_tui_add_flow(mock_scope_editor, mock_inquirer_prompt, tmp_path):
+    scopes_file = tmp_path / "scopes.py"
+    write_scopes_to_file(scopes_file, {})
+    
+    # Simulate user choosing "Add", typing a name, and then the editor returns a new scope
+    mock_inquirer_prompt.side_effect = [
+        {"action": "Add a new scope"},
+        {"name": "my-new-scope"},
+        {"action": "Back to agent"} # To exit the loop
+    ]
+    mock_scope_editor.return_value = {"path": "src", "include_patterns": ["**/*.js"]}
+    
+    _run_scope_management_tui({}, scopes_file, Console())
+    
+    mock_scope_editor.assert_called_once()
+    loaded_scopes = load_from_py_file(scopes_file, "scopes")
+    assert "my-new-scope" in loaded_scopes
+    assert loaded_scopes["my-new-scope"]["path"] == "src"
+
+@patch('InquirerPy.prompt')
+@patch('patchllm.tui.interface._interactive_scope_editor')
+def test_scope_management_tui_update_flow(mock_scope_editor, mock_inquirer_prompt, tmp_path):
+    scopes_file = tmp_path / "scopes.py"
+    initial_scopes = {"existing-scope": {"path": "old/path"}}
+    write_scopes_to_file(scopes_file, initial_scopes)
+    
+    # Simulate user choosing "Update", selecting the scope, and editor returning a modified scope
+    mock_inquirer_prompt.side_effect = [
+        {"action": "Update a scope"},
+        {"scope": "existing-scope"},
+        {"action": "Back to agent"}
+    ]
+    mock_scope_editor.return_value = {"path": "new/path"}
+    
+    _run_scope_management_tui(initial_scopes, scopes_file, Console())
+    
+    mock_scope_editor.assert_called_once_with(ANY, existing_scope={"path": "old/path"})
+    loaded_scopes = load_from_py_file(scopes_file, "scopes")
+    assert loaded_scopes["existing-scope"]["path"] == "new/path"
+
+@patch('patchllm.tui.interface.select_files_interactively')
+@patch('InquirerPy.prompt')
+def test_edit_patterns_interactive_with_selector(mock_inquirer_prompt, mock_selector, tmp_path):
+    os.chdir(tmp_path)
+    # Simulate user choosing the interactive selector, then done
+    mock_inquirer_prompt.side_effect = [
+        {"action": "Add from interactive selector"},
+        {"action": "Done"}
+    ]
+    mock_selector.return_value = [Path(tmp_path / "src/app.py"), Path(tmp_path / "README.md")]
+    
+    result = _edit_patterns_interactive([], "Include", Console())
+    
+    mock_selector.assert_called_once()
+    assert "src/app.py" in result
+    assert "README.md" in result
+    assert len(result) == 2
+
+@patch('InquirerPy.prompt')
+def test_edit_string_list_interactive_add_and_remove(mock_inquirer_prompt):
+    # Simulate: 1. Add item "c". 2. Remove items "a". 3. Done.
+    mock_inquirer_prompt.side_effect = [
+        {"action": "Add a keyword"},
+        {"item": "c"},
+        {"action": "Remove a keyword"},
+        {"items": ["a"]},
+        {"action": "Done"}
+    ]
+    
+    initial_list = ["a", "b"]
+    result = _edit_string_list_interactive(initial_list, "keyword", Console())
+    
+    assert result == ["b", "c"]
+
+# --- Tests for Interactive Plan Management ---
+
+@patch('patchllm.tui.interface._run_plan_management_tui')
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_plan_command_enters_interactive_mode(mock_prompt, mock_agent_session, mock_plan_tui, temp_project):
+    """Tests that `/plan` with no args enters interactive mode if a plan exists."""
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.plan = ["step 1", "step 2"]
+    mock_session_instance.goal = "a goal"
+    
+    mock_prompt.side_effect = ["/plan", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+        
+    mock_plan_tui.assert_called_once()
+    mock_session_instance.create_plan.assert_not_called()
+
+@patch('InquirerPy.prompt')
+def test_plan_management_tui_edit_flow(mock_inquirer_prompt, mock_args, capsys):
+    """Tests the edit functionality within the interactive plan manager."""
+    session = AgentSession(args=mock_args, scopes={}, recipes={})
+    session.plan = ["step one", "step two"]
+    
+    mock_inquirer_prompt.side_effect = [
+        {"action": "1. step one"},
+        {"sub_action": "Edit"},
+        {"text": "step one EDITED"},
+        {"action": "Done"}
+    ]
+    
+    _run_plan_management_tui(session, Console())
+    
+    assert session.plan == ["step one EDITED", "step two"]
+    captured = capsys.readouterr()
+    assert "Step 1 updated" in captured.out
+
+@patch('InquirerPy.prompt')
+def test_plan_management_tui_remove_flow(mock_inquirer_prompt, mock_args, capsys):
+    """Tests the remove functionality within the interactive plan manager."""
+    session = AgentSession(args=mock_args, scopes={}, recipes={})
+    session.plan = ["step one", "step two"]
+
+    mock_inquirer_prompt.side_effect = [
+        {"action": "2. step two"},
+        {"sub_action": "Remove"},
+        {"action": "Done"}
+    ]
+
+    _run_plan_management_tui(session, Console())
+
+    assert session.plan == ["step one"]
+    captured = capsys.readouterr()
+    assert "Step 2 removed" in captured.out
+
+@patch('InquirerPy.prompt')
+def test_plan_management_tui_add_flow(mock_inquirer_prompt, mock_args, capsys):
+    """Tests the add functionality within the interactive plan manager."""
+    session = AgentSession(args=mock_args, scopes={}, recipes={})
+    session.plan = ["step one"]
+
+    mock_inquirer_prompt.side_effect = [
+        {"action": "Add a new step"},
+        {"text": "step two"},
+        {"action": "Done"}
+    ]
+
+    _run_plan_management_tui(session, Console())
+
+    assert session.plan == ["step one", "step two"]
+    captured = capsys.readouterr()
+    assert "Step added" in captured.out
+
+@patch('InquirerPy.prompt')
+def test_plan_management_tui_reorder_flow(mock_inquirer_prompt, mock_args, capsys):
+    """Tests the reorder functionality within the interactive plan manager."""
+    session = AgentSession(args=mock_args, scopes={}, recipes={})
+    session.plan = ["A", "B", "C"]
+
+    mock_inquirer_prompt.side_effect = [
+        {"action": "Reorder steps"},
+        {"from": "3. C"},
+        {"to": "Move to position 1"},
+        {"action": "Done"}
+    ]
+
+    _run_plan_management_tui(session, Console())
+
+    assert session.plan == ["C", "A", "B"]
+    captured = capsys.readouterr()
+    assert "Step moved from position 3 to 1" in captured.out
+
+# --- Tests for Selective Approve ---
+
+@patch('InquirerPy.prompt')
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_approve_command_interactive_selection(mock_prompt, mock_agent_session, mock_inquirer_prompt, temp_project):
+    """Tests the /approve command opens a checklist and calls session with the result."""
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.last_execution_result = {
+        "summary": {"modified": ["a.py", "b.py"], "created": []}
+    }
+    # User selects only a.py
+    mock_inquirer_prompt.return_value = {"files": ["a.py"]}
+    
+    mock_prompt.side_effect = ["/approve", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+        
+    mock_inquirer_prompt.assert_called_once()
+    mock_session_instance.approve_changes.assert_called_once_with(["a.py"])
+
+@patch('patchllm.tui.interface.AgentSession')
+@patch('prompt_toolkit.PromptSession.prompt')
+def test_tui_displays_change_summary(mock_prompt, mock_agent_session, temp_project, capsys):
+    """Tests that the TUI correctly displays the change summary after a run."""
+    os.chdir(temp_project)
+    mock_session_instance = mock_agent_session.return_value
+    mock_session_instance.plan = ["do a thing"]
+    mock_session_instance.current_step = 0
+    
+    # Mock the result that comes back from the executor
+    mock_execution_result = {
+        "summary": {"modified": ["a.py"], "created": []},
+        "change_summary": "This is the natural language summary of the changes."
+    }
+    mock_session_instance.run_next_step.return_value = mock_execution_result
+    
+    mock_prompt.side_effect = ["/run", "/exit"]
+    with patch.object(sys, 'argv', ['patchllm']):
+        main()
+        
+    mock_session_instance.run_next_step.assert_called_once()
+    
+    captured = capsys.readouterr()
+    assert "Change Summary" in captured.out
+    assert "This is the natural language summary of the changes." in captured.out
+    assert "Proposed File Changes" in captured.out
+    assert "a.py" in captured.out

tests/test_utils.py

@@ -0,0 +1,31 @@
+from patchllm.utils import load_from_py_file, write_scopes_to_file
+import pytest
+
+def test_load_from_py_file_success(temp_scopes_file):
+    scopes = load_from_py_file(temp_scopes_file, "scopes")
+    assert isinstance(scopes, dict)
+    assert "base" in scopes
+
+def test_load_from_py_file_not_found(tmp_path):
+    with pytest.raises(FileNotFoundError):
+        load_from_py_file(tmp_path / "nonexistent.py", "scopes")
+
+def test_load_from_py_file_dict_not_found(tmp_path):
+    p = tmp_path / "invalid_scopes.py"
+    p.write_text("my_scopes = {}")
+    with pytest.raises(TypeError):
+        load_from_py_file(p, "scopes")
+
+def test_load_from_py_file_not_a_dict(tmp_path):
+    p = tmp_path / "invalid_type.py"
+    p.write_text("scopes = [1, 2, 3]")
+    with pytest.raises(TypeError):
+        load_from_py_file(p, "scopes")
+
+def test_write_scopes_to_file(tmp_path):
+    scopes_file = tmp_path / "output_scopes.py"
+    scopes_data = {"test_scope": {"path": "/tmp"}}
+    write_scopes_to_file(scopes_file, scopes_data)
+    assert scopes_file.exists()
+    loaded_scopes = load_from_py_file(scopes_file, "scopes")
+    assert loaded_scopes == scopes_data

patchllm/context.py

@@ -1,238 +0,0 @@
-import glob
-import textwrap
-import subprocess
-import shutil
-from pathlib import Path
-from rich.console import Console
-
-console = Console()
-
-# --- Default Settings & Templates ---
-
-DEFAULT_EXCLUDE_EXTENSIONS = [
-    # General
-    ".log", ".lock", ".env", ".bak", ".tmp", ".swp", ".swo", ".db", ".sqlite3",
-    # Python
-    ".pyc", ".pyo", ".pyd",
-    # JS/Node
-    ".next", ".svelte-kit",
-    # OS-specific
-    ".DS_Store",
-    # Media/Binary files
-    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp",
-    ".mp3", ".mp4", ".mov", ".avi", ".pdf",
-    ".o", ".so", ".dll", ".exe",
-    # Unity specific
-    ".meta",
-]
-
-BASE_TEMPLATE = textwrap.dedent('''
-    Source Tree:
-    ------------
-    ```
-    {{source_tree}}
-    ```
-    {{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]:
-    """Finds all files using glob patterns, handling both relative and absolute paths."""
-    if exclude_patterns is None:
-        exclude_patterns = []
-
-    def _get_files_from_patterns(patterns: list[str]) -> set[Path]:
-        """Helper to process a list of glob patterns and return matching file paths."""
-        files = set()
-        for pattern_str in patterns:
-            pattern_path = Path(pattern_str)
-            # If the pattern is absolute, use it as is. Otherwise, join it with the base_path.
-            search_path = pattern_path if pattern_path.is_absolute() else base_path / pattern_path
-            
-            for match in glob.glob(str(search_path), recursive=True):
-                path_obj = Path(match).resolve()
-                if path_obj.is_file():
-                    files.add(path_obj)
-        return files
-
-    included_files = _get_files_from_patterns(include_patterns)
-    excluded_files = _get_files_from_patterns(exclude_patterns)
-
-    return sorted(list(included_files - excluded_files))
-
-
-def filter_files_by_keyword(file_paths: list[Path], search_words: list[str]) -> list[Path]:
-    """Returns files from a list that contain any of the specified search words."""
-    if not search_words:
-        return file_paths
-    
-    matching_files = []
-    for file_path in file_paths:
-        try:
-            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:
-            console.print(f"⚠️  Could not read {file_path} for keyword search: {e}", style="yellow")
-    return matching_files
-
-
-def generate_source_tree(base_path: Path, file_paths: list[Path]) -> str:
-    """Generates a string representation of the file paths as a tree."""
-    if not file_paths:
-        return "No files found matching the criteria."
-    
-    tree = {}
-    for path in file_paths:
-        try:
-            rel_path = path.relative_to(base_path)
-        except ValueError:
-            rel_path = path
-            
-        level = tree
-        for part in rel_path.parts:
-            level = level.setdefault(part, {})
-
-    def _format_tree(tree_dict, indent=""):
-        lines = []
-        items = sorted(tree_dict.items(), key=lambda i: (not i[1], i[0]))
-        for i, (name, node) in enumerate(items):
-            last = i == len(items) - 1
-            connector = "└── " if last else "├── "
-            lines.append(f"{indent}{connector}{name}")
-            if node:
-                new_indent = indent + ("    " if last else "│   ")
-                lines.extend(_format_tree(node, new_indent))
-        return lines
-
-    return f"{base_path.name}\n" + "\n".join(_format_tree(tree))
-
-
-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(scope: dict) -> dict | None:
-    """
-    Builds the context string from files specified in the scope.
-
-    Args:
-        scope (dict): The scope for file searching.
-
-    Returns:
-        dict: A dictionary with the source tree and formatted context, or None.
-    """
-    base_path = Path(scope.get("path", ".")).resolve()
-    
-    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)
-
-    # Step 2: Filter by extension
-    count_before_ext = len(relevant_files)
-    norm_ext = {ext.lower() for ext in exclude_extensions}
-    relevant_files = [p for p in relevant_files if p.suffix.lower() not in norm_ext]
-    if count_before_ext > len(relevant_files):
-        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)
-        console.print(f"Filtered {count_before_kw - len(relevant_files)} files by keyword search.", style="cyan")
-
-    if not relevant_files and not urls:
-        console.print("\n⚠️  No files or URLs matched the specified criteria.", style="yellow")
-        return None
-
-    # Generate source tree and file content blocks
-    source_tree_str = generate_source_tree(base_path, relevant_files)
-    
-    file_contents = []
-    for file_path in relevant_files:
-        try:
-            display_path = file_path.as_posix()
-            content = file_path.read_text(encoding='utf-8')
-            file_contents.append(f"<file_path:{display_path}>\n```\n{content}\n```")
-        except Exception as e:
-            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}