Rerender single functionality

.gitignore

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

codeplain_REST_api.py

@@ -180,6 +180,8 @@ def render_functional_requirement(
         required_modules: dict,
         include_unittests: bool,
         run_state: RunState,
+        is_reimplementation: bool = False,
+        old_functional_requirement_text: Optional[str] = None,
     ) -> dict[str, str]:
         """
         Renders the content of a functionality based on the provided ID,
@@ -219,8 +221,12 @@ def render_functional_requirement(
             "module_name": module_name,
             "required_modules": required_modules,
             "include_unittests": include_unittests,
+            "is_reimplementation": is_reimplementation,
         }
 
+        if old_functional_requirement_text is not None:
+            payload["old_functional_requirement_text"] = old_functional_requirement_text
+
         return self.post_request(endpoint_url, headers, payload, run_state)
 
     def fix_unittests_issue(
@@ -317,6 +323,7 @@ def render_conformance_tests(
         conformance_tests_json,
         all_acceptance_tests,
         run_state: RunState,
+        is_reimplementation: bool = False,
     ):
         endpoint_url = f"{self.api_url}/render_conformance_tests"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
@@ -333,6 +340,7 @@ def render_conformance_tests(
             "conformance_tests_folder_name": conformance_tests_folder_name,
             "conformance_tests_json": conformance_tests_json,
             "all_acceptance_tests": all_acceptance_tests,
+            "is_reimplementation": is_reimplementation,
         }
 
         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_REIMPLEMENTED_COMMIT_MESSAGE = "[Codeplain] functionality ID (FRID):{} fully reimplemented"
 INITIAL_COMMIT_MESSAGE = "[Codeplain] Initial module commit"
 BASE_FOLDER_COMMIT_MESSAGE = "[Codeplain] Initialize build with Base Folder content"
 
@@ -440,9 +441,23 @@ def get_last_rendered_functionality(repo_path: Union[str, os.PathLike]) -> tuple
         return None, None
 
     repo = Repo(repo_path)
-    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")
+
+    implemented_pattern = FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE.format(".*")
+    implemented_pattern = implemented_pattern.replace("[", "\\[").replace("]", "\\]")
+    implemented_sha = repo.git.rev_list(repo.active_branch.name, "--grep", implemented_pattern, "-n", "1")
+
+    reimplemented_pattern = FUNCTIONAL_REQUIREMENT_REIMPLEMENTED_COMMIT_MESSAGE.format(".*")
+    reimplemented_pattern = reimplemented_pattern.replace("[", "\\[").replace("]", "\\]")
+    reimplemented_sha = repo.git.rev_list(repo.active_branch.name, "--grep", reimplemented_pattern, "-n", "1")
+
+    # Pick the more recent of the two (rev-list outputs most-recent first)
+    if implemented_sha and reimplemented_sha:
+        all_shas = repo.git.rev_list(repo.active_branch.name).splitlines()
+        implemented_idx = all_shas.index(implemented_sha)
+        reimplemented_idx = all_shas.index(reimplemented_sha)
+        commit_sha = implemented_sha if implemented_idx < reimplemented_idx else reimplemented_sha
+    else:
+        commit_sha = implemented_sha or reimplemented_sha
 
     if not commit_sha:
         # Repo was interrupted during the first functionality, fallback to initial commit and provide only module name
@@ -469,7 +484,7 @@ def get_last_rendered_functionality(repo_path: Union[str, os.PathLike]) -> tuple
     if isinstance(commit_message, bytes):
         commit_message = commit_message.decode("utf-8")
 
-    match = re.search(r"FRID\):(\S+) fully implemented", commit_message)
+    match = re.search(r"FRID\):(\S+) fully (?:re)?implemented", commit_message)
     if not match:
         raise InvalidGitRepositoryError(
             "Git repository is in an invalid state. Could not find frid in finished commit."

module_renderer.py

@@ -27,6 +27,7 @@ def __init__(
         event_bus: EventBus,
         stop_event: threading.Event | None = None,
         enter_pause_event: threading.Event | None = None,
+        is_rerender: bool = False,
     ):
         self.codeplainAPI = codeplainAPI
         self.plain_module = plain_module
@@ -37,6 +38,7 @@ def __init__(
         self.event_bus = event_bus
         self.stop_event = stop_event
         self.enter_pause_event = enter_pause_event
+        self.is_rerender = is_rerender
 
     def _build_render_context_for_module(
         self,
@@ -65,6 +67,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_rerender=self.is_rerender,
         )
 
     def _render_module(

plain2code.py

@@ -139,12 +139,17 @@ def _check_connection(codeplainAPI: codeplain_api.CodeplainAPI):
 def render(args, run_state: RunState, event_bus: EventBus, default_log_level: str = "INFO"):  # noqa: C901
     template_dirs = file_utils.get_template_directories(args.filename, args.template_dir, DEFAULT_TEMPLATE_DIRS)
 
-    # Compute render range from either --render-range or --render-from
+    # Compute render range from either --render-range, --render-from, or --rerender
     render_range = None
-    if args.render_range or args.render_from:
+    is_rerender = False
+    if args.render_range or args.render_from or args.rerender:
         # Parse the plain file to get the plain_source for FRID extraction
         _, plain_source, _ = plain_file.plain_file_parser(args.filename, template_dirs)
-        render_range = plain_spec.compute_render_range(args, plain_source)
+        if args.rerender:
+            render_range = plain_spec.get_render_range(args.rerender + "," + args.rerender, plain_source)
+            is_rerender = True
+        else:
+            render_range = plain_spec.compute_render_range(args, plain_source)
 
     codeplainAPI = codeplain_api.CodeplainAPI(args.api_key, console)
     assert args.api is not None and args.api != "", "API URL is required"
@@ -164,7 +169,7 @@ def render(args, run_state: RunState, event_bus: EventBus, default_log_level: st
     )
 
     render_choice = None
-    if render_range is None:
+    if render_range is None and not is_rerender:
         plain_module_render_state = get_plain_module_render_state(plain_module)
         if plain_module_render_state is not None:
             render_choices = get_render_choices(plain_module, plain_module_render_state, args.force_render)
@@ -212,6 +217,7 @@ def render(args, run_state: RunState, event_bus: EventBus, default_log_level: st
         event_bus,
         stop_event=stop_event,
         enter_pause_event=enter_pause_event,
+        is_rerender=is_rerender,
     )
 
     render_error: list[Exception] = []

plain2code_arguments.py

@@ -226,6 +226,12 @@ def create_parser():
         help="Continue generation starting from this specific functionality (e.g. `2`). "
         "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(
+        "--rerender",
+        type=frid_string,
+        help="Re-render a single already-rendered functionality (e.g. `2`). "
+        "Only top-level integer FRIDs are supported.",
+    )
 
     parser.add_argument(
         "--force-render",

plain_modules.py

@@ -108,6 +108,23 @@ def load_module_metadata(self) -> dict | None:
         with open(metadata_path, "r", encoding="utf-8") as f:
             return json.load(f)
 
+    def update_frid_in_module_metadata(self, frid: str, frid_text: str, update_source_hash: bool = False) -> None:
+        metadata = self.load_module_metadata() or {}
+        functionalities = metadata.get(MODULE_FUNCTIONALITIES, [])
+        frid_index = int(frid) - 1
+        if frid_index < len(functionalities):
+            functionalities[frid_index] = frid_text
+        else:
+            functionalities.append(frid_text)
+        metadata[MODULE_FUNCTIONALITIES] = functionalities
+        if update_source_hash:
+            metadata["source_hash"] = self.get_module_source_hash()
+
+        codeplain_folder = self.get_codeplain_folder()
+        os.makedirs(codeplain_folder, exist_ok=True)
+        with open(self.module_metadata_path(), "w", encoding="utf-8") as f:
+            json.dump(metadata, f, indent=4)
+
     def get_module_source_hash(self) -> str:
         return plain_spec.get_hash_value([self.plain_source] + self.resources_list)
 

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_REIMPLEMENTED_COMMIT_MESSAGE
+            if render_context.is_rerender
+            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/finish_functional_requirement.py

@@ -1,14 +1,32 @@
 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):
-        super().execute(render_context, previous_action_payload)
+    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,
+            render_context.frid_context.functional_requirement_text,
+            update_source_hash=render_context.is_rerender,
+        )
+
+        commit_message = (
+            git_utils.FUNCTIONAL_REQUIREMENT_REIMPLEMENTED_COMMIT_MESSAGE
+            if render_context.is_rerender
+            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/prepare_repositories.py

@@ -13,6 +13,9 @@ class PrepareRepositories(BaseAction):
     SUCCESSFUL_OUTCOME = "repositories_prepared"
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        if render_context.is_rerender:
+            return self._prepare_rerender(render_context)
+
         if render_context.render_range is not None and render_context.render_range[0] != plain_spec.get_first_frid(
             render_context.plain_source_tree
         ):
@@ -79,3 +82,46 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
                 )
 
         return self.SUCCESSFUL_OUTCOME, None
+
+    def _prepare_rerender(self, render_context: RenderContext):
+        frid = render_context.render_range[0]
+
+        if "." in frid:
+            render_context.dispatch_error(
+                f"--rerender only supports top-level integer FRIDs (e.g. `1`, `2`). "
+                f"Nested FRID `{frid}` is not supported."
+            )
+            return "error", None
+
+        if not git_utils.has_commit_for_frid(render_context.build_folder, frid, render_context.module_name):
+            render_context.dispatch_error(
+                f"Cannot re-render functionality {frid} because it has not been fully rendered yet. "
+                f"Please render all functionalities first by running: "
+                f"codeplain {render_context.module_name}.plain"
+            )
+            return "error", None
+
+        render_context.starting_frid = frid
+
+        module_metadata = render_context.plain_module.load_module_metadata()
+        if not module_metadata or "functionalities" not in module_metadata:
+            render_context.dispatch_error(
+                "module_metadata.json is missing or incomplete. " "Please re-render the module from the beginning."
+            )
+            return "error", None
+
+        render_context.old_frid_spec = module_metadata["functionalities"][int(frid) - 1]
+
+        if render_context.render_conformance_tests:
+            conformance_tests_json = render_context.conformance_tests.get_conformance_tests_json(
+                render_context.module_name
+            )
+            if frid in conformance_tests_json:
+                old_folder = conformance_tests_json[frid]["folder_name"]
+                file_utils.delete_folder(old_folder)
+                del conformance_tests_json[frid]
+                render_context.conformance_tests.dump_conformance_tests_json(
+                    render_context.module_name, conformance_tests_json
+                )
+
+        return self.SUCCESSFUL_OUTCOME, None

render_machine/actions/prepare_testing_environment.py

@@ -12,6 +12,12 @@ class PrepareTestingEnvironment(BaseAction):
     FAILED_OUTCOME = "testing_environment_preparation_failed"
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        if (
+            render_context.prepare_environment_script is None
+            or not render_context.conformance_tests_running_context.should_prepare_testing_environment
+        ):
+            return self.SUCCESSFUL_OUTCOME, None
+
         console.info(
             f"Running testing environment preparation script {render_context.prepare_environment_script} for build folder {render_context.build_folder}."
         )

render_machine/actions/render_conformance_tests.py

@@ -126,6 +126,7 @@ def _render_conformance_tests(self, render_context: RenderContext):
             ),
             all_acceptance_tests,
             run_state=render_context.run_state,
+            is_reimplementation=render_context.is_rerender,
         )
 
         render_context.conformance_tests_running_context.current_testing_frid_high_level_implementation_plan = (

render_machine/actions/render_functional_requirement.py

@@ -16,8 +16,22 @@
 class RenderFunctionalRequirement(BaseAction):
     SUCCESSFUL_OUTCOME = "code_and_unit_tests_generated"
     FUNCTIONAL_REQUIREMENT_TOO_COMPLEX_OUTCOME = "functional_requirement_too_complex"
+    ITERATION_LIMIT_EXCEEDED_OUTCOME = "frid_iteration_limit_exceeded"
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        if render_context.frid_context.functional_requirement_render_attempts >= MAX_CODE_GENERATION_RETRIES:
+            error_msg = f"Unittests could not be fixed after rendering the functionality {render_context.frid_context.frid} for the {MAX_CODE_GENERATION_RETRIES} times."
+            render_context.last_error_message = error_msg
+            return self.ITERATION_LIMIT_EXCEEDED_OUTCOME, None
+
+        render_context.frid_context.functional_requirement_render_attempts += 1
+
+        if render_context.frid_context.functional_requirement_render_attempts > 1:
+            console.info(
+                f"Unittests could not be fixed after rendering the functionality. "
+                f"Restarting rendering functionality {render_context.frid_context.frid} from scratch."
+            )
+
         render_utils.revert_changes_for_frid(render_context)
         existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
             render_context.build_folder
@@ -46,6 +60,8 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
                 render_context.get_required_modules_functionalities(),
                 render_context.should_run_unit_tests(),
                 render_context.run_state,
+                is_reimplementation=render_context.is_rerender,
+                old_functional_requirement_text=render_context.old_frid_spec,
             )
         except FunctionalRequirementTooComplex as e:
             error_message = f"The functionality:\n{render_context.frid_context.functional_requirement_text}\n is too complex to be implemented. Please break down the functionality into smaller parts ({str(e)})."