codeplain 0.2.12__py3-none-any.whl → 0.2.13__py3-none-any.whl

_version.py

@@ -1 +1 @@
-__version__ = "0.2.12"
+__version__ = "0.2.13"

{codeplain-0.2.12.dist-info → codeplain-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeplain
-Version: 0.2.12
+Version: 0.2.13
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console
@@ -20,7 +20,7 @@ Requires-Dist: textual>=7.5.0
 Requires-Dist: tiktoken==0.12.0
 Requires-Dist: transitions==0.9.3
 Provides-Extra: dev
-Requires-Dist: black==24.3.0; extra == 'dev'
+Requires-Dist: black==26.3.1; extra == 'dev'
 Requires-Dist: flake8==7.0.0; extra == 'dev'
 Requires-Dist: isort==5.13.2; extra == 'dev'
 Requires-Dist: mypy==1.11.2; extra == 'dev'
@@ -46,7 +46,7 @@ Schematic overview of the Codeplain's code generation service
 
 An example application in ***plain
 
-<img src="https://raw.githubusercontent.com/Codeplain-ai/plain2code_client/main/resources/plain_example.png" width="70%" height="70%">
+<img src="resources/plain_example.png" width="70%" height="70%">
 
 
 ## Getting started
@@ -115,7 +115,7 @@ After completing the installation steps above, you can immediately test the syst
 
 ### Documentation
 
-- For more details on the ***plain format, see the [***plain language specification](docs/plain_language_specification.md).
+- For more details on the ***plain format, see the [***plain language specification](https://www.plainlang.org/docs/intro/).
 - For step-by-step instructions for creating your first ***plain project see the [Kickstart your ***plain project](docs/starting_a_plain_project_from_scratch.md).
 - For complete CLI documentation and usage examples, see [plain2code CLI documentation](docs/plain2code_cli.md).
 

{codeplain-0.2.12.dist-info → codeplain-0.2.13.dist-info}/RECORD

@@ -1,19 +1,19 @@
-_version.py,sha256=X4KG3FscE5AhbGbcdDDgdDC550CVpxNMwdNLcx6EQ7M,23
-codeplain_REST_api.py,sha256=NH0j3eyv1ElqmGDw-mz743ZPE_h3X5UBILuAyLsQMys,19485
+_version.py,sha256=C0atO05M0rfDTTHt02NxNa4jt0eSqXM4AxShEhb2epA,23
+codeplain_REST_api.py,sha256=GkGLstHNeBu5mSsCqAuStKd9qGhDOO5miOyKmDdkPbE,19570
 concept_utils.py,sha256=vwSY4-FmxyqaDBxhntYzqG8t9pXvAWwiULP0DYQI32o,7905
 diff_utils.py,sha256=AjiQlqo5pRos_8hVXZo5yBurl5BzSrTMGrQv4dCtRCg,1198
-event_bus.py,sha256=sduIR3bgIbxAbLhwKd8Gx9YN9gzaeqy9-mNupS04aKw,1759
-file_utils.py,sha256=uy4JXQ0PicbvrErUit-KeLlVD1KsYwD4Cgu4XgDEe4s,12395
+event_bus.py,sha256=LM6d3WuiwB2M_rgVGDjV6jsJwj4U0tlj3KXepz4njqc,1081
+file_utils.py,sha256=-4NUReb--MllqDJ59qSZdxWC7NTpT0MdknF9H_95C9c,12365
 git_utils.py,sha256=jjiKbVF8k765T1VGyXYsZ7z9XkgiD6mo_OwXD9SeSlg,14411
 hash_key.py,sha256=lMKgKpOhPeC4UpFf9e7eCNK20FEaDsXTCJ8j3eCWidE,837
-memory_management.py,sha256=4_Vri7VXuvb-_DtQKvhyDbrtO24lHmNtPbT7BZj4AM4,5504
+memory_management.py,sha256=QWF1EzQ470Ei7QaI5_sGvrtjr1TXiSokeu-s6oo2RxI,5513
 module_renderer.py,sha256=sslmzxgqIDSyoymcmqq3Y1qBdVOJ15vevRq8jhsW6Eg,12156
-plain2code.py,sha256=OeRU3WgXfXwpKRtkTk26aCBaDjPii-hVKBkqNeluA_0,14259
-plain2code_arguments.py,sha256=aPqe6r9xXeuvMI9HvlZ9JEfRHtyDHiDsZwmuSiYq2Lg,12359
-plain2code_console.py,sha256=JscbS2eEO3xZDjoTLvBSwKrOi945p3uXNULvmXznop0,4052
+plain2code.py,sha256=tbi2qD8XHxtL6UIm0U5g9lGlA8L22QuE6iFTZRKfSl4,14908
+plain2code_arguments.py,sha256=EfiCo6Igzb-waTw0BTB6GX9LYzMk_hrx8UJ34Ryxo4M,12619
+plain2code_console.py,sha256=BDZlWQGvHfQTZFDXIwfKlTzOE3RfVffmdxTkXcM5ll4,4743
 plain2code_events.py,sha256=nITVjZzj7pR5l6tzTpLvuY76ZfL_IzvKtk0qskeQnS0,1377
 plain2code_exceptions.py,sha256=yX9cwWRI4I7O35UyEsaehBFn8OMNR28i_DMJHYCwlvs,1273
-plain2code_logger.py,sha256=I9AchbS34QY_8lvqUHe_TSJLfRZqfdi9rtV_OpJ0dss,4416
+plain2code_logger.py,sha256=YbJ3JgLXDhc_dibUUl9AtIG3IjGA8jagrhFegb5Myzc,3724
 plain2code_nodes.py,sha256=Om624mfb5MB1Z09c0Zqtb9G1gGkUY9x-v2hzAf3A2gw,3818
 plain2code_read_config.py,sha256=QnpbW_Bi9LzDIOubM5x7fVXH1HgiFL3-5Oa_O1EUoE4,2449
 plain2code_state.py,sha256=InLXdytMXnm9YC4o8MSTbtB1TmqYYUs6rASGBlyA_YY,1274
@@ -50,8 +50,8 @@ render_machine/actions/prepare_repositories.py,sha256=1jLGwbJS7jJkhjm-1p2oNv_9n1
 render_machine/actions/prepare_testing_environment.py,sha256=AmL6Esg3PvCqsEeYZtUE4mlYDavDrleHX7RFkU8qAtg,1900
 render_machine/actions/refactor_code.py,sha256=2cZViWb4Dj6t7dCN2fo9qniIIrn_VE22dsSORjmr_oA,2112
 render_machine/actions/render_conformance_tests.py,sha256=gQaYImSAD6fK8FhfDMQcKH1Uy9_Qq6jsj5ZEKHLmy9c,8798
-render_machine/actions/render_functional_requirement.py,sha256=lk9SquVSH_EwvtXPqyEfoirGwisQf5eHdBdV-NG2eoY,4120
-render_machine/actions/run_conformance_tests.py,sha256=ZYC7wFzJ9doZHE6JAMZ42fYuaQjVYNUfPSzMHFj9tuY,3513
+render_machine/actions/render_functional_requirement.py,sha256=BTX0jZoH8zX93KUamF7komkDzyxRj7Jwv7OKF8HMKJg,4180
+render_machine/actions/run_conformance_tests.py,sha256=SmEKUS6pO_461b35L0iR4p8Fl83S3APDvXISfA73NRc,3830
 render_machine/actions/run_unit_tests.py,sha256=vNxn1zoKbk8jebTDFE_8SbAxosk1Mbm3UjpvjrkbbWc,2080
 render_machine/actions/summarize_conformance_tests.py,sha256=BbBMJX3HkrZF_BlyNFw6prPgF9NLySapoLeGQ6_e3xU,1867
 standard_template_library/__init__.py,sha256=LtsHl0c3VV46DUInIqyOw4KKVoxKEMOx8dAZpMXtAXc,43
@@ -61,7 +61,7 @@ standard_template_library/typescript-react-app-boilerplate.plain,sha256=6LFxhEOz
 standard_template_library/typescript-react-app-template.plain,sha256=DN5wEJcT8ZqQTf0vFKi9Z1isi9cin2UVNOZb3r28d3M,715
 tests/__init__.py,sha256=Wk73Io62J15BtlLVIzxmASDWaaJkQLevS4BLK5LDAQg,16
 tests/conftest.py,sha256=QZcp08htUlJGgmHDlRWFgsWXZ8o8IBWTD5QqJaUMlU8,790
-tests/test_git_utils.py,sha256=Knc4R2ZkHYVj9iPFKhb0_ewaad_mxPrakOn6gpziHMc,13138
+tests/test_git_utils.py,sha256=2FYxYBs2HUkEgeKwnZWPZ8UpNTtZyK4g6BbBrZTv_ic,12984
 tests/test_imports.py,sha256=EWYLUxGunUUdsG9iCiY_tts6T7DIVdhdB_MZlB1LsmU,2081
 tests/test_plainfile.py,sha256=H0asjkBjdqAgwHHZJTaGYm0BG97ah6yirLk-yaHBzwM,11090
 tests/test_plainfileparser.py,sha256=Pq52n5NzJP_h56BRk7OofRwry0aAW1Al86U3VEkte9U,18724
@@ -70,13 +70,13 @@ tests/test_requires.py,sha256=6tnHYaKudxN-RiQjSFoi9nHe_x0ze3QF-f-j67zAE74,1250
 tui/__init__.py,sha256=_fy7FowY0RkWdn4kC7XV2jgvQPCj-2gE8fNUb-Mny0A,60
 tui/components.py,sha256=hPtXCKEhfGNWxQrordpJZueKQicWSbOYcIb25BACN8Q,22316
 tui/models.py,sha256=KMjlWubmPD41GA-BjgiqkaV9v7tLJ0fuWKBDPmZj4JA,1493
-tui/plain2code_tui.py,sha256=yVeoU7RMSSJYkFfJAjW6gJUeT6SjupTkXTtkMKB-1C4,14951
+tui/plain2code_tui.py,sha256=nUDgW_HCEixBajql1gyp4EYogKfM5K_5K0G_k-vtfXU,12087
 tui/spinner.py,sha256=Ro6Gd9Przf-whuHqPRY6HwI0T57yJjyNPbhDbigZKZE,2471
 tui/state_handlers.py,sha256=acc2JnZypog2X7DUQuzxeul9pcHOS6TETGjBMUEKLcc,15320
 tui/styles.css,sha256=fyO5rjPpRLTAt-ym_tOOXQ8F8ZYxEBvaa-JA-K1DAz0,5840
 tui/widget_helpers.py,sha256=lFKgGSgBMyraOGCXEhwKLnPR9xadr43Ei3OWEYzDjQg,5574
-codeplain-0.2.12.dist-info/METADATA,sha256=0sVua2vSyKac3eSVAv2w6iJcRoqU83s6o2WCUXcbtpw,4279
-codeplain-0.2.12.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-codeplain-0.2.12.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
-codeplain-0.2.12.dist-info/licenses/LICENSE,sha256=wsFi5dpbJurnRNfBj8q2RCcF3ryrmdRIfxc3lPcmc4c,1069
-codeplain-0.2.12.dist-info/RECORD,,
+codeplain-0.2.13.dist-info/METADATA,sha256=g583ibVMphvlBIadZAKdAQRLbA1Lt1lPP2_7BR1LJ3o,4210
+codeplain-0.2.13.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+codeplain-0.2.13.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
+codeplain-0.2.13.dist-info/licenses/LICENSE,sha256=pCeKgQ1mXE5OmNUuKOfOZh1T1vqkeCUxghE7N8qgnzc,11345
+codeplain-0.2.13.dist-info/RECORD,,

codeplain-0.2.13.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Codeplain, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

codeplain_REST_api.py

@@ -152,6 +152,7 @@ class CodeplainAPI:
         memory_files_content: dict,
         module_name: str,
         required_modules: dict,
+        include_unittests: bool,
         run_state: RunState,
     ) -> dict[str, str]:
         """
@@ -191,6 +192,7 @@ class CodeplainAPI:
             "memory_files_content": memory_files_content,
             "module_name": module_name,
             "required_modules": required_modules,
+            "include_unittests": include_unittests,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)

event_bus.py

@@ -7,26 +7,11 @@ from plain2code_events import BaseEvent
 class EventBus:
     def __init__(self):
         self._listeners: defaultdict[Type[BaseEvent], list[Callable[[Any], None]]] = defaultdict(list)
-        self._main_thread_callback: Callable[[Callable], None] | None = None
-        self._ready_callbacks: list[Callable[[], None]] = []
-
-    def register_main_thread_callback(self, fn: Callable[[Callable], None]):
-        """Set the function to call listeners from the main thread (e.g., Textual app.call_from_thread)."""
-        self._main_thread_callback = fn
-
-        # Notify anyone waiting for the event bus to be ready
-        for callback in self._ready_callbacks:
-            callback()
-        self._ready_callbacks.clear()
-
-    def on_ready(self, callback: Callable[[], None]):
-        """Register a callback to be called when the event bus is ready."""
-        if self._main_thread_callback:
-            # Already ready, call immediately
-            callback()
-        else:
-            # Not ready yet, queue it
-            self._ready_callbacks.append(callback)
+        self._dispatch_wrapper: Callable[[Callable], None] | None = None
+
+    def register_dispatch_wrapper(self, fn: Callable[[Callable], None]):
+        """Set a wrapper for dispatching listeners (e.g., Textual's app.call_from_thread)."""
+        self._dispatch_wrapper = fn
 
     def subscribe(self, event_type: Type[BaseEvent], listener: Callable[[Any], None]):
         """Registers a listener for a specific event type."""
@@ -39,7 +24,7 @@ class EventBus:
             for listener in self._listeners[type(event)]:
                 listener(event)
 
-        if not self._main_thread_callback:
-            raise RuntimeError("No main thread callback set. Call register_main_thread_callback() first.")
-
-        self._main_thread_callback(_dispatch)
+        if self._dispatch_wrapper:
+            self._dispatch_wrapper(_dispatch)
+        else:
+            _dispatch()

file_utils.py

@@ -236,8 +236,7 @@ def load_linked_resources(template_dirs: list[str], resources_list):
         content = open_from(template_dirs, file_name)
 
         if content is None:
-            raise FileNotFoundError(
-                f"""
+            raise FileNotFoundError(f"""
                 Resource file {file_name} not found. Resource files are searched in the following order (highest to lowest precedence):
 
                 1. The directory containing your .plain file
@@ -245,8 +244,7 @@ def load_linked_resources(template_dirs: list[str], resources_list):
                 3. The built-in 'standard_template_library' directory
 
                 Please ensure that the resource exists in one of these locations, or specify the correct --template-dir if using custom templates.
-                """
-            )
+                """)
 
         linked_resources[file_name] = content
 

memory_management.py

@@ -61,7 +61,7 @@ class MemoryManager:
         existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
             render_context.build_folder
         )
-        _, memory_files_content = MemoryManager.fetch_memory_files(self.memory_folder)
+        memory_files, memory_files_content = MemoryManager.fetch_memory_files(self.memory_folder)
 
         conformance_tests_folder_name = (
             render_context.conformance_tests_running_context.get_current_conformance_test_folder_name()
@@ -96,7 +96,7 @@ class MemoryManager:
         )
         if len(response_files) > 0:
             memory_folder_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
-            file_utils.store_response_files(memory_folder_path, response_files, existing_files)
+            file_utils.store_response_files(memory_folder_path, response_files, memory_files)
 
     def delete_unresolved_memory_files(self):
         """Delete memory files whose resolution_status is not 'RESOLVED'."""

plain2code.py

@@ -3,6 +3,7 @@ import logging
 import logging.config
 import os
 import sys
+import threading
 from pathlib import Path
 from typing import Optional
 
@@ -18,6 +19,7 @@ from event_bus import EventBus
 from module_renderer import ModuleRenderer
 from plain2code_arguments import parse_arguments
 from plain2code_console import console
+from plain2code_events import RenderFailed
 from plain2code_exceptions import (
     ConflictingRequirements,
     CreditBalanceTooLow,
@@ -122,6 +124,7 @@ def setup_logging(
     log_file_name: str,
     plain_file_path: Optional[str],
     render_id: str,
+    headless: bool = False,
 ):
     # Set default level to INFO for everything not explicitly configured
     logging.getLogger().setLevel(logging.INFO)
@@ -162,10 +165,12 @@ def setup_logging(
     for h in root_logger.handlers[:]:
         root_logger.removeHandler(h)
 
-    handler = TuiLoggingHandler(event_bus)
     formatter = IndentedFormatter("%(levelname)s:%(name)s:%(message)s")
-    handler.setFormatter(formatter)
-    root_logger.addHandler(handler)
+
+    if not headless:
+        handler = TuiLoggingHandler(event_bus)
+        handler.setFormatter(formatter)
+        root_logger.addHandler(handler)
 
     if log_to_file and log_file_path:
         try:
@@ -232,24 +237,36 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
         event_bus,
     )
 
-    app = Plain2CodeTUI(
-        event_bus=event_bus,
-        worker_fun=module_renderer.render_module,
-        render_id=run_state.render_id,
-        unittests_script=args.unittests_script,
-        conformance_tests_script=args.conformance_tests_script,
-        prepare_environment_script=args.prepare_environment_script,
-        state_machine_version=system_config.client_version,
-        css_path="styles.css",
-    )
-    result = app.run()
+    render_error: list[Exception] = []
 
-    # If the app exited due to a worker error, re-raise it here
-    # so it hits the exception handlers in main()
-    if isinstance(result, Exception):
-        raise result
+    def run_render():
+        try:
+            module_renderer.render_module()
+        except Exception as e:
+            render_error.append(e)
+            event_bus.publish(RenderFailed(error_message=str(e)))
 
-    return
+    if args.headless:
+        print(f"Render started. Render ID: {run_state.render_id}")
+        module_renderer.render_module()
+        return
+    else:
+        render_thread = threading.Thread(target=run_render, daemon=True)
+        app = Plain2CodeTUI(
+            event_bus=event_bus,
+            on_ready=render_thread.start,
+            render_id=run_state.render_id,
+            unittests_script=args.unittests_script,
+            conformance_tests_script=args.conformance_tests_script,
+            prepare_environment_script=args.prepare_environment_script,
+            state_machine_version=system_config.client_version,
+            css_path="styles.css",
+        )
+        app.run()
+        render_thread.join(timeout=1)
+
+    if render_error:
+        raise render_error[0]
 
 
 def main():  # noqa: C901
@@ -285,7 +302,13 @@ def main():  # noqa: C901
 
     run_state = RunState(spec_filename=args.filename, replay_with=args.replay_with)
 
-    setup_logging(args, event_bus, args.log_to_file, args.log_file_name, args.filename, run_state.render_id)
+    if args.headless:
+        # Suppress Rich console output.
+        console.quiet = True
+
+    setup_logging(
+        args, event_bus, args.log_to_file, args.log_file_name, args.filename, run_state.render_id, args.headless
+    )
 
     exc_info = None
     try:

plain2code_arguments.py

@@ -288,6 +288,14 @@ def create_parser():
         help="Path to the logging configuration file.",
     )
 
+    parser.add_argument(
+        "--headless",
+        action="store_true",
+        default=False,
+        help="Run in headless mode: no TUI, no terminal output except a single render-started message. "
+        "All logs are written to the log file.",
+    )
+
     return parser
 
 

plain2code_console.py

@@ -1,10 +1,11 @@
 import logging
 
-import tiktoken
 from rich.console import Console
 from rich.style import Style
 from rich.tree import Tree
 
+CHARACTERS_TO_TOKENS_RULE_OF_THUMB_RATIO = 4
+
 
 class Plain2CodeConsole(Console):
     INFO_STYLE = Style()
@@ -16,7 +17,16 @@ class Plain2CodeConsole(Console):
 
     def __init__(self):
         super().__init__()
-        self.llm_encoding = tiktoken.get_encoding("cl100k_base")
+        try:
+            import tiktoken
+
+            self.llm_encoding = tiktoken.get_encoding("cl100k_base")
+        except Exception as e:
+            logging.warning(
+                "Failed to import optional library tiktoken. Using approximate instead of exact token count."
+            )
+            logging.debug(f"Exception: {e}")
+            self.llm_encoding = None
 
     def info(self, *args, **kwargs):
         logging.info(" ".join(map(str, args)))
@@ -86,7 +96,7 @@ class Plain2CodeConsole(Console):
                             current_level = current_level.add(f"{part} [red]deleted[/red]")
                         else:
                             file_lines = len(content.splitlines())
-                            file_tokens = len(self.llm_encoding.encode(content))
+                            file_tokens = self._count_tokens(content)
                             current_level = current_level.add(f"{part} ({file_lines} lines, {file_tokens} tokens)")
                     else:
                         current_level = current_level.add(part)
@@ -95,6 +105,15 @@ class Plain2CodeConsole(Console):
 
         return tree
 
+    def _count_tokens(self, text):
+        """Count tokens using tiktoken if available, otherwise estimate from character count."""
+        if self.llm_encoding is not None:
+            try:
+                return len(self.llm_encoding.encode(text))
+            except Exception:
+                pass
+        return len(text) // CHARACTERS_TO_TOKENS_RULE_OF_THUMB_RATIO
+
     def print_resources(self, resources_list, linked_resources):
         if len(resources_list) == 0:
             self.input("Linked resources: None")
@@ -103,7 +122,7 @@ class Plain2CodeConsole(Console):
         self.input("Linked resources:")
         for resource_name in resources_list:
             if resource_name["target"] in linked_resources:
-                file_tokens = len(self.llm_encoding.encode(linked_resources[resource_name["target"]]))
+                file_tokens = self._count_tokens(linked_resources[resource_name["target"]])
                 self.input(
                     f"- {resource_name['text']} [#4169E1]({resource_name['target']}, {file_tokens} tokens)[/#4169E1]"
                 )

plain2code_logger.py

@@ -40,15 +40,10 @@ class TuiLoggingHandler(logging.Handler):
     def __init__(self, event_bus: EventBus):
         super().__init__()
         self.event_bus = event_bus
-        self._buffer = []
-        self.start_time = time.time()  # Record start time for offset calculation
-
-        # Register to be notified when event bus is ready
-        self.event_bus.on_ready(self._flush_buffer)
+        self.start_time = time.time()
 
     def emit(self, record):
         try:
-            # Extract structured data from the log record
             offset_seconds = record.created - self.start_time
             minutes = int(offset_seconds // 60)
             seconds = int(offset_seconds % 60)
@@ -60,12 +55,7 @@ class TuiLoggingHandler(logging.Handler):
                 message=record.getMessage(),
                 timestamp=timestamp,
             )
-
-            # Try to publish, fall back to buffering if not ready
-            if self.event_bus._main_thread_callback:
-                self.event_bus.publish(event)
-            else:
-                self._buffer.append(event)
+            self.event_bus.publish(event)
         except RuntimeError:
             # We're going to get this crash after the TUI app is closed (forcefully).
             # NOTE: This should be more thought out.
@@ -73,15 +63,6 @@ class TuiLoggingHandler(logging.Handler):
         except Exception:
             self.handleError(record)
 
-    def _flush_buffer(self):
-        """Flush buffered log messages to the event bus."""
-        for event in self._buffer:
-            try:
-                self.event_bus.publish(event)
-            except Exception:
-                pass
-        self._buffer.clear()
-
 
 class CrashLogHandler(logging.Handler):
     def __init__(self):

render_machine/actions/render_functional_requirement.py

@@ -51,6 +51,7 @@ class RenderFunctionalRequirement(BaseAction):
                     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:

render_machine/actions/run_conformance_tests.py

@@ -54,7 +54,13 @@ class RunConformanceTests(BaseAction):
         )
 
         if exit_code == 0:
