codeplain 0.3.11.dev19__tar.gz → 0.3.11.dev20__tar.gz

{codeplain-0.3.11.dev19 → codeplain-0.3.11.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.11.dev19
+Version: 0.3.11.dev20
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

{codeplain-0.3.11.dev19 → codeplain-0.3.11.dev20}/codeplain_REST_api.py

@@ -253,38 +253,6 @@ class CodeplainAPI:
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
-    def fix_unittests_issue(
-        self,
-        frid,
-        plain_source_tree,
-        linked_resources,
-        existing_files_content,
-        module_name: str,
-        required_modules,
-        unittests_issue,
-        run_state: RunState,
-        conformance_tests_fixes: list[dict] | None = None,
-    ):
-        endpoint_url = f"{self.api_url}/fix_unittests_issue"
-        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
-
-        payload = {
-            "frid": frid,
-            "plain_source_tree": plain_source_tree,
-            "linked_resources": linked_resources,
-            "existing_files_content": existing_files_content,
-            "module_name": module_name,
-            "required_modules": required_modules,
-            "unittests_issue": unittests_issue,
-            "unittest_batch_id": run_state.unittest_batch_id,
-        }
-        # Implementation code changes made by the conformance tests fixer right before this unit tests run;
-        # only sent when unit tests are processed inside the conformance tests phase.
-        if conformance_tests_fixes is not None:
-            payload["conformance_tests_fixes"] = conformance_tests_fixes
-
-        return self.post_request(endpoint_url, headers, payload, run_state)
-
     def distill_conformance_test_memory(
         self,
         frid,
@@ -558,3 +526,29 @@ class CodeplainAPI:
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)
+
+    def agent_start(self, task_type: str, task_params: dict, frid: str, module_name: str, run_state: RunState):
+        """Start a server-side agent session; returns the first turn (tool calls or completion)."""
+        endpoint_url = f"{self.api_url}/agent/start"
+        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
+        payload = {
+            "task_type": task_type,
+            "task_params": task_params,
+            "frid": frid,
+            "module_name": module_name,
+        }
+        return self.post_request(endpoint_url, headers, payload, run_state)
+
+    def agent_continue(
+        self, session_id: str, tool_results: list[dict], frid: str, module_name: str, run_state: RunState
+    ):
+        """Feed tool results into an agent session and run its next turn."""
+        endpoint_url = f"{self.api_url}/agent/continue"
+        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
+        payload = {
+            "session_id": session_id,
+            "tool_results": tool_results,
+            "frid": frid,
+            "module_name": module_name,
+        }
+        return self.post_request(endpoint_url, headers, payload, run_state)

codeplain-0.3.11.dev20/render_machine/actions/fix_unit_tests.py

@@ -0,0 +1,256 @@
+import os
+from http import HTTPStatus
+from typing import Any
+
+import requests
+
+import file_utils
+import plain_spec
+from plain2code_console import console
+from plain2code_exceptions import InternalClientError
+from render_machine import agent_tools
+from render_machine.actions.base_action import BaseAction
+from render_machine.render_context import RenderContext
+
+TASK_TYPE = "fix_unit_tests"
+SUBMIT_FIX_TOOL = "submit_fix"
+# Upper bound on LLM turns spent on one fix attempt; the server bounds the whole session.
+MAX_AGENT_TURNS_PER_ATTEMPT = 40
+# Answer to a submit_fix whose fix was accepted in an earlier unit-test loop of the conformance phase.
+ACCEPTED_THEN_CHANGED_MESSAGE = (
+    "Your fix was accepted: the unit tests passed. Afterwards the implementation code was changed to fix the "
+    "conformance tests{see_below}, and the unit tests now fail again. Files may have changed since you last read "
+    "them."
+)
+# Seeding the first turn: the build folder's file list and the files changed for the FRID.
+MAX_FILE_TREE_ENTRIES = 500
+MAX_RELEVANT_FILES_CHARS = 60_000
+
+
+class FixUnitTests(BaseAction):
+    """Fix failing unit tests with a server-side agent session that spans the fix attempts.
+
+    The first failure starts a session; the agent then drives read/grep/edit/run tool calls
+    (executed here) until it calls submit_fix. The state machine re-runs the unit tests and,
+    if they still fail, the next execution of this action answers that submit_fix call with
+    the new failure output inside the same session, so earlier attempts stay in context.
+
+    During the conformance phase the session also spans unit-test loops: after the conformance
+    tests fixer changes implementation code, the unit tests fail again and the same session is
+    continued, told what the conformance tests fixer changed (which it must preserve).
+    """
+
+    SUCCESSFUL_OUTCOME = "unit_tests_fix_generated"
+
+    def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
+        if not previous_action_payload or not previous_action_payload.get("previous_unittests_issue"):
+            raise InternalClientError(
+                "Internal client error: Previous action payload does not contain previous unit tests issue."
+            )
+        unittests_issue = previous_action_payload["previous_unittests_issue"]
+        context = render_context.unit_tests_running_context
+        session = render_context.unit_tests_agent_session
+        api = render_context.codeplain_api
+        frid, module_name = render_context.frid_context.frid, render_context.module_name
+        changed_files_before = set(context.changed_files)
+        log_path = render_context.script_execution_history.latest_unit_test_output_path
+        if log_path:
+            agent_tools.register_log_path(log_path, render_context)
+        conformance_tests_fixes = self._get_conformance_tests_fixes(render_context)
+        new_conformance_tests_fixes = conformance_tests_fixes[session.conformance_fixes_handed_off :]
+        if new_conformance_tests_fixes:
+            console.info(
+                f"Unit tests are fixed while preserving {len(new_conformance_tests_fixes)} implementation code "
+                "change(s) made to fix the conformance tests."
+            )
+
+        response = None
+        if session.session_id is not None:
+            if context.agent_used_in_this_loop:
+                console.info(f"Continuing agent session {session.session_id} with the new unit tests failure.")
+                output = "The fix was applied, but the unit tests still fail."
+            else:
+                # The session's last fix was accepted in an earlier unit-test loop of this conformance
+                # phase; since then the conformance tests fixer changed the code and the tests fail again.
+                console.info(
+                    f"Continuing agent session {session.session_id}: the unit tests fail again after the "
+                    "implementation was changed to fix the conformance tests."
+                )
+                output = ACCEPTED_THEN_CHANGED_MESSAGE.format(
+                    see_below=" (see the Conformance Tests Fix below)" if new_conformance_tests_fixes else ""
+                )
+                # Files changed outside the session, so earlier read results are stale.
+                context.tool_result_cache.clear()
+            submit_result: dict = {
+                "call_id": session.pending_submit_call_id,
+                "output": output + agent_tools.full_log_pointer(log_path),
+                "test_output": unittests_issue,
+            }
+            if new_conformance_tests_fixes:
+                submit_result["conformance_tests_fixes"] = new_conformance_tests_fixes
+            tool_results = session.pending_tool_results + [submit_result]
+            session.pending_tool_results, session.pending_submit_call_id = [], None
+            response = self._continue_session(render_context, session.session_id, tool_results)
+        if response is None:
+            console.info("Starting an agent session to fix the unit tests.")
+            # Cached read results point at earlier turns, which a new session does not have.
+            context.tool_result_cache.clear()
+            response = api.agent_start(
+                TASK_TYPE,
+                self._build_task_params(render_context, unittests_issue, conformance_tests_fixes),
+                frid,
+                module_name,
+                render_context.run_state,
+            )
+            session.session_id = response["session_id"]
+        assert session.session_id is not None
+        session.conformance_fixes_handed_off = len(conformance_tests_fixes)
+        context.agent_used_in_this_loop = True
+
+        submitted = False
+        turns = 0
+        while response.get("status") == "tool_calls" and turns < MAX_AGENT_TURNS_PER_ATTEMPT:
+            turns += 1
+            calls = response["calls"]
+            submit_call = next((call for call in calls if call["name"] == SUBMIT_FIX_TOOL), None)
+            tool_results = agent_tools.execute_calls(
+                [call for call in calls if call is not submit_call], render_context
+            )
+            if submit_call is not None:
+                session.pending_submit_call_id = submit_call["id"]
+                session.pending_tool_results = tool_results
+                submitted = True
+                console.info(f"Agent submitted a fix: {submit_call['args'].get('changes_made', '')}")
+                break
+            response = api.agent_continue(session.session_id, tool_results, frid, module_name, render_context.run_state)
+
+        if not submitted:
+            # The session ended without a submission (finished in text, failed, or used up this
+            # attempt's turn budget) — a fresh session is started if the tests still fail.
+            status = response.get("status")
+            if status == "failed":
+                console.warning(f"Agent session failed: {response.get('error', 'unknown error')}")
+            elif status == "tool_calls":
+                console.warning(f"Agent used {MAX_AGENT_TURNS_PER_ATTEMPT} turns without submitting a fix.")
+            session.reset()
+
+        console.print_files(
+            "Files changed while fixing unit tests:",
+            render_context.build_folder,
+            {path: "" for path in sorted(context.changed_files - changed_files_before)},
+            style=console.OUTPUT_STYLE,
+        )
+        return self.SUCCESSFUL_OUTCOME, None
+
+    @staticmethod
+    def _get_conformance_tests_fixes(render_context: RenderContext) -> list[dict]:
+        """Implementation code changes the conformance tests fixer made during this conformance phase, oldest
+        first. Empty outside the conformance phase (the implementation and refactoring unit-test loops)."""
+        conformance_tests_running_context = getattr(render_context, "conformance_tests_running_context", None)
+        if conformance_tests_running_context is None:
+            return []
+        return list(getattr(conformance_tests_running_context, "implementation_code_fixes", None) or [])
+
+    @staticmethod
+    def _continue_session(render_context: RenderContext, session_id: str, tool_results: list[dict]) -> dict | None:
+        """Continue the session; None if the server no longer has it (expired), so a new one is started."""
+        try:
+            return render_context.codeplain_api.agent_continue(
+                session_id,
+                tool_results,
+                render_context.frid_context.frid,
+                render_context.module_name,
+                render_context.run_state,
+            )
+        except requests.exceptions.HTTPError as e:
+            if e.response is None or e.response.status_code != HTTPStatus.NOT_FOUND:
+                raise
+            console.warning(f"Agent session {session_id} has expired; starting a new one.")
+            render_context.unit_tests_agent_session.reset()
+            return None
+
+    @staticmethod
+    def _build_task_params(
+        render_context: RenderContext, unittests_issue: str, conformance_tests_fixes: list[dict]
+    ) -> dict:
+        frid = render_context.frid_context.frid
+        specifications, _ = plain_spec.get_specifications_for_frid(render_context.plain_source_tree, frid)
+        context = render_context.unit_tests_running_context
+        # The files the conformance tests fixes changed are always seeded, so the agent sees what to preserve.
+        conformance_fix_files = {name for fix in conformance_tests_fixes for name in (fix or {}).get("code_diff") or {}}
+        task_params = {
+            "definitions": "\n".join(specifications.get(plain_spec.DEFINITIONS, [])),
+            "non_functional_requirements": "\n".join(specifications.get(plain_spec.NON_FUNCTIONAL_REQUIREMENTS, [])),
+            "functional_requirements": FixUnitTests._functional_requirements_section(render_context, specifications),
+            "linked_resources": render_context.frid_context.linked_resources,
+            "build_folder": render_context.build_folder,
+            "module_name": render_context.module_name,
+            "unittests_script_content": FixUnitTests._read_script(render_context.unittests_script),
+            "unittests_issue": unittests_issue,
+            "unittests_log_path": render_context.script_execution_history.latest_unit_test_output_path,
+            "file_tree": FixUnitTests._file_tree(render_context.build_folder),
+            "relevant_files": FixUnitTests._relevant_files(
+                render_context.build_folder,
+                render_context.frid_context.changed_files | context.changed_files | conformance_fix_files,
+            ),
+        }
+        if conformance_tests_fixes:
+            task_params["conformance_tests_fixes"] = conformance_tests_fixes
+        session = render_context.unit_tests_agent_session
+        if session.previous_session_id:
+            task_params["previous_session_id"] = session.previous_session_id
+        return task_params
+
+    @staticmethod
+    def _file_tree(build_folder: str) -> str:
+        paths = []
+        for root, dirs, files in os.walk(build_folder):
+            dirs[:] = sorted(d for d in dirs if d not in agent_tools.GREP_EXCLUDED_DIRS and not d.startswith("."))
+            paths.extend(os.path.relpath(os.path.join(root, name), build_folder) for name in sorted(files))
+            if len(paths) > MAX_FILE_TREE_ENTRIES:
+                return "\n".join(paths[:MAX_FILE_TREE_ENTRIES]) + "\n... [more files not listed]"
+        return "\n".join(paths)
+
+    @staticmethod
+    def _relevant_files(build_folder: str, file_names: set[str]) -> dict[str, str]:
+        """Contents of the given build-relative files, smallest first, within MAX_RELEVANT_FILES_CHARS."""
+        contents = {}
+        for name in file_names:
+            full_path = os.path.join(build_folder, name)
+            if os.path.isfile(full_path):
+                with open(full_path, "r", encoding="utf-8", errors="replace") as f:
+                    contents[name] = f.read()
+        relevant, total = {}, 0
+        for name in sorted(contents, key=lambda n: (len(contents[n]), n)):
+            if total + len(contents[name]) > MAX_RELEVANT_FILES_CHARS:
+                break
+            relevant[name] = contents[name]
+            total += len(contents[name])
+        return dict(sorted(relevant.items()))
+
+    @staticmethod
+    def _functional_requirements_section(render_context: RenderContext, specifications: dict) -> str:
+        sections = []
+        for module_name, functionalities in render_context.get_required_modules_functionalities().items():
+            sections.append(
+                f"### Module: {module_name} (Already Implemented, for context)\n" + "\n".join(functionalities)
+            )
+        current = specifications.get(plain_spec.FUNCTIONAL_REQUIREMENTS, [])
+        if len(current) > 1:
+            sections.append(
+                f"### Module: {render_context.module_name} (Already Implemented, for context)\n"
+                + "\n".join(current[:-1])
+            )
+        if current:
+            sections.append(f"### Module: {render_context.module_name} (Currently Being Implemented)\n{current[-1]}")
+        return "\n\n".join(sections)
+
+    @staticmethod
+    def _read_script(script: str | None) -> str:
+        if not script:
+            return ""
+        try:
+            with open(file_utils.add_current_path_if_no_path(script), "r", encoding="utf-8") as f:
+                return f.read()
+        except OSError:
+            return ""

{codeplain-0.3.11.dev19 → codeplain-0.3.11.dev20}/render_machine/actions/run_unit_tests.py

@@ -16,6 +16,15 @@ class RunUnitTests(BaseAction):
     UNRECOVERABLE_ERROR_OUTCOME = "unrecoverable_error_occurred"
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        context = render_context.unit_tests_running_context
+        if context.verified_passing:
+            # The fixing agent's own run passed and no file changed since; running again is redundant.
+            context.verified_passing = False
+            console.info("Unit tests already passed in the fixing agent's last run; not running them again.")
+            render_context.script_execution_history.latest_unit_test_output_path = context.verified_passing_log_path
+            render_context.script_execution_history.should_update_script_outputs = True
+            return self.SUCCESSFUL_OUTCOME, None
+
         unittests_script = os.path.normpath(render_context.unittests_script)
 
         console.info(

codeplain-0.3.11.dev20/render_machine/agent_tools.py

@@ -0,0 +1,270 @@
+"""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

{codeplain-0.3.11.dev19 → codeplain-0.3.11.dev20}/render_machine/render_context.py

@@ -19,6 +19,7 @@ from render_machine.render_types import (
     FridContext,
     ScriptExecutionHistory,
     TestExecutionPhase,
+    UnitTestsAgentSession,
     UnitTestsRunningContext,
 )
 
@@ -188,6 +189,14 @@ class RenderContext:
     def should_run_conformance_tests(self) -> bool:
         return self.conformance_tests_script is not None
 
+    @property
+    def unit_tests_agent_session(self) -> UnitTestsAgentSession:
+        """The agent session fixing the unit tests: per unit-test loop, except during the conformance
+        phase, where one session spans every loop (see UnitTestsAgentSession)."""
+        if self.conformance_tests_running_context is not None:
+            return self.conformance_tests_running_context.unit_tests_agent_session
+        return self.unit_tests_running_context.agent_session
+
     def start_unittests_processing(self):
         self.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
         self.run_state.increment_unittest_batch_id()