codeplain 0.3.11.dev20__py3-none-any.whl → 0.3.11.dev22__py3-none-any.whl

tests/test_fix_unit_tests_conformance_context.py

@@ -12,44 +12,25 @@ import pytest
 
 import plain_spec
 from memory_management import MemoryManager
+from render_machine.actions import fix_unit_tests as fix_unit_tests_module
 from render_machine.actions.fix_conformance_test import FixConformanceTest
 from render_machine.actions.fix_unit_tests import FixUnitTests
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
-from render_machine.render_context import RenderContext
-from render_machine.render_types import ConformanceTestsRunningContext, ScriptExecutionHistory, UnitTestsRunningContext
+from render_machine.render_types import ConformanceTestsRunningContext, UnitTestsRunningContext
 
 
 class FakeCodeplainAPI:
-    """Conformance fixes return a scripted response; every agent session submits a fix on its first turn."""
-
-    def __init__(self, conformance_fix_response=None):
+    def __init__(self, conformance_fix_response=None, unittests_fix_response=None):
         self.conformance_fix_response = conformance_fix_response
-        self.agent_calls = []
-        self.sessions_started = 0
+        self.unittests_fix_response = unittests_fix_response or {}
+        self.unittests_fix_calls = []
 
     def fix_conformance_tests_issue(self, *args, **kwargs):
         return self.conformance_fix_response
 
-    def agent_start(self, task_type, task_params, frid, module_name, run_state):
-        self.sessions_started += 1
-        self.agent_calls.append(("start", task_params))
-        return self._submit(f"s{self.sessions_started}")
-
-    def agent_continue(self, session_id, tool_results, frid, module_name, run_state):
-        self.agent_calls.append(("continue", session_id, tool_results))
-        return self._submit(session_id)
-
-    def _submit(self, session_id):
-        call_id = f"submit-{len(self.agent_calls)}"
-        return {
-            "session_id": session_id,
-            "status": "tool_calls",
-            "calls": [{"id": call_id, "name": "submit_fix", "args": {"changes_made": "fixed"}}],
-        }
-
-
-class FakeRenderContext(SimpleNamespace):
-    unit_tests_agent_session = RenderContext.unit_tests_agent_session
+    def fix_unittests_issue(self, *args, **kwargs):
+        self.unittests_fix_calls.append(kwargs)
+        return self.unittests_fix_response
 
 
 class FakeConformanceTests:
@@ -78,11 +59,7 @@ def memory_folder():
 def isolate_from_git_and_console(monkeypatch):
     monkeypatch.setattr(ImplementationCodeHelpers, "get_code_diff", staticmethod(lambda *args: {}))
     monkeypatch.setattr(plain_spec, "collect_linked_resources", lambda *args: None)
-    monkeypatch.setattr(
-        plain_spec,
-        "get_specifications_for_frid",
-        lambda tree, frid: ({plain_spec.FUNCTIONAL_REQUIREMENTS: ["- Add numbers."]}, None),
-    )
+    monkeypatch.setattr(fix_unit_tests_module.render_utils, "print_inputs", lambda *args: None)
 
 
 def make_conformance_context():
@@ -99,7 +76,7 @@ def make_conformance_context():
 
 
 def make_render_context(api, build_folder, memory_folder, conformance_tests_running_context):