-            render_context.memory_manager.delete_unresolved_memory_files()
+            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()
             return self.SUCCESSFUL_OUTCOME, None
 
         if exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:

tests/test_git_utils.py

@@ -63,8 +63,7 @@ def test_single_file_change(temp_repo):
     result = diff(temp_repo, "1.1")
 
     assert "test.txt" in result
-    expected_diff = dedent(
-        """
+    expected_diff = dedent("""
         --- a/test.txt
         +++ b/test.txt
         @@ -1,3 +1,3 @@
@@ -72,8 +71,7 @@ def test_single_file_change(temp_repo):
         +modified content
          line2
          line3
-    """
-    ).strip()
+    """).strip()
     assert result["test.txt"] == expected_diff
 
 
@@ -98,8 +96,7 @@ def test_multiple_file_changes(temp_repo):
 
     # Check first file
     assert "test.txt" in result
-    expected_diff1 = dedent(
-        """
+    expected_diff1 = dedent("""
         --- a/test.txt
         +++ b/test.txt
         @@ -1,3 +1,2 @@
@@ -107,22 +104,19 @@ def test_multiple_file_changes(temp_repo):
         +file1 modified
          line2
         -line3
-    """
-    ).strip()
+    """).strip()
     assert result["test.txt"] == expected_diff1
 
     # Check second file
     assert "file2.txt" in result
