codeplain 0.2.17__tar.gz → 0.2.19__tar.gz

codeplain-0.2.19/.claude/settings.local.json

@@ -0,0 +1,39 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gh pr:*)",
+      "Bash(git diff *)",
+      "Bash(mypy . --check-untyped-defs)",
+      "Bash(flake8 .)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/test_git_utils.py -v --no-header)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key python *)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/_sandbox_check.py -v -s)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/test_partial_rendering.py -v)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/test_plain_modules.py -v)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/ -v)",
+      "Bash(flake8 tests/)",
+      "Bash(git stash *)",
+      "Bash(flake8 tests/test_git_utils.py)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key coverage run -m pytest tests/ -v)",
+      "Bash(.venv/bin/coverage run *)",
+      "Bash(.venv/bin/coverage report *)",
+      "Bash(.venv/bin/python -m coverage run -m pytest tests/)",
+      "Bash(.venv/bin/python -m coverage report)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/)",
+      "Bash(flake8 tests/test_partial_rendering.py tests/test_plain_modules.py)",
+      "Bash(MASTER_KEY=test-master-key GOOGLE_API_KEY=test-google-api-key pytest tests/test_partial_rendering.py tests/test_plain_modules.py tests/test_git_utils.py)",
+      "Bash(pytest tests *)",
+      "Bash(pytest tests/test_git_utils.py::test_diff_without_previous_frid_and_no_base_folder -x -v)",
+      "Bash(git checkout *)",
+      "Bash(python -c ' *)",
+      "Bash(python3 -c ' *)",
+      "Bash(/opt/homebrew/opt/python@3.11/bin/python3.11 -c ' *)",
+      "Bash(pytest tests/test_git_utils.py -x -v)",
+      "Bash(pytest tests/test_git_utils.py -v)",
+      "Bash(pytest -x -v)",
+      "Bash(pytest tests/test_partial_rendering.py -v)",
+      "Bash(pytest -v)",
+      "Bash(pytest)"
+    ]
+  }
+}

{codeplain-0.2.17 → codeplain-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeplain
-Version: 0.2.17
+Version: 0.2.19
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

codeplain-0.2.19/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.19"

{codeplain-0.2.17 → codeplain-0.2.19}/codeplain_REST_api.py

@@ -262,12 +262,15 @@ class CodeplainAPI:
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
-    def refactor_source_files_if_needed(self, frid, files_to_check, existing_files_content, run_state: RunState):
+    def refactor_source_files_if_needed(
+        self, frid, module_name: str, files_to_check, existing_files_content, run_state: RunState
+    ):
         endpoint_url = f"{self.api_url}/refactor_source_files_if_needed"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
 
         payload = {
             "frid": frid,
+            "module_name": module_name,
             "files_to_check": list(files_to_check),
             "existing_files_content": existing_files_content,
         }
@@ -312,6 +315,7 @@ class CodeplainAPI:
     def generate_folder_name_from_functional_requirement(
         self,
         frid,
+        module_name: str,
         functional_requirement,
         existing_folder_names,
         run_state: RunState,
@@ -321,6 +325,7 @@ class CodeplainAPI:
 
         payload = {
             "frid": frid,
+            "module_name": module_name,
             "functional_requirement": functional_requirement,
             "existing_folder_names": existing_folder_names,
         }
@@ -454,22 +459,24 @@ class CodeplainAPI:
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
-    def finish_functional_requirement(self, frid, run_state: RunState):
+    def finish_functional_requirement(self, frid, module_name: str, run_state: RunState):
         endpoint_url = f"{self.api_url}/finish_functional_requirement"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
 
         payload = {
             "frid": frid,
+            "module_name": module_name,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
-    def fail_functional_requirement(self, frid, run_state: RunState):
+    def fail_functional_requirement(self, frid, module_name: str, run_state: RunState):
         endpoint_url = f"{self.api_url}/fail_functional_requirement"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
 
         payload = {
             "frid": frid,
+            "module_name": module_name,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)

{codeplain-0.2.17 → codeplain-0.2.19}/module_renderer.py

@@ -66,7 +66,7 @@ class ModuleRenderer:
                 f"  codeplain {module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION}"
             )
 
-        if not os.path.exists(conformance_tests_path):
+        if not os.path.exists(conformance_tests_path) and self.args.render_conformance_tests:
             raise MissingPreviousFunctionalitiesError(
                 f"Cannot start rendering from functionality {first_render_frid} for module '{module_name}' because the conformance tests folder does not exist.\n\n"
                 f"To fix this, please render the module from the beginning by running:\n"
@@ -275,4 +275,5 @@ class ModuleRenderer:
                 last_module_name = self.filename.replace(plain_file.PLAIN_SOURCE_FILE_EXTENSION, "")
                 rendered_code_path = f"{os.path.join(self.args.build_folder, last_module_name)}/"
 
+            self.run_state.set_render_generated_code_path(rendered_code_path)
             self.event_bus.publish(RenderCompleted(rendered_code_path=rendered_code_path))

{codeplain-0.2.17 → codeplain-0.2.19}/plain2code.py

@@ -47,7 +47,7 @@ from plain2code_logger import (
     get_log_file_path,
 )
 from plain2code_state import RunState
-from plain2code_utils import print_dry_run_output
+from plain2code_utils import format_duration_hms, print_dry_run_output
 from system_config import system_config
 from tui.plain2code_tui import Plain2CodeTUI
 
@@ -55,6 +55,21 @@ DEFAULT_TEMPLATE_DIRS = importlib.resources.files("standard_template_library")
 RENDER_THREAD_SHUTDOWN_TIMEOUT = 0.7
 
 
+def print_exit_summary(
+    run_state: RunState,
+    spec_filename: str,
+) -> None:
+    console.quiet = False
+    """Print render outcome after the TUI exits (terminal restored)."""
+    msg = "\n[#79FC96]✓ rendering completed\n\n" if run_state.render_succeeded else "[#FF6B6B]✗ rendering failed\n\n"
+    msg += f"  [#8E8F91]render id:\t\t\t[#FFFFFF]{run_state.render_id}\n"
+    msg += f"  [#8E8F91]input file:\t\t\t[#FFFFFF]{spec_filename}\n"
+    msg += f"  [#8E8F91]generated code folder:\t[#FFFFFF]{run_state.render_generated_code_path or '-'}\n\n"
+    msg += f"[#8E8F91]functionalities  [#FFFFFF]{run_state.rendered_functionalities}  [#8E8F91]used credits  [#FFFFFF]{run_state.rendered_functionalities}  [#8E8F91]render time  [#FFFFFF]{format_duration_hms(run_state.render_time_accumulated)}\n"
+    console.info(msg)
+    console.quiet = True
+
+
 def get_render_range(render_range, plain_source):
     render_range = render_range.split(",")
     range_end = render_range[1] if len(render_range) == 2 else render_range[0]
@@ -186,8 +201,6 @@ def _check_connection(codeplainAPI: codeplain_api.CodeplainAPI):
 def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
     template_dirs = file_utils.get_template_directories(args.filename, args.template_dir, DEFAULT_TEMPLATE_DIRS)
 
-    console.info(f"Rendering {args.filename} to target code.")
-
     # Compute render range from either --render-range or --render-from
     render_range = None
     if args.render_range or args.render_from:
@@ -219,14 +232,16 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
     )
 
     render_error: list[Exception] = []
+    run_state.render_succeeded = False
 
     def run_render():
         try:
             module_renderer.render_module()
-            console.info(f"[#79FC96]Render {run_state.render_id} completed successfully.[/#79FC96]")
+            run_state.set_render_succeeded(True)
         except RenderCancelledError:
             pass  # TUI already closed, nothing to report
         except Exception as e:
+            run_state.set_render_succeeded(False)
             render_error.append(e)
             event_bus.publish(RenderFailed(error_message=str(e)))
 
@@ -234,7 +249,9 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
         console.info(f"Render started. Render ID: {run_state.render_id}")
         try:
             module_renderer.render_module()
+            run_state.set_render_succeeded(True)
         except RenderCancelledError:
+            run_state.set_render_succeeded(False)
             pass
         return
     else:
@@ -251,6 +268,7 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
             css_path="styles.css",
         )
         app.run()
+
         stop_event.set()
         render_thread.join(timeout=RENDER_THREAD_SHUTDOWN_TIMEOUT)
 
@@ -304,8 +322,6 @@ def main():  # noqa: C901
             raise MissingAPIKey(
                 "API key is required. Please set the CODEPLAIN_API_KEY environment variable or provide it with the --api-key argument."
             )
-
-        console.info(f"Render ID: {run_state.render_id}")
         render(args, run_state, event_bus)
     except InvalidFridArgument as e:
         exc_info = sys.exc_info()
@@ -374,6 +390,7 @@ def main():  # noqa: C901
         console.error(f"Error rendering plain code: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
     finally:
+        print_exit_summary(run_state, args.filename)
         if exc_info:
             # Log traceback using the logging system
             logging.error("Render crashed with exception:", exc_info=exc_info)

{codeplain-0.2.17 → codeplain-0.2.19}/plain2code_logger.py

@@ -27,11 +27,12 @@ class TuiLoggingHandler(logging.Handler):
 
     def emit(self, record):
         try:
-            offset_seconds = record.created - self.start_time
-            minutes = int(offset_seconds // 60)
-            seconds = int(offset_seconds % 60)
-            milliseconds = int((offset_seconds % 1) * 100)
-            timestamp = f"{minutes:02d}:{seconds:02d}:{milliseconds:02d}"
+            offset_seconds = int(record.created - self.start_time)
+            hours = offset_seconds // 3600
+            minutes = (offset_seconds % 3600) // 60
+            seconds = offset_seconds % 60
+            timestamp = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
             event = LogMessageEmitted(
                 logger_name=record.name,
                 level=record.levelname,

{codeplain-0.2.17 → codeplain-0.2.19}/plain2code_state.py

@@ -1,5 +1,6 @@
 """Contains all state and context information we need for the rendering process."""
 
+import time
 import uuid
 from typing import Optional
 
@@ -9,6 +10,9 @@ class RunState:
 
     def __init__(self, spec_filename: str, replay_with: Optional[str] = None):
         self.replay: bool = replay_with is not None
+        self.render_succeeded: bool = False
+        self.render_generated_code_path: Optional[str] = None
+        self.rendered_functionalities: int = 0
         if replay_with:
             self.render_id: str = replay_with
         else:
@@ -17,6 +21,8 @@ class RunState:
         self.call_count: int = 0
         self.unittest_batch_id: int = 0
         self.frid_render_anaysis: dict[str, str] = {}
+        self.render_time_accumulated: int = 0
+        self.last_render_start_timestamp: float = time.monotonic()
 
     def increment_call_count(self):
         self.call_count += 1
@@ -27,6 +33,21 @@ class RunState:
     def add_rendering_analysis_for_frid(self, frid, rendering_analysis) -> None:
         self.frid_render_anaysis[frid] = rendering_analysis
 
+    def set_render_succeeded(self, succeeded: bool):
+        self.render_succeeded = succeeded
+
+    def set_render_generated_code_path(self, generated_code_path: str):
+        self.render_generated_code_path = generated_code_path
+
+    def increment_rendered_functionalities(self):
+        self.rendered_functionalities += 1
+
+    def add_to_render_time(self):
+        self.render_time_accumulated += int(time.monotonic() - self.last_render_start_timestamp)
+
+    def set_last_render_start_timestamp(self):
+        self.last_render_start_timestamp = time.monotonic()
+
     def to_dict(self):
         return {
             "render_id": self.render_id,

{codeplain-0.2.17 → codeplain-0.2.19}/plain2code_utils.py

@@ -3,6 +3,22 @@ from typing import Optional
 import plain_spec
 from plain2code_console import console
 
+
+def format_duration_hms(total_seconds: int) -> str:
+    """Format a duration in seconds as hours, minutes, and seconds (e.g. ``1h 2m 3.45s``, ``45.67s``)."""
+    if total_seconds < 0:
+        total_seconds = 0
+    h = int(total_seconds // 3600)
+    m = int((total_seconds % 3600) // 60)
+    s = total_seconds % 60
+    if h:
+        return f"{h}h {m}m {s}s"
+    if m:
+        return f"{m}m {s}s"
+    text = f"{s}".rstrip("0").rstrip(".")
+    return f"{text}s" if text else "0s"
+
+
 AMBIGUITY_CAUSES = {
     "reference_resource_ambiguity": "Ambiguity is in the reference resources",
     "definition_ambiguity": "Ambiguity is in the definitions",

{codeplain-0.2.17 → codeplain-0.2.19}/plain_file.py

@@ -649,7 +649,7 @@ def plain_file_parser(  # noqa: C901
         )
 
     if not check_if_functional_requirements_are_specified(plain_file_parse_result.plain_source, []):
-        raise PlainSyntaxError("Syntax error: No functionality specified.")
+        raise PlainSyntaxError(f"Module '{module_name}' was required but does not contain functional requirements.")
 
     exported_definitions = process_required_modules(
         plain_file_parse_result.required_modules,

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/actions/exit_with_error.py

@@ -13,6 +13,7 @@ class ExitWithError(BaseAction):
 
         render_context.codeplain_api.fail_functional_requirement(
             render_context.frid_context.frid,
+            module_name=render_context.module_name,
             run_state=render_context.run_state,
         )
 

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/actions/finish_functional_requirement.py

@@ -12,6 +12,7 @@ class FinishFunctionalRequirement(CommitImplementationCodeChanges):
 
         render_context.codeplain_api.finish_functional_requirement(
             render_context.frid_context.frid,
+            module_name=render_context.module_name,
             run_state=render_context.run_state,
         )
 

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/actions/refactor_code.py

@@ -31,6 +31,7 @@ class RefactorCode(BaseAction):
         ):
             response_files = render_context.codeplain_api.refactor_source_files_if_needed(
                 frid=render_context.frid_context.frid,
+                module_name=render_context.module_name,
                 files_to_check=render_context.frid_context.changed_files,
                 existing_files_content=existing_files_content,
                 run_state=render_context.run_state,

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/actions/render_conformance_tests.py

@@ -38,6 +38,7 @@ class RenderConformanceTests(BaseAction):
             ):
                 fr_subfolder_name = render_context.codeplain_api.generate_folder_name_from_functional_requirement(
                     frid=render_context.conformance_tests_running_context.current_testing_frid,
+                    module_name=render_context.conformance_tests_running_context.current_testing_module_name,
                     functional_requirement=render_context.conformance_tests_running_context.current_testing_frid_specifications[
                         plain_spec.FUNCTIONAL_REQUIREMENTS
                     ][

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/actions/render_functional_requirement.py

@@ -40,20 +40,17 @@ class RenderFunctionalRequirement(BaseAction):
                     render_context, existing_files_content, "Files sent as input to code generation:"
                 )
 
-            with console.status(
-                f"[{console.INFO_STYLE}]Generating functionality {render_context.frid_context.frid}...\n"
-            ):
-                response_files = render_context.codeplain_api.render_functional_requirement(
-                    render_context.frid_context.frid,
-                    render_context.plain_source_tree,
-                    render_context.frid_context.linked_resources,
-                    existing_files_content,
-                    memory_files_content,
-                    render_context.module_name,
-                    render_context.get_required_modules_functionalities(),
-                    render_context.should_run_unit_tests(),
-                    render_context.run_state,
-                )
+            response_files = render_context.codeplain_api.render_functional_requirement(
+                render_context.frid_context.frid,
+                render_context.plain_source_tree,
+                render_context.frid_context.linked_resources,
+                existing_files_content,
+                memory_files_content,
+                render_context.module_name,
+                render_context.get_required_modules_functionalities(),
+                render_context.should_run_unit_tests(),
+                render_context.run_state,
+            )
         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)})."
             if e.proposed_breakdown:

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/code_renderer.py

@@ -43,8 +43,11 @@ class CodeRenderer:
             if self.render_context.enter_pause_event.is_set():
                 self.render_context.event_bus.publish(RenderPaused())
 
+                # don't take sleep time into account for render time
+                self.render_context.run_state.add_to_render_time()
                 while self.render_context.enter_pause_event.is_set():
                     time.sleep(PAUSE_POLL_INTERVAL_SECONDS)
+                self.render_context.run_state.set_last_render_start_timestamp()
 
             self.render_context.event_bus.publish(
                 RenderStateUpdated(

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/render_context.py

@@ -146,12 +146,6 @@ class RenderContext:
         else:
             frid = plain_spec.get_next_frid(self.plain_source_tree, self.frid_context.frid)
 
-        if frid is None:
-            # If frid context is empty, it means that all frids have been implemented
-            self.frid_context = None
-            self.machine.dispatch(triggers.PREPARE_FINAL_OUTPUT)
-            return
-
         specifications, _ = plain_spec.get_specifications_for_frid(self.plain_source_tree, frid)
         functional_requirement_text = specifications[plain_spec.FUNCTIONAL_REQUIREMENTS][-1]
 
@@ -172,10 +166,6 @@ class RenderContext:
         return
 
     def check_frid_iteration_limit(self):
-        # If frid context is not set, it means that all frids have been implemented
-        if self.frid_context is None:
-            return
-
         if self.frid_context.functional_requirement_render_attempts >= MAX_CODE_GENERATION_RETRIES:
             error_msg = f"Unittests could not be fixed after rendering the functionality {self.frid_context.frid} for the {MAX_CODE_GENERATION_RETRIES} times."
             self.dispatch_error(error_msg)
@@ -189,8 +179,12 @@ class RenderContext:
                 f"Restarting rendering the functionality {self.frid_context.frid} from scratch."
             )
 
+    def has_next_frid(self) -> bool:
+        return plain_spec.get_next_frid(self.plain_source_tree, self.frid_context.frid) is not None
+
     def finish_implementing_frid(self):
         self.functional_requirements_render_attempts_failed_unit_during_conformance_tests = 0
+        self.run_state.increment_rendered_functionalities()
 
     def should_run_unit_tests(self) -> bool:
         return self.unittests_script is not None
@@ -453,3 +447,11 @@ class RenderContext:
             console.info(
                 f"Running conformance tests attempt {self.conformance_tests_running_context.fix_attempts + 1}."
             )
+
+    def start_render_completed(self):
+        self.run_state.set_render_succeeded(True)
+        self.run_state.add_to_render_time()
+
+    def start_render_failed(self):
+        self.run_state.set_render_succeeded(False)
+        self.run_state.add_to_render_time()

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/render_utils.py

@@ -19,7 +19,7 @@ SCRIPT_EXECUTION_TIMEOUT = 120
 TIMEOUT_ERROR_EXIT_CODE = 124
 POLL_INTERVAL_SECONDS = 0.2
 SIGTERM_GRACE_PERIOD_SECONDS = 0.2
-STDOUT_READ_TIMEOUT_SECONDS = 5
+STDOUT_READ_TIMEOUT_SECONDS = 2
 F_SETPIPE_SIZE = 1031  # Linux-only constant
 PIPE_SIZE_KB = 1024  # 1MB
 
@@ -120,11 +120,27 @@ def execute_script(  # noqa: C901
         # Set the pipe size to 1MB to avoid buffer overflows
         fcntl.fcntl(proc.stdout.fileno(), F_SETPIPE_SIZE, PIPE_SIZE_KB * 1024)  # 1MB
 
+    # Drain stdout in a background thread to prevent pipe buffer deadlock.
+    # macOS has a 64KB pipe buffer; without continuous draining, scripts that produce
+    # more output than that block on write and never exit, causing spurious timeouts.
+    output_chunks: list[str] = []
+
+    def _drain_stdout() -> None:
+        try:
+            for chunk in iter(lambda: proc.stdout.read(8192), ""):
+                output_chunks.append(chunk)
+        except (OSError, ValueError):
+            pass
+
+    reader = threading.Thread(target=_drain_stdout, daemon=True)
+    reader.start()
+
     try:
         while proc.poll() is None:
             if time.time() - start_time >= script_timeout:
                 _kill_process(proc)
-                partial_stdout = proc.stdout.read()
+                reader.join(timeout=2)
+                partial_stdout = "".join(output_chunks)
                 exc = subprocess.TimeoutExpired(cmd, script_timeout)
                 exc.stdout = partial_stdout
                 raise exc
@@ -136,12 +152,13 @@ def execute_script(  # noqa: C901
             else:
                 time.sleep(POLL_INTERVAL_SECONDS)
 
-        # Use communicate() with a timeout because child processes may hold the pipe open after the main process exits.
-        try:
-            stdout, _ = proc.communicate(timeout=STDOUT_READ_TIMEOUT_SECONDS)
-        except subprocess.TimeoutExpired:
+        # Wait for the reader to finish draining remaining output.
+        # Close stdout if child processes keep the pipe open beyond the grace period.
+        reader.join(timeout=STDOUT_READ_TIMEOUT_SECONDS)
+        if reader.is_alive():
             proc.stdout.close()
-            stdout = ""
+            reader.join(timeout=1)
+        stdout = "".join(output_chunks)
         elapsed_time = time.time() - start_time
 
         sanitized_script_output = _sanitize_script_output(stdout)

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/state_machine_config.py

@@ -233,8 +233,8 @@ class StateMachineConfig:
                     States.FRID_FULLY_IMPLEMENTED.value,
                 ],
             },
-            States.RENDER_COMPLETED.value,
-            States.RENDER_FAILED.value,
+            {"name": States.RENDER_COMPLETED.value, "on_enter": "start_render_completed"},
+            {"name": States.RENDER_FAILED.value, "on_enter": "start_render_failed"},
         ]
 
     def get_transitions(self) -> List[Dict[str, Any]]:
@@ -261,11 +261,6 @@ class StateMachineConfig:
                 "dest": f"{States.IMPLEMENTING_FRID.value}_{States.STEP_COMPLETED.value}",
                 "unless": "should_run_unit_tests",
             },
-            {
-                "source": f"{States.IMPLEMENTING_FRID.value}",
-                "trigger": triggers.PREPARE_FINAL_OUTPUT,
-                "dest": States.RENDER_COMPLETED.value,
-            },
             {
                 "source": "*",
                 "trigger": triggers.HANDLE_ERROR,
@@ -349,6 +344,13 @@ class StateMachineConfig:
                 "source": f"{States.IMPLEMENTING_FRID.value}_{States.FRID_FULLY_IMPLEMENTED.value}",
                 "trigger": triggers.PROCEED_FRID_PROCESSING,
                 "dest": f"{States.IMPLEMENTING_FRID.value}",
+                "conditions": "has_next_frid",
+            },
+            {
+                "source": f"{States.IMPLEMENTING_FRID.value}_{States.FRID_FULLY_IMPLEMENTED.value}",
+                "trigger": triggers.PROCEED_FRID_PROCESSING,
+                "dest": States.RENDER_COMPLETED.value,
+                "unless": "has_next_frid",
             },
             {
                 "source": f"{States.IMPLEMENTING_FRID.value}_{States.REFACTORING_CODE.value}_{States.PROCESSING_UNIT_TESTS.value}_{States.UNIT_TESTS_READY.value}",

{codeplain-0.2.17 → codeplain-0.2.19}/render_machine/triggers.py

@@ -12,7 +12,6 @@ PROCEED_FRID_PROCESSING = "proceed_frid_processing"
 MARK_UNIT_TESTS_FAILED = "mark_unit_tests_failed"
 MARK_UNIT_TESTS_PASSED = "mark_unit_tests_passed"
 MARK_UNIT_TESTS_READY = "mark_unit_tests_ready"
-PREPARE_FINAL_OUTPUT = "prepare_final_output"
 FINISH_RENDER = "finish_render"
 HANDLE_ERROR = "handle_error"
 REFACTOR_CODE = "refactor_code"

codeplain-0.2.17/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh pr:*)"
-    ]
-  }
-}

codeplain-0.2.17/_version.py

@@ -1 +0,0 @@
-__version__ = "0.2.17"