Regenerate a single functionality of a rendered project

.gitignore

@@ -30,3 +30,5 @@ dist
 
 .coverage
 logging_config.yaml
+
+.claude/worktrees/

codeplain_REST_api.py

@@ -266,6 +266,9 @@ def render_functional_requirement(
         required_modules: dict,
         include_unittests: bool,
         run_state: RunState,
+        is_regeneration: bool = False,
+        old_functional_requirement_text: Optional[str] = None,
+        code_functional_requirements: Optional[list] = None,
     ) -> dict[str, str]:
         """
         Renders the content of a functionality based on the provided ID,
@@ -305,8 +308,15 @@ def render_functional_requirement(
             "module_name": module_name,
             "required_modules": required_modules,
             "include_unittests": include_unittests,
+            "is_regeneration": is_regeneration,
         }
 
+        if old_functional_requirement_text is not None:
+            payload["old_functional_requirement_text"] = old_functional_requirement_text
+
+        if code_functional_requirements is not None:
+            payload["code_functional_requirements"] = code_functional_requirements
+
         return self.post_request(endpoint_url, headers, payload, run_state)
 
     def distill_conformance_test_memory(
@@ -365,6 +375,7 @@ def render_conformance_tests(
         conformance_tests_folder_name,
         conformance_tests_json,
         run_state: RunState,
+        is_regeneration: bool = False,
     ):
         endpoint_url = f"{self.api_url}/render_conformance_tests"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
@@ -380,6 +391,7 @@ def render_conformance_tests(
             "required_modules": required_modules,
             "conformance_tests_folder_name": conformance_tests_folder_name,
             "conformance_tests_json": conformance_tests_json,
+            "is_regeneration": is_regeneration,
         }
 
         response = self.post_request(endpoint_url, headers, payload, run_state)

git_utils.py

@@ -17,6 +17,7 @@
 # Following messages are used as checkpoints in the git history
 # Changing them will break backwards compatibility so change them with care
 FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE = "[Codeplain] functionality ID (FRID):{} fully implemented"
+FUNCTIONAL_REQUIREMENT_REGENERATED_COMMIT_MESSAGE = "[Codeplain] functionality ID (FRID):{} fully regenerated"
 INITIAL_COMMIT_MESSAGE = "[Codeplain] Initial module commit"
 BASE_FOLDER_COMMIT_MESSAGE = "[Codeplain] Initialize build with Base Folder content"
 
@@ -430,6 +431,10 @@ def get_last_rendered_functionality(repo_path: Union[str, os.PathLike]) -> tuple
         return None, None
 
     repo = Repo(repo_path)
+
+    # Only a "fully implemented" commit marks how far the module is rendered. A "fully regenerated"
+    # commit sits on top of that frontier, because a single functionality was rendered again in place.
+    # Treating it as the frontier would report the regenerated frid as the last rendered one.
     grep_pattern = FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE.format(".*")
     grep_pattern = grep_pattern.replace("[", "\\[").replace("]", "\\]")
     commit_sha = repo.git.rev_list(repo.active_branch.name, "--grep", grep_pattern, "-n", "1")

module_renderer.py

@@ -26,6 +26,7 @@ def __init__(
         event_bus: EventBus,
         stop_event: threading.Event | None = None,
         enter_pause_event: threading.Event | None = None,
+        is_regenerate: bool = False,
     ):
         self.codeplainAPI = codeplainAPI
         self.plain_module = plain_module
@@ -36,12 +37,14 @@ def __init__(
         self.event_bus = event_bus
         self.stop_event = stop_event
         self.enter_pause_event = enter_pause_event
+        self.is_regenerate = is_regenerate
 
     def _build_render_context_for_module(
         self,
         plain_module: PlainModule,
         memory_manager: MemoryManager,
         render_range: list[str] | None,
+        is_regenerate: bool,
     ) -> RenderContext:
         return RenderContext(
             self.codeplainAPI,
@@ -63,6 +66,7 @@ def _build_render_context_for_module(
             test_script_timeout=self.args.test_script_timeout,
             stop_event=self.stop_event,
             enter_pause_event=self.enter_pause_event,
+            is_regenerate=is_regenerate,
         )
 
     def _render_module(
@@ -83,6 +87,8 @@ def _render_module(
             render_range = self.render_choice.render_range
 
         if render_range is not None:
+            if self.is_regenerate:
+                plain_module.ensure_frid_can_be_regenerated(render_range[0])
             plain_module.ensure_previous_frid_commits_exist(render_range, self.args.render_conformance_tests)
 
         has_any_required_module_changed = False
@@ -121,10 +127,15 @@ def _render_module(
             self.codeplainAPI,
             plain_module.module_memory_folder,
         )
+        # Only the module that owns the target functionality is being regenerated. Required modules
+        # are rendered in full, so they must not take the regenerate path.
+        is_regenerate = self.is_regenerate and render_range is not None
+
         render_context = self._build_render_context_for_module(
             plain_module,
             memory_manager,
             render_range,
+            is_regenerate,
         )
 
         code_renderer = CodeRenderer(render_context)
@@ -139,7 +150,11 @@ def _render_module(
             code_renderer.render_context.event_bus.publish(RenderFailed(error_message=error_message))
             return False, True
 
-        plain_module.save_module_metadata()
+        # save_module_metadata records "the whole module matches the current spec". After a
+        # regenerate only one functionality was rendered, and FinishFunctionalRequirement already
+        # updated its metadata entry, so writing the whole baseline would claim too much.
+        if not is_regenerate:
+            plain_module.save_module_metadata()
 
         self.loaded_modules.append(plain_module)
 

plain2code.py

@@ -339,10 +339,23 @@ def render(  # noqa: C901
     event_bus: EventBus,
     default_log_level: str = "INFO",
 ):
-    # Compute render range from either --render-range or --render-from
+    # Compute render range from either --render-range, --render-from, or --regenerate
     render_range = None
-    if args.render_range or args.render_from:
-        render_range = plain_spec.compute_render_range(args, plain_module.plain_source)
+    is_regenerate = False
+    if args.render_range or args.render_from or args.regenerate:
+        if args.regenerate:
+            frids = list(plain_spec.get_frids(plain_module.plain_source))
+            if args.regenerate not in frids:
+                raise InvalidFridArgument(
+                    f"Cannot regenerate functionality {args.regenerate} because module {plain_module.module_name} "
+                    f"has no such functionality. Its functionalities are: {', '.join(frids)}."
+                )
+            render_range = plain_spec.get_render_range(
+                args.regenerate + "," + args.regenerate, plain_module.plain_source
+            )
+            is_regenerate = True
+        else:
+            render_range = plain_spec.compute_render_range(args, plain_module.plain_source)
 
     run_state.user_email = _check_connection(codeplainAPI)
 
@@ -369,7 +382,7 @@ def render(  # noqa: C901
         module.reconcile_metadata_with_git()
 
     render_choice = None
-    if render_range is None:
+    if render_range is None and not is_regenerate:
         plain_module_render_state = get_plain_module_render_state(plain_module, args.render_conformance_tests)
         if plain_module_render_state is not None:
             render_choices = get_render_choices(plain_module, plain_module_render_state, args.force_render)
@@ -418,6 +431,7 @@ def render(  # noqa: C901
         event_bus,
         stop_event=stop_event,
         enter_pause_event=enter_pause_event,
+        is_regenerate=is_regenerate,
     )
 
     render_error: list[Exception] = []

plain2code_arguments.py

@@ -346,6 +346,12 @@ def create_parser():
         help="Continue generation starting from this specific functionality (e.g. `add-task`). "
         "The functionality with this ID will be included in the output. The functionality ID must match one of the functionalities in your plain file.",
     )
+    render_range_group.add_argument(
+        "--regenerate",
+        type=frid_string,
+        help="Regenerate a single already-rendered functionality (e.g. `add-task`). "
+        "The functionality ID must match one of the functionalities in your plain file.",
+    )
 
     _add_arg(
         parser,

plain_modules.py

@@ -360,6 +360,11 @@ def update_frid_in_module_metadata(self, frid: str) -> None:
             functionalities.append(functionality)
         metadata[MODULE_FUNCTIONALITIES] = functionalities
 
+        # source_hash claims the code implements the whole spec, so only stamp it when that is
+        # true. Regenerating one functionality leaves the other functionalities as they were.
+        if self._metadata_matches_spec(metadata):
+            metadata["source_hash"] = self.get_module_source_hash()
+
         metadata_utils.write_metadata(self.module_metadata_path(), metadata)
 
     def _unique_chain(self) -> list[tuple[str, dict]]:
@@ -379,6 +384,13 @@ def _unique_chain(self) -> list[tuple[str, dict]]:
             chain.append((module.module_name, module.plain_source))
         return chain
 
+    def _metadata_matches_spec(self, metadata: dict) -> bool:
+        """Whether the given metadata already describes the module's current spec."""
+        if metadata.get(MODULE_FUNCTIONALITIES) != self._get_module_functional_requirements():
+            return False
+
+        return metadata.get("non_functional_source_hash") == self.get_module_non_functional_source_hash()
+
     def get_module_source_hash(self) -> str:
         return plain_spec.get_hash_value([self.plain_source] + self.resources_list)
 