-    expected_diff2 = dedent(
-        """
+    expected_diff2 = dedent("""
         --- /dev/null
         +++ b/file2.txt
         @@ -0,0 +1,2 @@
         +file2 modified
         +line2
         \
-    """
-    ).strip()
+    """).strip()
     assert result["file2.txt"] == expected_diff2
 
 
@@ -157,8 +151,7 @@ def test_multiple_commits_diff(temp_repo):
 
     # Check first file
     assert "test.txt" in result
-    expected_diff1 = dedent(
-        """
+    expected_diff1 = dedent("""
         --- a/test.txt
         +++ b/test.txt
         @@ -1,3 +1,2 @@
@@ -166,35 +159,30 @@ def test_multiple_commits_diff(temp_repo):
         +file1 frid1.2 refactored version
          line2
         -line3
-    """
-    ).strip()
+    """).strip()
     assert result["test.txt"] == expected_diff1
 
     # Check second file
     assert "file2.txt" in result
-    expected_diff2 = dedent(
-        """
+    expected_diff2 = dedent("""
         --- a/file2.txt
         +++ b/file2.txt
         @@ -1,2 +1,2 @@
         -file2 frid1.1 refactored version
         +file2 frid1.2 version
          line2
-    """
-    ).strip()
+    """).strip()
     assert result["file2.txt"] == expected_diff2
 
     # Check third file
     assert "file3.txt" in result
