Carry the project lessons forward after the module folder is prepared

Inheritance never happened in a real render. Every module in the d365 chain
ended up with only the lessons it had learned itself, and none of the ones the
module before it had passed on.

The copy was made in the renderer, before the render started. The first action
of the render is PrepareRepositories, which deletes the module folder outright
to start it clean - and .memory lives inside that folder. So the file was
copied in, deleted seconds later, and the consolidating call at the end of the
first functionality wrote a fresh one containing only what that module had just
learned.

The copy now happens inside PrepareRepositories, immediately after the wipe it
has to survive. MemoryManager holds the predecessor's folder so it owns both
ends of the copy rather than being handed them.

The unit tests did not catch this because they only ever exercised the two
steps separately: resolving the predecessor, and copying between two folders.
Both were correct in isolation. There is now a test that runs PrepareRepositories
against a folder holding an inherited file and asserts the wipe still happens
and the file is still there afterwards; it fails if the call is removed.

That test is built on SimpleNamespace rather than MagicMock on purpose. A
MagicMock attribute satisfies os.fspath, so a path the test forgot to set turns
into a real directory named after the mock instead of an error - which is how an
earlier version of it quietly created a MagicMock/ tree in the repository root.

Author: VitjanZ

memory_management.py

@@ -60,37 +60,43 @@ def fetch_memory_files(memory_folder: str) -> tuple[list[str], dict[str, str]]:
         console.debug(f"Loaded {len(memory_files_content)} memory files.")
         return memory_files, memory_files_content
 
-    @staticmethod
-    def inherit_project_lessons(predecessor_memory_folder: Optional[str], memory_folder: str) -> None:
+    def inherit_project_lessons(self) -> None:
         """Carry the project lessons forward from the module rendered before this one.
 
         Copied rather than merged: the predecessor's file already contains everything inherited from further
         back, so one copy carries the whole chain. Overwriting is deliberate - the file is a snapshot of what
         the chain knew at this point, not an accumulation of this module's own history.
 
-        With no predecessor, or none that has a file, whatever is already here is left alone. That lets the
-        first module in a chain keep accumulating across renders, which is where a project's toolchain facts
-        get their first home.
+        Called once the module's folders have been prepared, not before. Preparing them deletes the module
+        folder outright, `.memory` included, so a copy made any earlier does not survive to be read.
         """
-        if not predecessor_memory_folder:
+        if not self.predecessor_memory_folder:
             return
 
-        source = os.path.join(predecessor_memory_folder, PROJECT_LESSONS_FILE_NAME)
+        source = os.path.join(self.predecessor_memory_folder, PROJECT_LESSONS_FILE_NAME)
         if not os.path.exists(source):
+            console.debug(f"No project lessons to inherit from {self.predecessor_memory_folder}.")
             return
 
-        destination = os.path.join(memory_folder, PROJECT_LESSONS_FILE_NAME)
+        destination = os.path.join(self.memory_folder, PROJECT_LESSONS_FILE_NAME)
         try:
-            os.makedirs(memory_folder, exist_ok=True)
+            os.makedirs(self.memory_folder, exist_ok=True)
             shutil.copyfile(source, destination)
             console.debug(f"Inherited project lessons from {source}.")
         except OSError as exception:
             console.debug(f"Could not inherit project lessons from {source}: {exception}.")
 
-    def __init__(self, codeplain_api, memory_folder: str, project_memory_folder: str):
+    def __init__(
+        self,
+        codeplain_api,
+        memory_folder: str,
+        project_memory_folder: str,
+        predecessor_memory_folder: Optional[str] = None,
+    ):
         self.codeplain_api = codeplain_api
         self.memory_folder = memory_folder
         self.project_memory_folder = project_memory_folder
+        self.predecessor_memory_folder = predecessor_memory_folder
 
     def consolidate_lessons(self, render_context: RenderContext) -> None:
         """Extract what transfers to later functionalities, then discard the journal it came from.

module_renderer.py

@@ -141,9 +141,7 @@ def _render_module(
             self.codeplainAPI,
             plain_module.module_memory_folder,
             plain_module.project_memory_folder,
-        )
-        MemoryManager.inherit_project_lessons(
-            self._predecessor_memory_folder(plain_module), plain_module.module_memory_folder
+            self._predecessor_memory_folder(plain_module),
         )
         render_context = self._build_render_context_for_module(
             plain_module,

render_machine/actions/prepare_repositories.py

@@ -35,6 +35,10 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
             file_utils.delete_folder(render_context.plain_module.module_folder)
             render_context.plain_module.seed_module_metadata()
 
+            # After the wipe, not before it: the module folder that was just deleted holds .memory, so the
+            # project lessons have to be carried forward once there is somewhere for them to live.
+            render_context.memory_manager.inherit_project_lessons()
+
             if render_context.required_modules:
                 previous_module = render_context.required_modules[-1]
                 console.debug(f"Cloning git repo from module {previous_module.module_name}.")

tests/test_prepare_repositories_layout.py

@@ -15,6 +15,7 @@
 
 import pytest
 
+from memory_management import MemoryManager
 from plain_modules import PlainModule
 from render_machine.actions.prepare_repositories import PrepareRepositories
 from render_machine.conformance_tests import CONFORMANCE_TESTS_DEFINITION_FILE_NAME, ConformanceTests
@@ -46,6 +47,11 @@ def _make_render_context(module: PlainModule, render_conformance_tests: bool) ->
         render_conformance_tests=render_conformance_tests,
         conformance_tests=ConformanceTests(module.build_folder, CONFORMANCE_TESTS_DEFINITION_FILE_NAME),
         base_folder=None,
+        # Preparing the folders is also where the project lessons are carried forward, since it is what
+        # deletes the folder they have to live in.
+        memory_manager=MemoryManager(
+            None, module.module_memory_folder, module.project_memory_folder, predecessor_memory_folder=None
+        ),
     )
 
 

tests/test_project_lessons_inheritance.py

@@ -8,12 +8,14 @@
 
 import json
 import os
+from types import SimpleNamespace
 from unittest.mock import MagicMock
 
 import pytest
 
 from memory_management import CONFORMANCE_TEST_LESSONS_FILE_NAME, PROJECT_LESSONS_FILE_NAME, MemoryManager
 from module_renderer import ModuleRenderer
+from render_machine.actions.prepare_repositories import PrepareRepositories
 
 POM_LESSON = {"lesson": "Conformance test projects must declare spring-boot-starter-parent.", "scope": "project"}
 BINDER_LESSON = {"lesson": "The SLF4J binder must be logback-classic.", "scope": "project"}
@@ -68,7 +70,7 @@ def test_a_module_inherits_the_project_lessons_of_the_one_before_it(tmp_path):
     predecessor, successor = str(tmp_path / "a"), str(tmp_path / "b")
     _write_lessons(predecessor, PROJECT_LESSONS_FILE_NAME, [POM_LESSON])
 
-    MemoryManager.inherit_project_lessons(predecessor, successor)
+    MemoryManager(MagicMock(), successor, successor, predecessor).inherit_project_lessons()
 
     assert _read_lessons(successor, PROJECT_LESSONS_FILE_NAME) == [POM_LESSON]
 
@@ -78,7 +80,7 @@ def test_inheriting_replaces_what_was_there_so_the_file_is_a_snapshot_of_the_cha
     _write_lessons(predecessor, PROJECT_LESSONS_FILE_NAME, [POM_LESSON])
     _write_lessons(successor, PROJECT_LESSONS_FILE_NAME, [BINDER_LESSON])
 
-    MemoryManager.inherit_project_lessons(predecessor, successor)
+    MemoryManager(MagicMock(), successor, successor, predecessor).inherit_project_lessons()
 
     assert _read_lessons(successor, PROJECT_LESSONS_FILE_NAME) == [POM_LESSON]
 
@@ -87,7 +89,7 @@ def test_the_module_own_lessons_are_not_inherited(tmp_path):
     predecessor, successor = str(tmp_path / "a"), str(tmp_path / "b")
     _write_lessons(predecessor, CONFORMANCE_TEST_LESSONS_FILE_NAME, [{"lesson": "about HttpClient"}])
 
-    MemoryManager.inherit_project_lessons(predecessor, successor)
+    MemoryManager(MagicMock(), successor, successor, predecessor).inherit_project_lessons()
 
     assert not os.path.exists(os.path.join(successor, CONFORMANCE_TEST_LESSONS_FILE_NAME))
 
@@ -98,15 +100,15 @@ def test_a_predecessor_that_learned_nothing_leaves_what_is_already_here_alone(tm
     os.makedirs(predecessor, exist_ok=True)
     _write_lessons(successor, PROJECT_LESSONS_FILE_NAME, [BINDER_LESSON])
 
-    MemoryManager.inherit_project_lessons(predecessor, successor)
+    MemoryManager(MagicMock(), successor, successor, predecessor).inherit_project_lessons()
 
     assert _read_lessons(successor, PROJECT_LESSONS_FILE_NAME) == [BINDER_LESSON]
 
 
 def test_the_first_module_in_the_chain_has_nothing_to_inherit(tmp_path):
     successor = str(tmp_path / "b")
 
-    MemoryManager.inherit_project_lessons(None, successor)
+    MemoryManager(MagicMock(), successor, successor, None).inherit_project_lessons()
 
     assert not os.path.exists(os.path.join(successor, PROJECT_LESSONS_FILE_NAME))
 
@@ -171,3 +173,45 @@ def test_a_module_outside_this_render_has_no_predecessor(chain):
     _, _, top = chain
 
     assert _renderer(top)._predecessor_memory_folder(_module("unrelated")) is None
+
+
+# --- the copy has to outlive the render's own setup --------------------------------------------------------
+
+
+def test_the_inherited_file_survives_preparing_the_module_folder(tmp_path):
+    """Preparing a module deletes its folder outright, .memory included.
+
+    The copy was originally made before the render started, which put it in the folder that the very first
+    action then deleted. Every module in the d365 chain ended up with only its own lessons, and nothing in the
+    unit tests noticed because none of them exercised the two steps together.
+
+    Built on SimpleNamespace rather than MagicMock deliberately: a MagicMock attribute satisfies os.fspath and
+    silently becomes a real directory, so a missing path reads as a passing test.
+    """
+    predecessor = str(tmp_path / "predecessor" / ".memory")
+    _write_lessons(predecessor, PROJECT_LESSONS_FILE_NAME, [POM_LESSON])
+
+    module_folder = tmp_path / "build" / "the_module"
+    memory_folder = module_folder / ".memory"
+    code_folder = module_folder / "code"
+    os.makedirs(str(memory_folder), exist_ok=True)
+    os.makedirs(str(code_folder), exist_ok=True)
+    # Something that must not survive the wipe, standing in for a previous render's output.
+    (code_folder / "stale.java").write_text("stale", encoding="utf-8")
+
+    render_context = SimpleNamespace(
+        render_range=None,
+        required_modules=[],
+        render_conformance_tests=False,
+        base_folder=None,
+        build_folder=str(code_folder),
+        module_name="the_module",
+        run_state=SimpleNamespace(render_id="test-render-id"),
+        plain_module=SimpleNamespace(module_folder=str(module_folder), seed_module_metadata=lambda: None),
+        memory_manager=MemoryManager(None, str(memory_folder), str(memory_folder), predecessor),
+    )
+
+    PrepareRepositories().execute(render_context, None)
+
+    assert not os.path.exists(str(code_folder / "stale.java")), "the wipe must still happen"
+    assert _read_lessons(str(memory_folder), PROJECT_LESSONS_FILE_NAME) == [POM_LESSON]