@@ -562,6 +574,21 @@ def _ensure_frid_commit_exists(
                     f"  codeplain {self.module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION} --render-from {frid}"
                 )
 
+    def ensure_frid_can_be_regenerated(self, frid: str) -> None:
+        """Stop a regeneration of a functionality that was never fully rendered.
+
+        Only a rendered functionality can be generated again. This check runs before the required
+        modules are rendered, so a regeneration that cannot run uses no credits.
+        """
+        if not os.path.exists(self.module_build_folder) or not git_utils.has_commit_for_frid(
+            self.module_build_folder, frid, self.module_name
+        ):
+            raise MissingPreviousFunctionalitiesError(
+                f"Cannot regenerate functionality {frid} because it has not been fully rendered yet. "
+                f"Please render all functionalities first by running:\n"
+                f"  codeplain {self.module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION}"
+            )
+
     def ensure_previous_frid_commits_exist(self, render_range: list[str], render_conformance_tests: bool) -> None:
         """
         Ensure that all FRID commits before the render_range exist.

render_machine/actions/commit_conformance_tests_changes.py

@@ -10,9 +10,8 @@ class CommitConformanceTestsChanges(BaseAction):
     SUCCESSFUL_OUTCOME_IMPLEMENTATION_NOT_UPDATED = "conformance_tests_changes_committed_implementation_not_updated"
     SUCCESSFUL_OUTCOME_IMPLEMENTATION_UPDATED = "conformance_tests_changes_committed_implementation_updated"
 
-    def __init__(self, implementation_code_commit_message: str, conformance_tests_commit_message: str):
+    def __init__(self, implementation_code_commit_message: str):
         self.implementation_code_commit_message = implementation_code_commit_message
-        self.conformance_tests_commit_message = conformance_tests_commit_message
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         implementation_updated = False
@@ -26,8 +25,13 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
             )
             implementation_updated = True
 
+        conformance_tests_commit_message = (
+            git_utils.FUNCTIONAL_REQUIREMENT_REGENERATED_COMMIT_MESSAGE
+            if render_context.is_regenerate
+            else git_utils.FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE
+        )
         functional_requirement_text = render_context.frid_context.specifications[plain_spec.FUNCTIONAL_REQUIREMENTS][-1]
-        templated_functional_requirement_finished_commit_msg = self.conformance_tests_commit_message.format(
+        templated_functional_requirement_finished_commit_msg = conformance_tests_commit_message.format(
             render_context.frid_context.frid
         )
         formatted_conformance_commit_msg = (

render_machine/actions/exit_with_error.py

@@ -18,13 +18,14 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
         render_context.last_error_message = error_message
         console.error(error_message)
 
-        render_context.codeplain_api.fail_functional_requirement(
-            render_context.frid_context.frid,
-            module_name=render_context.module_name,
-            run_state=render_context.run_state,
-        )
-
+        # A render can fail before any functionality is started, for example when a regeneration is
+        # not possible. There is then no functionality to report as failed.
         if render_context.frid_context is not None:
+            render_context.codeplain_api.fail_functional_requirement(
+                render_context.frid_context.frid,
+                module_name=render_context.module_name,
+                run_state=render_context.run_state,
+            )
             console.info(
                 f"To continue rendering from the last successfully rendered functionality, "
                 f"provide the --render-from {render_context.frid_context.frid} flag."

render_machine/actions/finish_functional_requirement.py

@@ -1,16 +1,28 @@
 from typing import Any
 
-from render_machine.actions.commit_implementation_code_changes import CommitImplementationCodeChanges
+import git_utils
+from render_machine.actions.base_action import BaseAction
 from render_machine.render_context import RenderContext
 
 
-class FinishFunctionalRequirement(CommitImplementationCodeChanges):
+class FinishFunctionalRequirement(BaseAction):
     SUCCESSFUL_OUTCOME = "functional_requirement_finished"
 
-    def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         render_context.plain_module.update_frid_in_module_metadata(render_context.frid_context.frid)
 
-        super().execute(render_context, previous_action_payload)
+        commit_message = (
+            git_utils.FUNCTIONAL_REQUIREMENT_REGENERATED_COMMIT_MESSAGE
+            if render_context.is_regenerate
+            else git_utils.FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE
+        )
+        git_utils.add_all_files_and_commit(
+            render_context.build_folder,
+            commit_message.format(render_context.frid_context.frid),
+            render_context.module_name,
+            render_context.frid_context.frid,
+            render_context.run_state.render_id,
+        )
 
         render_context.codeplain_api.finish_functional_requirement(
             render_context.frid_context.frid,

render_machine/actions/fix_unit_tests.py

@@ -245,8 +245,27 @@ def _functional_requirements_section(render_context: RenderContext, specificatio
             )
         if current:
             sections.append(f"### Module: {render_context.module_name} (Currently Being Implemented)\n{current[-1]}")
+        later = FixUnitTests._functionalities_after_regenerated_one(render_context)
+        if later:
+            sections.append(
+                f"### Module: {render_context.module_name} (Already Implemented, for context)\n" + "\n".join(later)
+            )
         return "\n\n".join(sections)
 
+    @staticmethod
+    def _functionalities_after_regenerated_one(render_context: RenderContext) -> list[str]:
+        """The specs of the functionalities after the regenerated one, as their code implements them.
+
+        A regeneration renders one functionality again, and the functionalities after it keep their
+        code. Without their specs, the agent can change their code to agree with a wrong unit test.
+        """
+        if not render_context.is_regenerate:
+            return []
+        stored = render_context.plain_module.load_module_metadata()["functionalities"]
+        stored_frids = [functionality["id"] for functionality in stored]
+        position = stored_frids.index(render_context.frid_context.frid)
+        return [functionality["markdown"] for functionality in stored[position + 1 :]]
+
     @staticmethod
     def _read_script(script: str | None) -> str:
         if not script: