codeplain 0.3.10.dev3__tar.gz → 0.3.10.dev5__tar.gz

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/PKG-INFO

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

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/codeplain_REST_api.py

@@ -254,7 +254,7 @@ class CodeplainAPI:
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
-    def create_conformance_test_memory(
+    def distill_conformance_test_memory(
         self,
         frid,
         plain_source_tree,
@@ -263,15 +263,10 @@ class CodeplainAPI:
         memory_files_content,
         module_name,
         required_modules,
-        code_diff,
-        conformance_tests_files,
-        acceptance_tests,
-        conformance_tests_issue,
-        conformance_tests_folder_name,
-        previous_conformance_tests_issue_old,
+        fix_journals,
         run_state: RunState,
     ):
-        endpoint_url = f"{self.api_url}/create_conformance_test_memory"
+        endpoint_url = f"{self.api_url}/distill_conformance_test_memory"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
 
         payload = {
@@ -282,12 +277,7 @@ class CodeplainAPI:
             "memory_files_content": memory_files_content,
             "module_name": module_name,
             "required_modules": required_modules,
-            "code_diff": code_diff,
-            "conformance_tests_files": conformance_tests_files,
-            "acceptance_tests": acceptance_tests,
-            "conformance_tests_issue": conformance_tests_issue,
-            "conformance_tests_folder_name": conformance_tests_folder_name,
-            "previous_conformance_tests_issue": previous_conformance_tests_issue_old,
+            "fix_journals": fix_journals,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)
@@ -381,6 +371,7 @@ class CodeplainAPI:
         conformance_tests_folder_name,
         current_testing_frid_high_level_implementation_plan: Optional[str],
         conflicting_requirements_count: int,
+        fix_attempts_journal: list,
         run_state: RunState,
     ):
         endpoint_url = f"{self.api_url}/fix_conformance_tests_issue"
@@ -403,6 +394,7 @@ class CodeplainAPI:
             "conformance_tests_folder_name": conformance_tests_folder_name,
             "current_testing_frid_high_level_implementation_plan": current_testing_frid_high_level_implementation_plan,
             "conflicting_requirements_count": conflicting_requirements_count,
+            "fix_attempts_journal": fix_attempts_journal,
         }
 
         if acceptance_tests is not None:

codeplain-0.3.10.dev5/conformance_fix_journal.py

@@ -0,0 +1,207 @@
+"""Deterministic journal of conformance tests fix attempts.
+
+While a functionality's conformance tests are failing, every fix attempt is recorded here: the
+issue that triggered it, what the fixer said it tried, which files it changed and whether the tests
+passed afterwards. A digest of the journal is sent back with every fix request so the fixer does
+not repeat attempts that already failed, and once the functionality's conformance tests all pass
+the journal is distilled into durable memories and deleted.
+
+Each entry carries the issue in two forms: the raw script output (kept untruncated, on disk only)
+and the prepared form the server built for the fix prompt (trimmed, and summarized or truncated
+when oversized) - the issue exactly the way the fixer saw it. The prepared form is what travels in
+the fix digest and the distillation payload; the raw form exists for humans debugging a render.
+An attempt's outcome text is not stored twice: the output produced after an attempt is the raw
+issue of the next attempt.
+
+Journals are keyed by the (module, frid) whose tests are being fixed - during the regression sweep
+that can be a previously implemented functionality, possibly from a required module.
+"""
+
+import hashlib
+import json
+import os
+import shutil
+
+from plain2code_console import console
+
+CONFORMANCE_TEST_JOURNAL_SUBFOLDER = "conformance_test_journal"
+
+# Cap for the issue excerpts included in payloads (the per-attempt issue in the fix digest, and the
+# initial issue in the distillation payload). The server-prepared issue is already bounded (LLM
+# summary or ~10k-char truncation), so this only trims the rare oversized case - it must not
+# routinely cut into summaries the server already sized for a prompt.
+MAX_ISSUE_EXCERPT_CHARS = 8000
+
+# The keys of a journal entry that make up the digest sent to the fixer and the distiller.
+DIGEST_KEYS = ["attempt", "hypothesis", "approach", "target", "files_changed", "duplicate_of", "result"]
+
+
+def _trim_issue(issue: str | None, max_chars: int) -> str | None:
+    if issue is None or len(issue) <= max_chars:
+        return issue
+    return f"(TRUNCATED - showing the last {max_chars} characters)\n" + issue[-max_chars:]
+
+
+def normalized_diff_hash(diff_files: dict[str, str] | None) -> str | None:
+    """Hashes a fix's diff so that essentially identical retries can be detected.
+
+    Whitespace-only differences are ignored - a fix that reproduces an earlier failed change with
+    different formatting is still the same attempt.
+    """
+    if not diff_files:
+        return None
+
+    normalized_parts = []
+    for file_name in sorted(diff_files):
+        content_lines = [line.strip() for line in (diff_files[file_name] or "").splitlines() if line.strip()]
+        normalized_parts.append(file_name + "\n" + "\n".join(content_lines))
+
+    return hashlib.sha256("\n".join(normalized_parts).encode("utf-8")).hexdigest()
+
+
+class FixAttemptJournal:
+    """File-backed journal, one JSONL file per (module, frid) whose conformance tests are fixed."""
+
+    def __init__(self, memory_folder: str):
+        self.journal_folder = os.path.join(memory_folder, CONFORMANCE_TEST_JOURNAL_SUBFOLDER)
+
+    def _journal_path(self, module_name: str, frid: str) -> str:
+        return os.path.join(self.journal_folder, f"{module_name}__{frid}.jsonl")
+
+    def _read_entries(self, module_name: str, frid: str) -> list[dict]:
+        journal_path = self._journal_path(module_name, frid)
+        if not os.path.exists(journal_path):
+            return []
+
+        entries = []
+        with open(journal_path, "r", encoding="utf-8") as journal_file:
+            for line in journal_file:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    console.error(f"Skipping malformed journal entry in {journal_path}.")
+
+        return entries
+
+    def _write_entries(self, module_name: str, frid: str, entries: list[dict]):
+        os.makedirs(self.journal_folder, exist_ok=True)
+        with open(self._journal_path(module_name, frid), "w", encoding="utf-8") as journal_file:
+            for entry in entries:
+                journal_file.write(json.dumps(entry) + "\n")
+
+    def open_attempt(self, module_name: str, frid: str, attempt_no: int, issue_before: str):
+        """Starts a new journal entry for a fix attempt that is about to be made.
+
+        The raw issue is stored untruncated - it never travels in a payload, only its prepared form
+        (recorded later by record_fix) does.
+        """
+        entries = self._read_entries(module_name, frid)
+        entries.append({"attempt": attempt_no, "issue_before_raw": issue_before})
+        self._write_entries(module_name, frid, entries)
+
+    def record_fix(
+        self,
+        module_name: str,
+        frid: str,
+        fix_attempt_summary: dict | None,
+        files_changed: list[str],
+        target: str,
+        diff_files: dict[str, str] | None,
+        prepared_issue: str | None,
+    ):
+        """Completes the open attempt with what the fix actually did.
+
+        The prepared issue is the form the server built for the fix prompt - the issue exactly the
+        way the fixer saw it. The diff hash marks the attempt as a duplicate when an earlier attempt
+        in the same journal produced essentially the same change - the strongest signal that the
+        fixer is going in circles.
+        """
+        entries = self._read_entries(module_name, frid)
+        if not entries:
+            console.error("Cannot record a fix - no journal entry is open.")
+            return
+
+        entry = entries[-1]
+        if isinstance(fix_attempt_summary, dict):
+            entry["hypothesis"] = fix_attempt_summary.get("hypothesis")
+            entry["approach"] = fix_attempt_summary.get("approach")
+        if prepared_issue:
+            entry["issue_before"] = prepared_issue
+        entry["files_changed"] = sorted(files_changed)
+        entry["target"] = target
+
+        diff_hash = normalized_diff_hash(diff_files)
+        entry["diff_hash"] = diff_hash
+        if diff_hash is not None:
+            for earlier_entry in entries[:-1]:
+                if earlier_entry.get("diff_hash") == diff_hash:
+                    entry["duplicate_of"] = earlier_entry["attempt"]
+                    break
+
+        self._write_entries(module_name, frid, entries)
+
+    def record_result(self, module_name: str, frid: str, passed: bool):
+        """Records whether the conformance tests passed after the last fix attempt was applied.
+
+        A failed run's output is not stored here - it becomes the raw issue of the next attempt.
+        Does nothing when no attempt is pending: the first test run of a functionality has no fix
+        attempt behind it.
+        """
+        entries = self._read_entries(module_name, frid)
+        if not entries or "result" in entries[-1]:
+            return
+
+        entries[-1]["result"] = "conformance tests passed" if passed else "conformance tests still failed"
+        self._write_entries(module_name, frid, entries)
+
+    def build_digest(self, module_name: str, frid: str) -> list[dict]:
+        """Builds the compact attempt history sent with a fix request.
+
+        Only attempts whose fix has been recorded are included - the entry just opened for the
+        attempt being made (and any dangling entry an interrupted render left behind) carries no
+        information for the fixer. Each included attempt carries the prepared issue it addressed,
+        so the fixer can see how the issue evolved across attempts. Raw outputs never travel - the
+        current issue is sent with the request separately.
+        """
+        return [self._digest_entry(entry) for entry in self._read_entries(module_name, frid) if "target" in entry]
+
+    @staticmethod
+    def _digest_entry(entry: dict) -> dict:
+        digest_entry = {key: entry[key] for key in DIGEST_KEYS if key in entry}
+        if entry.get("issue_before"):
+            digest_entry["issue"] = _trim_issue(entry["issue_before"], MAX_ISSUE_EXCERPT_CHARS)
+        return digest_entry
+
+    def collect_all(self) -> list[dict]:
+        """Collects the digests of every journal, keyed by the tested module and frid, for distillation."""
+        if not os.path.exists(self.journal_folder):
+            return []
+
+        journals = []
+        for file_name in sorted(os.listdir(self.journal_folder)):
+            if not file_name.endswith(".jsonl") or "__" not in file_name:
+                continue
+            module_name, _, frid = file_name[: -len(".jsonl")].rpartition("__")
+            entries = [entry for entry in self._read_entries(module_name, frid) if "target" in entry]
+            if not entries:
+                continue
+            initial_issue = entries[0].get("issue_before") or _trim_issue(
+                entries[0].get("issue_before_raw"), MAX_ISSUE_EXCERPT_CHARS
+            )
+            journal = {
+                "module": module_name,
+                "frid": frid,
+                "initial_issue": initial_issue,
+                "attempts": [self._digest_entry(entry) for entry in entries],
+            }
+            journals.append(journal)
+
+        return journals
+
+    def clear_all(self):
+        """Deletes every journal. Called after the journals have been distilled into memories."""
+        if os.path.exists(self.journal_folder):
+            shutil.rmtree(self.journal_folder)

codeplain-0.3.10.dev5/memory_management.py

@@ -0,0 +1,52 @@
+import os
+
+import file_utils
+from conformance_fix_journal import FixAttemptJournal
+from plain2code_console import console
+
+CONFORMANCE_TEST_MEMORY_SUBFOLDER = "conformance_test_memory"
+
+
+class MemoryManager:
+    """Manages a module's memory store at <build>/<module>/.memory.
+
+    The distilled memories are inherited by the next module in the chain (copied over when its
+    render starts, like the code repo), so learnings travel across modules.
+    """
+
+    @staticmethod
+    def fetch_memory_files(memory_folder: str) -> tuple[list[str], dict[str, str]]:
+        """Fetch memory files from memory_folder/conformance_test_memory."""
+        memory_path = os.path.join(memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        if not os.path.exists(memory_path):
+            return [], {}
+        memory_files = file_utils.list_all_text_files(memory_path)
+        memory_files_content = file_utils.get_existing_files_content(memory_path, memory_files)
+        console.debug(f"Loaded {len(memory_files_content)} memory files.")
+        return memory_files, memory_files_content
+
+    def __init__(self, codeplain_api, memory_folder: str):
+        self.codeplain_api = codeplain_api
+        self.memory_folder = memory_folder
+        self.journal = FixAttemptJournal(memory_folder)
+
+    def store_memory_files(self, response_files: dict[str, str]):
+        """Stores distilled memory files, applying deletions (None content) to existing memories."""
+        memory_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        memory_files, _ = MemoryManager.fetch_memory_files(self.memory_folder)
+        file_utils.store_response_files(memory_path, response_files, memory_files)
+
+    @staticmethod
+    def inherit_memories(source_memory_folder: str, destination_memory_folder: str):
+        """Copies the distilled memories of a previously rendered module into this module's store.
+
+        Only the distilled memories travel - fix attempt journals are transient state of one
+        module's render. A previous module without memories (e.g. shipped as an archive that
+        carries only code) is a no-op.
+        """
+        source_path = os.path.join(source_memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        if not os.path.isdir(source_path):
+            return
+        file_utils.copy_folder_content(
+            source_path, os.path.join(destination_memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        )

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/plain2code.py

@@ -203,6 +203,15 @@ def warn_if_acceptance_tests_without_conformance_script(plain_module, args) -> N
     )
 
 
+def validate_linked_resources(plain_module) -> None:
+    """Load every linked resource exactly the way rendering does, so dry-run
+    surfaces the same errors (binary file, missing file, oversized base64 blob)."""
+    for module in plain_module.all_required_modules + [plain_module]:
+        resources_list: list[dict] = []
+        plain_spec.collect_linked_resources(module.plain_source, resources_list, None, True)
+        file_utils.load_linked_resources(module.template_dirs, resources_list, module.module_name)
+
+
 def render(  # noqa: C901
     plain_module: plain_modules.PlainModule,
     args,
@@ -393,6 +402,12 @@ def main():  # noqa: C901
         return
 
     if args.dry_run:
+        try:
+            validate_linked_resources(plain_module)
+        except Exception as e:
+            console.error(f"Error: {str(e)}")
+            return
+
         console.info("Printing dry run output...\n")
         render_range = plain_spec.compute_render_range(args, plain_module.plain_source)
         print_dry_run_output(plain_module.plain_source, render_range)

codeplain-0.3.10.dev5/render_machine/actions/distill_conformance_test_memory.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+from plain2code_console import console
+from render_machine.actions.base_action import BaseAction
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
+from render_machine.render_context import RenderContext
+
+
+class DistillConformanceTestMemory(BaseAction):
+    """Distills the conformance tests fix journals into durable memories once all tests pass.
+
+    Runs exactly once per functional requirement, as the first postprocessing step. When no fix
+    attempts were needed there is nothing to distill and no API call is made. Distillation is best
+    effort - a failure must never fail the render, so the journals are kept for the next
+    distillation instead.
+
+    The memories land in the module's own memory store and are inherited by the next module in the
+    chain when its render starts.
+    """
+
+    SUCCESSFUL_OUTCOME = "conformance_test_memory_distilled"
+
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        journal = render_context.memory_manager.journal
+        fix_journals = journal.collect_all()
+        if not fix_journals:
+            return self.SUCCESSFUL_OUTCOME, None
+
+        console.info(f"Distilling conformance test fix learnings for functionality {render_context.frid_context.frid}.")
+
+        try:
+            _, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(render_context.build_folder)
+            _, memory_files_content = render_context.memory_manager.fetch_memory_files(
+                render_context.memory_manager.memory_folder
+            )
+
+            response_files = render_context.codeplain_api.distill_conformance_test_memory(
+                frid=render_context.frid_context.frid,
+                plain_source_tree=render_context.plain_source_tree,
+                linked_resources=render_context.frid_context.linked_resources,
+                existing_files_content=existing_files_content,
+                memory_files_content=memory_files_content,
+                module_name=render_context.module_name,
+                required_modules=render_context.get_required_modules_functionalities(),
+                fix_journals=fix_journals,
+                run_state=render_context.run_state,
+            )
+
+            if response_files:
+                render_context.memory_manager.store_memory_files(response_files)
+        except Exception as e:
+            console.error(f"Failed to distill conformance test memory (keeping the journals): {e}")
+            return self.SUCCESSFUL_OUTCOME, None
+
+        journal.clear_all()
+        return self.SUCCESSFUL_OUTCOME, None

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/render_machine/actions/fix_conformance_test.py

@@ -54,14 +54,13 @@ class FixConformanceTest(BaseAction):
             )
         previous_conformance_tests_issue = previous_action_payload["previous_conformance_tests_issue"]
 
-        render_context.conformance_tests_running_context.previous_conformance_tests_issue_old = (
-            previous_conformance_tests_issue
-        )
-        render_context.conformance_tests_running_context.previous_conformance_tests_issue_frid = (
-            render_context.conformance_tests_running_context.current_testing_frid
-        )
-        render_context.conformance_tests_running_context.previous_conformance_tests_issue_module = (
-            render_context.conformance_tests_running_context.current_testing_module_name
+        journal = render_context.memory_manager.journal
+        journal.record_result(ctx.current_testing_module_name, ctx.current_testing_frid, passed=False)
+        journal.open_attempt(
+            ctx.current_testing_module_name,
+            ctx.current_testing_frid,
+            ctx.fix_attempts,
+            previous_conformance_tests_issue,
         )
 
         existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
@@ -114,25 +113,28 @@ class FixConformanceTest(BaseAction):
             style=console.INPUT_STYLE,
         )
 
-        [issue_reason_code, response_files] = render_context.codeplain_api.fix_conformance_tests_issue(
-            render_context.frid_context.frid,
-            render_context.conformance_tests_running_context.current_testing_frid,
-            render_context.plain_source_tree,
-            render_context.frid_context.linked_resources,
-            existing_files_content,
-            memory_files_content,
-            render_context.module_name,
-            render_context.conformance_tests_running_context.current_testing_module_name,
-            render_context.get_required_modules_functionalities(),
-            previous_frid_code_diff,
-            existing_conformance_test_files_content,
-            render_context.conformance_tests_running_context.get_current_acceptance_tests(),
-            previous_conformance_tests_issue,
-            render_context.conformance_tests_running_context.fix_attempts,
-            render_context.conformance_tests_running_context.get_current_conformance_test_folder_name(),
-            render_context.conformance_tests_running_context.current_testing_frid_high_level_implementation_plan,
-            render_context.conformance_tests_running_context.conflicting_requirement_count,
-            run_state=render_context.run_state,
+        [issue_reason_code, response_files, fix_attempt_summary, prepared_conformance_tests_issue] = (
+            render_context.codeplain_api.fix_conformance_tests_issue(
+                render_context.frid_context.frid,
+                render_context.conformance_tests_running_context.current_testing_frid,
+                render_context.plain_source_tree,
+                render_context.frid_context.linked_resources,
+                existing_files_content,
+                memory_files_content,
+                render_context.module_name,
+                render_context.conformance_tests_running_context.current_testing_module_name,
+                render_context.get_required_modules_functionalities(),
+                previous_frid_code_diff,
+                existing_conformance_test_files_content,
+                render_context.conformance_tests_running_context.get_current_acceptance_tests(),
+                previous_conformance_tests_issue,
+                render_context.conformance_tests_running_context.fix_attempts,
+                render_context.conformance_tests_running_context.get_current_conformance_test_folder_name(),
+                render_context.conformance_tests_running_context.current_testing_frid_high_level_implementation_plan,
+                render_context.conformance_tests_running_context.conflicting_requirement_count,
+                journal.build_digest(ctx.current_testing_module_name, ctx.current_testing_frid),
+                run_state=render_context.run_state,
+            )
         )
         code_diff_files_content = {}
 
@@ -159,14 +161,21 @@ class FixConformanceTest(BaseAction):
                 existing_conformance_test_files,
             )
             code_diff_files_content = diff_utils.get_code_diff(response_files, existing_conformance_test_files_content)
-            render_context.conformance_tests_running_context.code_diff_files = code_diff_files_content
+            journal.record_fix(
+                ctx.current_testing_module_name,
+                ctx.current_testing_frid,
+                fix_attempt_summary,
+                list(response_files),
+                "CONFORMANCE_TESTS",
+                code_diff_files_content,
+                prepared_conformance_tests_issue,
+            )
 
             return self.IMPLEMENTATION_CODE_NOT_UPDATED, None
         else:
             if len(response_files) > 0:
                 file_utils.store_response_files(render_context.build_folder, response_files, existing_files)
                 code_diff_files_content = diff_utils.get_code_diff(response_files, existing_files_content)
-                render_context.conformance_tests_running_context.code_diff_files = code_diff_files_content
                 console.print_files(
                     "Files fixed:",
                     render_context.build_folder,
@@ -180,6 +189,26 @@ class FixConformanceTest(BaseAction):
                 ctx.test_that_triggered_code_change = (ctx.current_testing_module_name, ctx.current_testing_frid)
                 ctx.execution_phase = TestExecutionPhase.RETRYING_AFTER_CODE_CHANGE
 
+                journal.record_fix(
+                    ctx.current_testing_module_name,
+                    ctx.current_testing_frid,
+                    fix_attempt_summary,
+                    list(response_files),
+                    "IMPLEMENTATION_CODE",
+                    code_diff_files_content,
+                    prepared_conformance_tests_issue,
+                )
+
                 return self.IMPLEMENTATION_CODE_UPDATED, None
             else:
+                journal.record_fix(
+                    ctx.current_testing_module_name,
+                    ctx.current_testing_frid,
+                    fix_attempt_summary,
+                    [],
+                    "IMPLEMENTATION_CODE",
+                    None,
+                    prepared_conformance_tests_issue,
+                )
+
                 return self.IMPLEMENTATION_CODE_NOT_UPDATED, None

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/render_machine/actions/prepare_repositories.py

@@ -3,6 +3,7 @@ from typing import Any
 import file_utils
 import git_utils
 import plain_spec
+from memory_management import MemoryManager
 from plain2code_console import console
 from render_machine.actions.base_action import BaseAction
 from render_machine.render_context import RenderContext
@@ -50,6 +51,13 @@ class PrepareRepositories(BaseAction):
                     render_context.module_name,
                     render_context.run_state.render_id,
                 )
+
+                # Like the code repo, the distilled conformance test memories carry over from the
+                # previous module so its learnings are available while rendering this one.
+                MemoryManager.inherit_memories(
+                    previous_module.module_memory_folder,
+                    render_context.plain_module.module_memory_folder,
+                )
             else:
                 console.debug("Initializing git repositories for the render folders.")
 

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/render_machine/actions/run_conformance_tests.py

@@ -54,18 +54,12 @@ class RunConformanceTests(BaseAction):
         )
         render_context.script_execution_history.should_update_script_outputs = True
 
-        render_context.memory_manager.create_conformance_tests_memory(
-            render_context, exit_code, conformance_tests_issue
-        )
-
         if exit_code == 0:
-            if (
-                render_context.conformance_tests_running_context.current_testing_module_name
-                == render_context.module_name
-                and render_context.conformance_tests_running_context.current_testing_frid
-                == render_context.frid_context.frid
-            ):
-                render_context.memory_manager.delete_unresolved_memory_files()
+            render_context.memory_manager.journal.record_result(
+                render_context.conformance_tests_running_context.current_testing_module_name,
+                render_context.conformance_tests_running_context.current_testing_frid,
+                passed=True,
+            )
             return self.SUCCESSFUL_OUTCOME, None
 
         if exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/render_machine/render_types.py

@@ -90,10 +90,6 @@ class ConformanceTestsRunningContext:
         self.regenerating_conformance_tests: bool = False
 
         self.current_testing_frid_high_level_implementation_plan: Optional[str] = None
-        self.previous_conformance_tests_issue_old: Optional[str] = None
-        self.previous_conformance_tests_issue_frid: Optional[str] = None
-        self.previous_conformance_tests_issue_module: Optional[str] = None
-        self.code_diff_files: Optional[dict[str, str]] = None
 
     def get_conformance_tests_json(self, module_name: str) -> dict:
         return self._conformance_tests_json[module_name]

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/render_machine/state_machine_config.py

@@ -13,6 +13,7 @@ from render_machine.actions.analyze_specification_ambiguity import AnalyzeSpecif
 from render_machine.actions.commit_conformance_tests_changes import CommitConformanceTestsChanges
 from render_machine.actions.commit_implementation_code_changes import CommitImplementationCodeChanges
 from render_machine.actions.create_dist import CreateDist
+from render_machine.actions.distill_conformance_test_memory import DistillConformanceTestMemory
 from render_machine.actions.exit_with_error import ExitWithError
 from render_machine.actions.finish_functional_requirement import FinishFunctionalRequirement
 from render_machine.actions.fix_conformance_test import FixConformanceTest
@@ -52,6 +53,7 @@ class StateMachineConfig:
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TEST_GENERATED.value}": PrepareTestingEnvironment(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TEST_ENV_PREPARED.value}": RunConformanceTests(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TEST_FAILED.value}": FixConformanceTest(),
+            f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value}": DistillConformanceTestMemory(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value}": SummarizeConformanceTests(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_COMMIT.value}": CommitConformanceTestsChanges(
                 git_utils.CONFORMANCE_TESTS_PASSED_COMMIT_MESSAGE,
@@ -96,6 +98,7 @@ class StateMachineConfig:
             FixConformanceTest.REGENERATE_CONFORMANCE_TESTS_OUTCOME: triggers.MARK_REGENERATION_OF_CONFORMANCE_TESTS,
             CommitConformanceTestsChanges.SUCCESSFUL_OUTCOME_IMPLEMENTATION_UPDATED: triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
             CommitConformanceTestsChanges.SUCCESSFUL_OUTCOME_IMPLEMENTATION_NOT_UPDATED: triggers.PROCEED_FRID_PROCESSING,
+            DistillConformanceTestMemory.SUCCESSFUL_OUTCOME: triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
             SummarizeConformanceTests.SUCCESSFUL_OUTCOME: triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
             AnalyzeSpecificationAmbiguity.SUCCESSFUL_OUTCOME: triggers.PROCEED_FRID_PROCESSING,
         }
@@ -120,8 +123,9 @@ class StateMachineConfig:
     def get_postprocessing_conformance_tests_states(self) -> Dict[str, Any]:
         return {
             "name": States.POSTPROCESSING_CONFORMANCE_TESTS.value,
-            "initial": States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value,
+            "initial": States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value,
             "children": [
+                States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value,
                 States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value,
                 States.CONFORMANCE_TESTS_READY_FOR_COMMIT.value,
                 States.CONFORMANCE_TESTS_READY_FOR_AMBIGUITY_ANALYSIS.value,
@@ -278,6 +282,11 @@ class StateMachineConfig:
                 "trigger": triggers.MARK_ALL_CONFORMANCE_TESTS_PASSED,
                 "dest": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}",
             },
+            {
+                "source": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value}",
+                "trigger": triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
+                "dest": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value}",
+            },
             {
                 "source": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value}",
                 "trigger": triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,

{codeplain-0.3.10.dev3 → codeplain-0.3.10.dev5}/render_machine/states.py

@@ -44,6 +44,7 @@ class States(Enum):
 
     # Postprocessing conformance tests states
     POSTPROCESSING_CONFORMANCE_TESTS = "postprocessingConformanceTests"
+    CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION = "conformanceTestsReadyForMemoryDistillation"
     CONFORMANCE_TESTS_READY_FOR_SUMMARY = "conformanceTestsReadyForSummary"
     CONFORMANCE_TESTS_READY_FOR_COMMIT = "conformanceTestsReadyForCommit"
     CONFORMANCE_TESTS_READY_FOR_AMBIGUITY_ANALYSIS = "conformanceTestsReadyForAmbiguityAnalysis"