-    expected_diff3 = dedent(
-        """
+    expected_diff3 = dedent("""
         --- /dev/null
         +++ b/file3.txt
         @@ -0,0 +1,2 @@
         +file3 frid1.2 new file
         +line2
-    """
-    ).strip()
+    """).strip()
     assert result["file3.txt"] == expected_diff3
 
 
@@ -213,27 +201,23 @@ def test_diff_without_previous_frid_and_no_base_folder(empty_repo):
     result = diff(empty_repo)
 
     assert "new.txt" in result
-    expected_diff = dedent(
-        """
+    expected_diff = dedent("""
         --- /dev/null
         +++ b/new.txt
         @@ -0,0 +1,2 @@
         +new file content
         +line2
-    """
-    ).strip()
+    """).strip()
     assert result["new.txt"] == expected_diff
 
     assert "new2.txt" in result
-    expected_diff2 = dedent(
-        """
+    expected_diff2 = dedent("""
         --- /dev/null
         +++ b/new2.txt
         @@ -0,0 +1,2 @@
         +new file content
         +line2
-    """
-    ).strip()
+    """).strip()
     assert result["new2.txt"] == expected_diff2
 
 
@@ -251,16 +235,14 @@ def test_diff_without_previous_frid_and_base_folder(temp_repo):
     result = diff(temp_repo)
 
     assert "new.txt" in result