-    return FakeRenderContext(
+    return SimpleNamespace(
         codeplain_api=api,
         build_folder=build_folder,
         memory_manager=MemoryManager(api, memory_folder),
@@ -109,11 +86,9 @@ def make_render_context(api, build_folder, memory_folder, conformance_tests_runn
         plain_source_tree={},
         module_name="mod",
         required_modules=None,
-        frid_context=SimpleNamespace(frid="1", linked_resources={}, changed_files=set()),
+        frid_context=SimpleNamespace(frid="1", linked_resources={}),
         get_required_modules_functionalities=lambda: {},
         run_state=SimpleNamespace(render_id="test-render-id", unittest_batch_id=1),
-        unittests_script=None,
-        script_execution_history=ScriptExecutionHistory(),
     )
 
 
@@ -216,104 +191,34 @@ def test_implementation_fix_with_no_files_is_not_remembered(build_folder, memory
     assert ctx.implementation_code_fixes == []
 
 
-def run_unit_tests_fix(render_context, issue="1 failed"):
-    return FixUnitTests().execute(render_context, {"previous_unittests_issue": issue})
-
-
-def start_new_unit_test_loop(render_context):
-    """What RenderContext.start_unittests_processing does when the unit tests are run again."""
-    render_context.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
-
-
-def conformance_fix(number):
-    return {
-        "hypothesis": f"hypothesis {number}",
-        "approach": f"approach {number}",
-        "code_diff": {"app.py": f"+{number}"},
-    }
+def run_unit_tests_fix(render_context):
+    return FixUnitTests().execute(render_context, {"previous_unittests_issue": "1 failed"})
 
 
-def test_first_unit_test_loop_of_conformance_phase_seeds_the_session_with_the_fixes(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
+def test_unit_tests_fix_forwards_conformance_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI(unittests_fix_response={"test_app.py": "def test_add(): pass\n"})
     ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
+    ctx.implementation_code_fixes.append(
+        {"hypothesis": "off by one", "approach": "add one", "code_diff": {"app.py": "+    return a + b + 1"}}
+    )
     render_context = make_render_context(api, build_folder, memory_folder, ctx)
 
     outcome, _ = run_unit_tests_fix(render_context)
 
     assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
-    kind, task_params = api.agent_calls[0]
-    assert kind == "start"
-    assert task_params["conformance_tests_fixes"] == ctx.implementation_code_fixes
+    assert len(api.unittests_fix_calls) == 1
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] == ctx.implementation_code_fixes
     # The forwarded list is a copy, so later conformance fixes do not mutate what was sent.
-    assert task_params["conformance_tests_fixes"] is not ctx.implementation_code_fixes
-    # The file the conformance fix changed is seeded although the FRID did not change it.
-    assert "app.py" in task_params["relevant_files"]
-    assert ctx.unit_tests_agent_session.session_id == "s1"
-
-
-def test_next_unit_test_loop_of_conformance_phase_continues_the_session_with_only_new_fixes(
-    build_folder, memory_folder
-):
-    api = FakeCodeplainAPI()
-    ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
-    render_context = make_render_context(api, build_folder, memory_folder, ctx)
-    run_unit_tests_fix(render_context)
-
-    # The fix was accepted; the conformance tests fixer changes the code again and the unit tests fail again.
-    ctx.implementation_code_fixes.append(conformance_fix(2))
-    start_new_unit_test_loop(render_context)
-    run_unit_tests_fix(render_context, issue="2 failed")
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is not ctx.implementation_code_fixes
 
-    assert api.sessions_started == 1
-    kind, session_id, tool_results = api.agent_calls[1]
-    assert (kind, session_id) == ("continue", "s1")
-    submit_answer = tool_results[-1]
-    assert submit_answer["call_id"] == "submit-1"
-    assert submit_answer["output"].startswith("Your fix was accepted: the unit tests passed.")
-    assert "Conformance Tests Fix below" in submit_answer["output"]
-    assert submit_answer["conformance_tests_fixes"] == [conformance_fix(2)]
-    assert submit_answer["test_output"] == "2 failed"
 
-
-def test_retry_within_a_unit_test_loop_says_the_fix_did_not_work(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
-    ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
-    render_context = make_render_context(api, build_folder, memory_folder, ctx)
-    run_unit_tests_fix(render_context)
-
-    run_unit_tests_fix(render_context, issue="still failing")
-
-    submit_answer = api.agent_calls[1][2][-1]
-    assert "still fail" in submit_answer["output"]
-    # Fix 1 was already shown to the session, so it is not sent again.
-    assert "conformance_tests_fixes" not in submit_answer
-
-
-def test_new_conformance_phase_starts_a_new_session(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
-    render_context = make_render_context(api, build_folder, memory_folder, make_conformance_context())
-    run_unit_tests_fix(render_context)
-
-    # E.g. the functionality is re-rendered from scratch: the conformance tests running context is recreated.
-    render_context.conformance_tests_running_context = make_conformance_context()
-    start_new_unit_test_loop(render_context)
-    run_unit_tests_fix(render_context)
-
-    assert [call[0] for call in api.agent_calls] == ["start", "start"]
-
-
-def test_unit_tests_outside_conformance_phase_get_no_fixes_and_a_session_per_loop(build_folder, memory_folder):
+def test_unit_tests_fix_outside_conformance_phase_sends_no_fixes(build_folder, memory_folder):
     api = FakeCodeplainAPI()
     render_context = make_render_context(api, build_folder, memory_folder, None)
-    run_unit_tests_fix(render_context)
-    start_new_unit_test_loop(render_context)
+
     run_unit_tests_fix(render_context)
 
-    assert [call[0] for call in api.agent_calls] == ["start", "start"]
-    assert all("conformance_tests_fixes" not in call[1] for call in api.agent_calls)
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None
 
 
 def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_sends_no_fixes(build_folder, memory_folder):
@@ -322,4 +227,4 @@ def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_send
 
     run_unit_tests_fix(render_context)
 
-    assert "conformance_tests_fixes" not in api.agent_calls[0][1]
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None

tests/test_tui_components.py

@@ -6,7 +6,7 @@ from textual.widgets import Static
 
 from event_bus import EventBus
 from plain2code_state import RunState
-from tui.components import ProgressItem, SubstateLine, TUIComponents
+from tui.components import FRIDProgress, ProgressItem, RenderingInfoBox, SubstateLine, TUIComponents
 from tui.models import Substate
 from tui.plain2code_tui import Plain2CodeTUI
 from tui.widget_helpers import display_error_message, display_success_message, update_progress_item_substates
@@ -86,3 +86,62 @@ def test_status_messages_keep_brackets():
             assert "[Errno 2] No such file: run_tests.sh [b" in str(status.content)
 
     asyncio.run(scenario())
+
+
+# A functionality quote as the render TUI receives it: several lines, square brackets included.
+MULTILINE_FUNCTIONALITY_TEXT = (
+    "Functionality 3: :User: should be able to add a :Task: [optional]\n"
+    "  - The :Task: must have non-empty content.\n"
+    "  - The :Task: is appended to the end of the list."
+)
+
+
+def test_functionality_text_collapses_and_expands_with_ctrl_o():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            frid_progress = app.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress)
+            info_box = frid_progress.query_one(RenderingInfoBox)
+            info_box.update_functionality(MULTILINE_FUNCTIONALITY_TEXT)
+            await pilot.pause()
+
+            widget = info_box.functionality_widget
+            assert widget is not None
+
+            # Collapsed by default: first line only, with the expand hint.
+            collapsed = str(widget.content)
+            assert "Functionality 3: :User: should be able to add a :Task: [optional]" in collapsed
+            assert "non-empty content" not in collapsed
+            assert RenderingInfoBox.EXPAND_HINT in collapsed
+
+            await pilot.press("ctrl+o")
+            await pilot.pause()
+            expanded = str(widget.content)
+            assert "non-empty content" in expanded
+            assert "appended to the end of the list" in expanded
+            assert RenderingInfoBox.COLLAPSE_HINT in expanded
+
+            await pilot.press("ctrl+o")
+            await pilot.pause()
+            assert str(widget.content) == collapsed
+
+    asyncio.run(scenario())
+
+
+def test_single_line_functionality_text_has_no_hint():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            info_box = app.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress).query_one(RenderingInfoBox)
+            info_box.update_functionality("Functionality 1: :User: should be able to add a :Task:")
+            await pilot.pause()
+
+            widget = info_box.functionality_widget
+            assert widget is not None
+            assert str(widget.content) == "Functionality 1: :User: should be able to add a :Task:"
+
+    asyncio.run(scenario())

tui/components.py

@@ -339,10 +339,14 @@ class ProgressItem(Vertical):
 class RenderingInfoBox(Vertical):
     """Responsive container for module and functionality information."""
 
+    EXPAND_HINT = "(ctrl+o to expand)"
+    COLLAPSE_HINT = "(ctrl+o to collapse)"
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.module_text = ""
         self.functionality_text = ""
+        self.functionality_expanded = False
         self.module_widget: Static | None = None
         self.functionality_widget: Static | None = None
 
@@ -356,12 +360,31 @@ class RenderingInfoBox(Vertical):
         self.functionality_text = text
         self._refresh_content()
 
+    def toggle_functionality(self) -> None:
+        """Expand or collapse the functionality text."""
+        self.functionality_expanded = not self.functionality_expanded
+        self._refresh_content()
+
+    def _format_functionality(self) -> Content:
+        """Build the functionality line, collapsed to its first line unless expanded.
+
+        The functionality text comes from the spec and may contain square brackets, so it
+        is assembled as Content and never goes through the markup parser.
+        """
+        text = self.functionality_text or ""
+        lines = text.splitlines()
+        if len(lines) <= 1:
+            return Content(text)
+        if self.functionality_expanded:
+            return Content.assemble(f"{text}\n", (self.COLLAPSE_HINT, "#888888"))
+        return Content.assemble(f"{lines[0]} \u2026 ", (self.EXPAND_HINT, "#888888"))
+
     def _refresh_content(self) -> None:
         """Refresh text inside the box."""
         if self.module_widget is not None:
             self.module_widget.update(self.module_text or "")
         if self.functionality_widget is not None:
-            self.functionality_widget.update(self.functionality_text or "")
+            self.functionality_widget.update(self._format_functionality())
 
     def on_mount(self) -> None:
         """Initialize default labels on mount."""
@@ -372,7 +395,7 @@ class RenderingInfoBox(Vertical):
 
     def compose(self):
         self.module_widget = Static(self.module_text, classes="rendering-info-row", markup=False)
-        self.functionality_widget = Static(self.functionality_text, classes="rendering-info-row", markup=False)
+        self.functionality_widget = Static(self._format_functionality(), classes="rendering-info-row", markup=False)
         yield Static("module status", classes="rendering-info-title")
         with Vertical(classes="rendering-info-box"):
             yield self.module_widget

tui/plain2code_tui.py

@@ -65,6 +65,7 @@ class Plain2CodeTUI(App):
         Binding("ctrl+d", "quit", "Quit", show=False),
         Binding("enter", "enter_exit", "Exit", show=False),
         Binding("ctrl+p", "pause", "Pause", show=False, priority=True),
+        Binding("ctrl+o", "toggle_functionality", "Expand/Collapse", show=False),
         ("ctrl+l", "toggle_logs", "Toggle Logs"),
     ]
 
@@ -231,6 +232,14 @@ class Plain2CodeTUI(App):
             self.run_state.render_time_accumulated,
         )
 
+    def action_toggle_functionality(self) -> None:
+        """Expand or collapse the functionality text in the rendering info box."""
+        try:
+            frid_progress = self.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress)
+            frid_progress.query_one(RenderingInfoBox).toggle_functionality()
+        except NoMatches:
+            pass
+
     def action_toggle_logs(self) -> None:
         """Toggle between dashboard and log view."""
         switcher = self.query_one(f"#{TUIComponents.CONTENT_SWITCHER.value}", ContentSwitcher)

render_machine/agent_tools.py

@@ -1,270 +0,0 @@
-"""Client-side implementations of the tools a server-side agent can call.
-
-The server declares the tools to the LLM (codeplain-api: src/agent/tools.py) and forwards
-the model's calls; this module executes them against the local build folder and returns
-plain-text results. Relative paths resolve against the build folder. Reads are allowed only in the
-build folder and the full test logs the agent was pointed to; writes only inside the build folder.
-"""
-
-import glob
-import json
-import os
-import subprocess
-import tempfile
-from typing import Callable
-
-from plain2code_console import console
-from render_machine import render_utils
-from render_machine.render_context import RenderContext
-
-DEFAULT_READ_LIMIT = 200
-MAX_LINE_CHARS = 10_000
-MAX_OUTPUT_CHARS = 30_000
-EDIT_SNIPPET_CONTEXT_LINES = 3
-MAX_EDIT_SNIPPET_LINES = 60
-MAX_GREP_CONTEXT_LINES = 20
-# Tools without side effects; repeating one while no file changed returns a pointer instead.
-READ_ONLY_TOOLS = ("read_file", "grep", "ls_files")
-GREP_EXCLUDED_DIRS = (".git", "__pycache__", "node_modules", ".venv", "target", "dist", "build")
-
-
-def _build_folder(render_context: RenderContext) -> str:
-    return os.path.normpath(os.path.abspath(render_context.build_folder))
-
-
-def _resolve(file_path: str, render_context: RenderContext) -> str:
-    if os.path.isabs(file_path):
-        return os.path.normpath(file_path)
-    return os.path.normpath(os.path.join(_build_folder(render_context), file_path))
-
-
-def _within(path: str, folder: str) -> bool:
-    return path == folder or path.startswith(folder + os.sep)
-
-
-def _readable(path: str, render_context: RenderContext) -> bool:
-    return (
-        _within(path, _build_folder(render_context))
-        or path in render_context.unit_tests_agent_session.readable_log_paths
-    )
-
-
-def register_log_path(log_path: str, render_context: RenderContext) -> None:
-    """Allow read_file/grep on a full test log the agent is pointed to."""
-    render_context.unit_tests_agent_session.readable_log_paths.add(os.path.normpath(os.path.abspath(log_path)))
-
-
-def _writable(path: str, render_context: RenderContext) -> bool:
-    return _within(path, _build_folder(render_context))
-
-
-def _bound(text: str) -> str:
-    """Cap very long lines and the total size so one tool result cannot flood the context."""
-    lines = [
-        line if len(line) <= MAX_LINE_CHARS else line[:MAX_LINE_CHARS] + "... [line truncated]"
-        for line in text.split("\n")
-    ]
-    text = "\n".join(lines)
-    if len(text) > MAX_OUTPUT_CHARS:
-        head, tail = int(MAX_OUTPUT_CHARS * 0.6), int(MAX_OUTPUT_CHARS * 0.4)
-        text = text[:head] + f"\n\n... [truncated {len(text) - head - tail:,} chars] ...\n\n" + text[-tail:]
-    return text
-
-
-def _track_change(full_path: str, render_context: RenderContext) -> None:
-    context = render_context.unit_tests_running_context
-    context.changed_files.add(os.path.relpath(full_path, _build_folder(render_context)))
-    context.verified_passing, context.verified_passing_log_path = False, None
-    context.tool_result_cache.clear()
-
-
-def read_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    if not _readable(full_path, render_context):
-        return f"Error: read access denied for '{full_path}' (readable: build folder and test logs)."
-    if not os.path.isfile(full_path):
-        return f"Error: file not found: '{full_path}'."
-    with open(full_path, "r", encoding="utf-8", errors="replace") as f:
-        lines = f.read().split("\n")
-    offset = max(int(args.get("offset") or 1), 1)
-    limit = int(args.get("limit") or DEFAULT_READ_LIMIT)
-    selected = lines[offset - 1 : offset - 1 + limit]
-    if not selected:
-        return f"Error: offset {offset} is past the end of the file ({len(lines)} lines)."
-    numbered = "\n".join(f"{offset + i}: {line}" for i, line in enumerate(selected))
-    last = offset - 1 + len(selected)
-    note = (
-        f"\n[showing lines {offset}-{last} of {len(lines)}; use offset={last + 1} to continue]"
-        if last < len(lines)
-        else ""
-    )
-    return _bound(numbered) + note
-
-
-def grep(args: dict, render_context: RenderContext) -> str:
-    pattern = args.get("pattern", "")
-    if not pattern:
-        return "Error: pattern is required."
-    target = _resolve(args.get("file_path") or ".", render_context)
-    if not _readable(target, render_context):
-        return f"Error: read access denied for '{target}'."
-    if not os.path.exists(target):
-        return f"Error: path not found: '{target}'."
-    # Run from the build folder so matches inside it come back as build-relative paths, which
-    # is the form the other tools accept; a test log outside it is passed by absolute path.
-    cwd = _build_folder(render_context)
-    options = [f"--exclude-dir={d}" for d in GREP_EXCLUDED_DIRS]
-    context_lines = min(max(int(args.get("context_lines") or 0), 0), MAX_GREP_CONTEXT_LINES)
-    if context_lines:
-        options.append(f"-C{context_lines}")
-    if args.get("include"):
-        options.append(f"--include={args['include']}")
-    command = ["grep", "-rnI", *options, "-e", pattern, "--"]
-    command.append(os.path.relpath(target, cwd) if _within(target, cwd) else target)
-    result = subprocess.run(command, capture_output=True, text=True, cwd=cwd)
-    if result.returncode == 1:
-        return f"No matches for '{pattern}' in '{target}'."
-    if result.returncode != 0:
-        return f"Error: grep failed: {result.stderr.strip()}"
-    lines = [line[2:] if line.startswith("./") else line for line in result.stdout.rstrip("\n").split("\n")]
-    return _bound("\n".join(lines))
-
-
-def ls_files(args: dict, render_context: RenderContext) -> str:
-    target = _resolve(args.get("pattern") or ".", render_context)
-    if not _readable(target, render_context):
-        return f"Error: read access denied for '{target}'."
-    if os.path.isdir(target):
-        entries = sorted(os.listdir(target))
-        listing = [entry + "/" if os.path.isdir(os.path.join(target, entry)) else entry for entry in entries]
-        return f"{target}:\n" + ("\n".join(listing) if listing else "(empty)")
-    matches = sorted(glob.glob(target, recursive=True))
-    return _bound("\n".join(matches)) if matches else f"No files match '{target}'."
-
-
-def edit_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    search, replace = args.get("search", ""), args.get("replace", "")
-    if not search:
-        return "Error: search is required."
-    if not _writable(full_path, render_context):
-        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
-    if not os.path.isfile(full_path):
-        return f"Error: file not found: '{full_path}'. Use write_file to create new files."
-    with open(full_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    occurrences = content.count(search)
-    if occurrences != 1:
-        return (
-            f"Error: search text found {occurrences} times in '{full_path}'; it must appear exactly once. "
-            "Read the file and use a larger, unique snippet."
-        )
-    with open(full_path, "w", encoding="utf-8") as f:
-        f.write(content.replace(search, replace, 1))
-    _track_change(full_path, render_context)
-    return f"Edited '{full_path}'. The edited region now reads:\n" + _edit_snippet(content, search, replace)
-
-
-def _edit_snippet(content: str, search: str, replace: str) -> str:
-    """Numbered lines of the replacement plus a little context, so the edit needs no re-read."""
-    lines = content.replace(search, replace, 1).split("\n")
-    first = content[: content.index(search)].count("\n")
-    last = first + replace.count("\n")
-    start = max(first - EDIT_SNIPPET_CONTEXT_LINES, 0)
-    end = min(last + EDIT_SNIPPET_CONTEXT_LINES + 1, len(lines), start + MAX_EDIT_SNIPPET_LINES)
-    snippet = "\n".join(f"{start + i + 1}: {line}" for i, line in enumerate(lines[start:end]))
-    return _bound(snippet)
-
-
-def write_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    if not _writable(full_path, render_context):
-        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
-    os.makedirs(os.path.dirname(full_path), exist_ok=True)
-    with open(full_path, "w", encoding="utf-8") as f:
-        f.write(args.get("content", ""))
-    _track_change(full_path, render_context)
-    return f"Wrote '{full_path}'."
-
-
-def delete_file(args: dict, render_context: RenderContext) -> str:
-    full_path = _resolve(args.get("file_path", ""), render_context)
-    if not _writable(full_path, render_context):
-        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
-    if not os.path.isfile(full_path):
-        return f"Error: file not found: '{full_path}'."
-    os.remove(full_path)
-    _track_change(full_path, render_context)
-    return f"Deleted '{full_path}'."
-
-
-def full_log_pointer(log_file_path: str | None) -> str:
-    return f" Full log: {log_file_path} (search it with grep, passing that path as file_path)." if log_file_path else ""
-
-
-def run_unit_tests(_args: dict, render_context: RenderContext) -> dict:
-    """Returns a result dict: a short header in `output` and the raw failure output in
-    `test_output`, which the server condenses (summarizing it when it is long)."""
-    exit_code, output, log_file_path = render_utils.execute_script(
-        os.path.normpath(render_context.unittests_script),
-        [render_context.build_folder],
-        "Unit Tests",
-        timeout=render_context.test_script_timeout,
-        stop_event=render_context.stop_event,
-    )
-    context = render_context.unit_tests_running_context
-    if exit_code == 0:
-        context.verified_passing, context.verified_passing_log_path = True, log_file_path
-        return {"output": "All unit tests passed."}
-    if not log_file_path and output:
-        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".unittest_output") as f:
-            f.write(output)
-            log_file_path = f.name
-    if log_file_path:
-        register_log_path(log_file_path, render_context)
-    return {
-        "output": f"Unit tests failed (exit code {exit_code}).{full_log_pointer(log_file_path)}",
-        "test_output": output,
-    }
-
-
-TOOLS: dict[str, Callable[[dict, RenderContext], str | dict]] = {
-    "read_file": read_file,
-    "grep": grep,
-    "ls_files": ls_files,
-    "edit_file": edit_file,
-    "write_file": write_file,
-    "delete_file": delete_file,
-    "run_unit_tests": run_unit_tests,
-}
-
-
-def execute_calls(calls: list[dict], render_context: RenderContext) -> list[dict]:
-    """Execute the agent's tool calls in order; every call gets a result, errors included.
-
-    A repeated read-only call (same tool and arguments, no file changed in between) is not
-    re-executed: its result is already in the conversation, so a short pointer is returned."""
-    cache = render_context.unit_tests_running_context.tool_result_cache
-    results = []
-    for call in calls:
-        tool = TOOLS.get(call["name"])
-        cache_key = json.dumps([call["name"], call.get("args") or {}], sort_keys=True)
-        result: dict
-        if tool is None:
-            result = {"output": f"Error: unknown tool '{call['name']}'."}
-        elif call["name"] in READ_ONLY_TOOLS and cache_key in cache:
-            result = {
-                "output": "Same call as an earlier one and no file has changed since; "
-                "its result is unchanged (see the earlier result above)."
-            }
-        else:
-            try:
-                output = tool(call.get("args") or {}, render_context)
-                result = output if isinstance(output, dict) else {"output": output}
-            except Exception as e:
-                result = {"output": f"Error: tool '{call['name']}' failed: {type(e).__name__}: {e}"}
-            if call["name"] in READ_ONLY_TOOLS and not result["output"].startswith("Error"):
-                cache[cache_key] = result["output"]
-        console.debug(f"Agent tool {call['name']}({call.get('args')}) -> {result['output'][:200]!r}")
-        results.append({"call_id": call["id"], **result})
-    return results