-    expected_diff = dedent(
-        """
+    expected_diff = dedent("""
         --- a/new.txt
         +++ b/new.txt
         @@ -1,2 +1,2 @@
         -base folder content
         +updated base folder content
          line2
-    """
-    ).strip()
+    """).strip()
     assert result["new.txt"] == expected_diff
 
 
@@ -276,15 +258,13 @@ def test_new_file(temp_repo):
     result = diff(temp_repo, "1.1")
 
     assert "new.txt" in result
-    expected_diff = dedent(
-        """
+    expected_diff = dedent("""
         --- /dev/null
         +++ b/new.txt
         @@ -0,0 +1,2 @@
         +new file content
         +line2
-    """
-    ).strip()
+    """).strip()
     assert result["new.txt"] == expected_diff
 
 
@@ -300,16 +280,14 @@ def test_deleted_file(temp_repo):
     result = diff(temp_repo, "1.1")
 
     assert "test.txt" in result
-    expected_diff = dedent(
-        """
+    expected_diff = dedent("""
         --- a/test.txt
         +++ /dev/null
         @@ -1,3 +0,0 @@
         -initial content
         -line2
         -line3
-    """
-    ).strip()
+    """).strip()
     assert result["test.txt"] == expected_diff
 
 

tui/plain2code_tui.py

@@ -1,6 +1,3 @@
-import os
-import threading
-import time
 from typing import Callable, Optional
 
 from textual.app import App, ComposeResult
@@ -8,10 +5,8 @@ from textual.binding import Binding
 from textual.containers import Vertical, VerticalScroll
 from textual.css.query import NoMatches
 from textual.widgets import ContentSwitcher, Static
-from textual.worker import Worker, WorkerFailed, WorkerState
 
 from event_bus import EventBus
-from plain2code_console import console
 from plain2code_events import (
     LogMessageEmitted,
     RenderCompleted,
@@ -48,8 +43,6 @@ from .state_handlers import (
     UnitTestsHandler,
 )
 
-FORCE_EXIT_DELAY = 0.5  # seconds
-
 
 class Plain2CodeTUI(App):
     """A Textual TUI for plain2code."""
@@ -64,7 +57,7 @@ class Plain2CodeTUI(App):
     def __init__(
         self,
         event_bus: EventBus,
-        worker_fun: Callable[[], None],
+        on_ready: Callable[[], None],
         render_id: str,
         unittests_script: str,
         conformance_tests_script: str,
@@ -75,7 +68,7 @@ class Plain2CodeTUI(App):
         super().__init__(**kwargs)
         self.dark = True  # Set dark mode as default
         self.event_bus = event_bus
-        self.worker_fun = worker_fun
+        self._on_ready = on_ready
         self.render_id = render_id
         self.unittests_script: Optional[str] = unittests_script
         self.conformance_tests_script: Optional[str] = conformance_tests_script
@@ -125,7 +118,7 @@ class Plain2CodeTUI(App):
 
     def on_mount(self) -> None:
         """Called when the app is mounted."""
-        self.event_bus.register_main_thread_callback(self.call_from_thread)
+        self.event_bus.register_dispatch_wrapper(self.call_from_thread)
 
         self.event_bus.subscribe(RenderStateUpdated, self.on_render_state_updated)
         self.event_bus.subscribe(RenderCompleted, self.on_render_completed)
@@ -134,39 +127,7 @@ class Plain2CodeTUI(App):
         self.event_bus.subscribe(RenderModuleCompleted, self.on_render_module_completed)
         self.event_bus.subscribe(LogMessageEmitted, self.on_log_message_emitted)
 
-        self.render_worker = self.run_worker(self.worker_fun, thread=True)
-
-    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
-        """Handle worker state changes."""
-        if event.worker.state == WorkerState.ERROR:
-            # Extract the original exception from WorkerFailed wrapper
-            error = event.worker.error
-            original_error = error.__cause__ if isinstance(error, WorkerFailed) and error.__cause__ else error
-            self.exit(result=original_error)
-
-    def _handle_exception(self, error: Exception) -> None:
-        """Override Textual's exception handler to suppress console tracebacks for worker errors.
-
-        Worker exceptions are logged to file via the logging system (configured in file handler in plain2code.py),
-        but the verbose Textual/Rich traceback is suppressed from the terminal. The clean error message
-        is displayed via the exception handlers in main().
-        """
-        # Because TUI is running in main thread and code renderer is running in a worker thread, textual models this
-        # by raising a WorkerFailed exception in this case
-        if isinstance(error, WorkerFailed):
-            # Here, we still print the error to get some additional information to the file, but it's probably
-            # not necessary because we either way print the entire traceback to the console. Here, we could in the future
-            # print more information if we would want to.
-            original_error = error.__cause__ if error.__cause__ else error
-            console.error(
-                f"Worker failed with exception: {type(original_error).__name__}: {original_error}",
-                exc_info=(type(original_error), original_error, original_error.__traceback__),
-                stack_info=False,
-            )
-            return
-
-        # For non-worker exceptions, use the default Textual behavior
-        super()._handle_exception(error)
+        self._on_ready()
 
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
@@ -290,24 +251,12 @@ class Plain2CodeTUI(App):
     def on_render_failed(self, event: RenderFailed):
         """Handle render failure."""
         self._render_error_handler.handle(event.error_message)
-
-    def _ensure_exit(self) -> None:
-        """Ensure exit the application immediately."""
-
-        def ensure_exit():
-            time.sleep(FORCE_EXIT_DELAY)
-            try:
-                if hasattr(self, "_driver") and self._driver is not None:
-                    # suspend_application_mode() calls stop_application_mode() and close()
-                    # It ensures terminal reset sequences are flushed before exiting.
-                    self._driver.suspend_application_mode()
-            except Exception as e:
-                log_to_widget(self, "WARNING", f"Error suspending application mode: {type(e).__name__}: {e}")
-            finally:
-                os._exit(0)  # Kill process immediately, no cleanup - terminates all threads
-
-        # daemon=True ensures this thread dies with the process if it exits before the timer fires
-        threading.Thread(target=ensure_exit, daemon=True).start()
+        self._render_finished = True
+        try:
+            footer = self.screen.query_one(CustomFooter)
+            footer.show_render_finished()
+        except NoMatches:
+            pass
 
     async def action_copy_selection(self) -> None:
         """Handle ctrl+c: copy selected text if any.
@@ -332,5 +281,4 @@ class Plain2CodeTUI(App):
         Note: Force exit may leave files partially written if interrupted during file I/O operations.
         This is acceptable since the folders in which we are writing are git versioned and are reset in the next render.
         """
-        self.render_worker.cancel()
         self.exit()

codeplain-0.2.12.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Codeplain.ai
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.