codeplain 0.2.5__tar.gz → 0.2.7__tar.gz

{codeplain-0.2.5 → codeplain-0.2.7}/PKG-INFO

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

{codeplain-0.2.5 → codeplain-0.2.7}/codeplain_REST_api.py

@@ -2,6 +2,7 @@ import time
 from typing import Optional
 
 import requests
+from requests.exceptions import ConnectionError, Timeout
 
 import plain2code_exceptions
 from plain2code_state import RunState
@@ -9,7 +10,6 @@ from plain2code_state import RunState
 MAX_RETRIES = 4
 RETRY_DELAY = 3
 
-# TODO: Handle connection errors
 RETRY_ERROR_CODES = [
     "LLMInternalError",
 ]
@@ -44,6 +44,42 @@ class CodeplainAPI:
         run_state.increment_call_count()
         payload["render_state"] = run_state.to_dict()
 
+    def _handle_retry_logic(
+        self, attempt: int, retry_delay: int, num_retries: int, error: Exception, silent: bool
+    ) -> int:
+        """
+        Handles retry logic with exponential backoff.
+
+        Args:
+            attempt: Current attempt number
+            retry_delay: Current retry delay in seconds
+            error: The exception that occurred
+            num_retries: Number of retries allowed
+            error_type: Type of error for logging (e.g., "Network error", "Error")
+
+        Returns:
+            Updated retry_delay for next attempt
+
+        Raises:
+            The original exception if max retries exceeded
+        """
+        is_connection_error = isinstance(error, ConnectionError) or isinstance(error, Timeout)
+        connection_error_type = "Network error" if is_connection_error else "Error"
+        if attempt < num_retries:
+            if not silent:
+                self.console.info(f"{connection_error_type} on attempt {attempt + 1}/{num_retries + 1}: {error}")
+                self.console.info(f"Retrying in {retry_delay} seconds...")
+            time.sleep(retry_delay)
+            # Exponential backoff
+            return retry_delay * 2
+        else:
+            if not silent:
+                self.console.error(f"Max retries ({num_retries}) exceeded. Last error: {error}")
+            if is_connection_error:
+                raise plain2code_exceptions.NetworkConnectionError("Failed to connect to API server.")
+            else:
+                raise error
+
     def _raise_for_error_code(self, response_json):
         """Raise appropriate exception based on error code in response."""
         error_code = response_json.get("error_code")
@@ -60,7 +96,13 @@ class CodeplainAPI:
         raise exception_class(message)
 
     def post_request(
-        self, endpoint_url, headers, payload, run_state: Optional[RunState], num_retries: int = MAX_RETRIES
+        self,
+        endpoint_url,
+        headers,
+        payload,
+        run_state: Optional[RunState],
+        num_retries: int = MAX_RETRIES,
+        silent: bool = False,
     ):
         if run_state is not None:
             self._extend_payload_with_run_state(payload, run_state)
@@ -85,18 +127,12 @@ class CodeplainAPI:
                 return response_json
 
             except Exception as e:
+                # For other errors, check if they should be retried
                 if response_json is not None and "error_code" in response_json:
                     if response_json["error_code"] not in RETRY_ERROR_CODES:
                         raise e
 
-                if attempt < num_retries:
-                    self.console.info(f"Error on attempt {attempt + 1}/{num_retries + 1}: {e}")
-                    self.console.info(f"Retrying in {retry_delay} seconds...")
-                    time.sleep(retry_delay)
-                    retry_delay *= 2  # Exponential backoff
-                else:
-                    self.console.error(f"Max retries ({num_retries}) exceeded. Last error: {e}")
-                    raise e
+                retry_delay = self._handle_retry_logic(attempt, retry_delay, num_retries, e, silent)
 
     def connection_check(self, client_version):
         endpoint_url = f"{self.api_url}/connection_check"
@@ -105,7 +141,7 @@ class CodeplainAPI:
             "api_key": self.api_key,
             "client_version": client_version,
         }
-        return self.post_request(endpoint_url, headers, payload, None, num_retries=0)
+        return self.post_request(endpoint_url, headers, payload, None, num_retries=0, silent=True)
 
     def render_functional_requirement(
         self,

{codeplain-0.2.5 → codeplain-0.2.7}/config/system_config.yaml

@@ -1,4 +1,4 @@
-client_version: "0.17.0"
+client_version: "0.2.7"
 
 error_messages:
   template_not_found:

codeplain-0.2.7/docs/plain2code_cli.md

@@ -0,0 +1,63 @@
+# Plain2Code CLI Reference
+
+```text
+usage: generate_cli.py [-h] [--verbose] [--base-folder BASE_FOLDER] [--build-folder BUILD_FOLDER] [--log-to-file | --no-log-to-file] [--log-file-name LOG_FILE_NAME] [--config-name CONFIG_NAME] [--render-range RENDER_RANGE | --render-from RENDER_FROM] [--force-render]
+                       [--unittests-script UNITTESTS_SCRIPT] [--conformance-tests-folder CONFORMANCE_TESTS_FOLDER] [--conformance-tests-script CONFORMANCE_TESTS_SCRIPT] [--prepare-environment-script PREPARE_ENVIRONMENT_SCRIPT] [--api [API]] [--api-key API_KEY]
+                       [--full-plain] [--dry-run] [--replay-with REPLAY_WITH] [--template-dir TEMPLATE_DIR] [--copy-build] [--build-dest BUILD_DEST] [--copy-conformance-tests] [--conformance-tests-dest CONFORMANCE_TESTS_DEST] [--render-machine-graph]
+                       [--logging-config-path]
+                       filename
+
+Render plain code to target code.
+
+positional arguments:
+  filename              Path to the plain file to render. The directory containing this file has highest precedence for template loading, so you can place custom templates here to override the defaults. See --template-dir for more details about template loading.
+
+options:
+  -h, --help            show this help message and exit
+  --verbose, -v         Enable verbose output
+  --base-folder BASE_FOLDER
+                        Base folder for the build files
+  --build-folder BUILD_FOLDER
+                        Folder for build files
+  --log-to-file, --no-log-to-file
+                        Enable logging to a file. Defaults to True. Use --no-log-to-file to disable.
+  --log-file-name LOG_FILE_NAME
+                        Name of the log file. Defaults to 'codeplain.log'.Always resolved relative to the plain file directory.If file on this path already exists, it will be overwritten by the current logs.
+  --render-range RENDER_RANGE
+                        Specify a range of functional requirements to render (e.g. '1.1,2.3'). Use comma to separate start and end IDs. If only one ID is provided, only that requirement is rendered. Range is inclusive of both start and end IDs.
+  --render-from RENDER_FROM
+                        Continue generation starting from this specific functional requirement (e.g. '2.1'). The requirement with this ID will be included in the output. The ID must match one of the functional requirements in your plain file.
+  --force-render        Force re-render of all the required modules.
+  --unittests-script UNITTESTS_SCRIPT
+                        Shell script to run unit tests on generated code. Receives the build folder path as its first argument (default: 'plain_modules').
+  --conformance-tests-folder CONFORMANCE_TESTS_FOLDER
+                        Folder for conformance test files
+  --conformance-tests-script CONFORMANCE_TESTS_SCRIPT
+                        Path to conformance tests shell script. The script should accept two arguments: 1) First argument: path to a folder (e.g. 'plain_modules/module_name') containing generated source code, 2) Second argument: path to a subfolder of the conformance
+                        tests folder (e.g. 'conformance_tests/subfoldername') containing test files.
+  --prepare-environment-script PREPARE_ENVIRONMENT_SCRIPT
+                        Path to a shell script that prepares the testing environment. The script should accept the build folder path as its first argument (default: 'plain_modules').
+  --api [API]           Alternative base URL for the API. Default: `https://api.codeplain.ai`
+  --api-key API_KEY     API key used to access the API. If not provided, the CODEPLAIN_API_KEY environment variable is used.
+  --full-plain          Display the complete plain specification before code generation. This shows your plain file with any included template content expanded. Useful for understanding what content is being processed.
+  --dry-run             Preview of what Codeplain would do without actually making any changes.
+  --replay-with REPLAY_WITH
+  --template-dir TEMPLATE_DIR
+                        Path to a custom template directory. Templates are searched in the following order: 1) directory containing the plain file, 2) this custom template directory (if provided), 3) built-in standard_template_library directory
+  --copy-build          If set, copy the build folder to `--build-dest` after every successful rendering.
+  --build-dest BUILD_DEST
+                        Target folder to copy build output to (used only if --copy-build is set).
+  --copy-conformance-tests
+                        If set, copy the conformance tests folder to `--conformance-tests-dest` after every successful rendering. Requires --conformance-tests-script.
+  --conformance-tests-dest CONFORMANCE_TESTS_DEST
+                        Target folder to copy conformance tests output to (used only if --copy-conformance-tests is set).
+  --render-machine-graph
+                        If set, render the state machine graph.
+  --logging-config-path
+                        Path to the logging configuration file.
+
+configuration:
+  --config-name CONFIG_NAME
+                        Path to the config file, defaults to config.yaml
+
+```

{codeplain-0.2.5 → codeplain-0.2.7}/examples/example_hello_world_python/config.yaml

@@ -1,3 +1,3 @@
 unittests-script: ../../test_scripts/run_unittests_python.sh
 conformance-tests-script: ../../test_scripts/run_conformance_tests_python.sh
-verbose: true  # verbose flag, defaults to false if not set
+verbose: true

{codeplain-0.2.5 → codeplain-0.2.7}/git_utils.py

@@ -1,4 +1,5 @@
 import os
+from configparser import NoOptionError, NoSectionError
 from typing import Optional, Union
 
 from git import Repo
@@ -42,6 +43,24 @@ def _get_full_commit_message(message, module_name, frid, render_id) -> str:
     return full_message
 
 
+def _ensure_git_config(repo: Repo) -> None:
+    config = repo.config_reader()
+
+    try:
+        config.get_value("user", "name")
+    except (NoSectionError, NoOptionError):
+        # user.name not configured, set a default at repo level
+        with repo.config_writer(config_level="repository") as writer:
+            writer.set_value("user", "name", "Codeplain")
+
+    try:
+        config.get_value("user", "email")
+    except (NoSectionError, NoOptionError):
+        # user.email not configured, set a default at repo level
+        with repo.config_writer(config_level="repository") as writer:
+            writer.set_value("user", "email", "codeplain@localhost")
+
+
 def init_git_repo(
     path_to_repo: Union[str, os.PathLike], module_name: Optional[str] = None, render_id: Optional[str] = None
 ) -> Repo:
@@ -56,6 +75,7 @@ def init_git_repo(
         os.makedirs(path_to_repo)
 
     repo = Repo.init(path_to_repo)
+    _ensure_git_config(repo)
     repo.git.commit(
         "--allow-empty", "-m", _get_full_commit_message(INITIAL_COMMIT_MESSAGE, module_name, None, render_id)
     )

{codeplain-0.2.5 → codeplain-0.2.7}/install/walkthrough.sh

@@ -13,13 +13,13 @@ NC="${NC:-\033[0m}"
 # Onboarding Step 1: Introduction to Plain
 clear
 echo ""
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
-echo -e "  ${YELLOW}${BOLD}quick intro to ***plain specification language${NC} - Step 1 of 5"
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
+echo -e "  ${YELLOW}${BOLD}***plain specification language intro${NC} - Step 1 of 5"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
 echo ""
-echo -e "  ***plain is a language of spec-driven development that allows developers to express intent on any level of detail."
+echo -e "  ***plain is a language of spec-driven development that allows developers to express intent at any level of detail."
 echo ""
-echo -e "  write specs in ${YELLOW}plain English${NC}, in markdown with additional syntax"
+echo -e "  write specs in natural language extended with additional syntax based on markdown."
 echo ""
 echo -e "  render production-ready code with *codeplain."
 echo ""
@@ -28,8 +28,8 @@ echo ""
 echo -e "${GRAY}  ┌────────────────────────────────────────────────────────┐${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}  ${YELLOW}***definitions***${NC}      - key concepts in your app     ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${YELLOW}***implementation reqs***${NC}  - implementation details       ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${YELLOW}***test reqs***${NC}       - testing requirements         ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${YELLOW}***implementation reqs***${NC}  - implementation details   ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${YELLOW}***test reqs***${NC}       - testing requirements          ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}  ${YELLOW}***functional specs***${NC} - what the app should do       ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
 echo -e "${GRAY}  └────────────────────────────────────────────────────────┘${NC}"
@@ -41,33 +41,32 @@ read -r -p "  press [Enter] to continue..." < /dev/tty
 # Onboarding Step 2: Functional Specification
 clear
 echo ""
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
-echo -e "  ${YELLOW}${BOLD}Plain Language 101${NC} - Step 2 of 5"
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
+echo -e "  ${YELLOW}${BOLD}***plain specification language intro${NC} - Step 2 of 5"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
 echo ""
 echo -e "  ${WHITE}${BOLD}FUNCTIONAL SPECS${NC} - what should the app do?"
 echo ""
 echo -e "  This is where you describe ${GREEN}what your app should do${NC},"
-echo -e "  written in plain English. No code, just requirements."
+echo -e "  written in natural language. No code, just requirements."
 echo ""
 echo -e "${GRAY}  ┌────────────────────────────────────────────────────────┐${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***definitions***${NC}                                    ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***definitions***${NC}                                     ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :App: is a console application.${NC}                    ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :App: is a console application.${NC}                     ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***implementation reqs***${NC}                                ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***implementation reqs***${NC}                             ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :Implementation: should be in Python.${NC}              ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :UnitTests: should use Unittest framework.${NC}         ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :Implementation: should be in Python.${NC}               ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***test reqs***${NC}                                     ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***test reqs***${NC}                                       ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :ConformanceTests: should use Unittest.${NC}            ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :ConformanceTests: should use pytest.${NC}               ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***functional specs***${NC}                               ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***functional specs***${NC}                                ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :App: should display \"hello, world\".${NC}               ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :App: should display \"hello, world\".${NC}                ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
 echo -e "${GRAY}  └────────────────────────────────────────────────────────┘${NC}"
 echo ""
@@ -79,37 +78,36 @@ read -r -p "  press [Enter] to continue..." < /dev/tty
 # Onboarding Step 3: Definitions
 clear
 echo ""
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
-echo -e "  ${YELLOW}${BOLD}Plain Language 101${NC} - Step 3 of 5"
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
+echo -e "  ${YELLOW}${BOLD}***plain specification language intro${NC} - Step 3 of 5"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
 echo ""
-echo -e "  ${WHITE}${BOLD}DEFINITIONS${NC} - identify key concepts"
+echo -e "  ${WHITE}${BOLD}DEFINITIONS${NC} - definitions and descriptions of key concepts"
 echo ""
-echo -e "  Define ${GREEN}reusable concepts${NC} with the ${YELLOW}:ConceptName:${NC} syntax."
+echo -e "  Define ${GREEN}reusable concepts${NC} using the ${YELLOW}:Concept:${NC} notation."
 echo -e "  These become building blocks you can reference anywhere."
 echo ""
 echo -e "${GRAY}  ┌────────────────────────────────────────────────────────┐${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***definitions***${NC}                                    ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***definitions***${NC}                                     ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :App: is a console application.${NC}                    ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :App: is a console application.${NC}                     ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***implementation reqs***${NC}                                ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***implementation reqs***${NC}                             ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :Implementation: should be in Python.${NC}              ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :UnitTests: should use Unittest framework.${NC}         ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :Implementation: should be in Python.${NC}               ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***test reqs***${NC}                                     ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***test reqs***${NC}                                       ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :ConformanceTests: should use Unittest.${NC}            ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :ConformanceTests: should use pytest.${NC}               ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***functional specs***${NC}                               ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***functional specs***${NC}                                ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :App: should display \"hello, world\".${NC}               ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :App: should display \"hello, world\".${NC}                ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
 echo -e "${GRAY}  └────────────────────────────────────────────────────────┘${NC}"
 echo ""
-echo -e "  ${GREEN}▲${NC} The ${YELLOW}:App:${NC} concept is defined once and used throughout."
+echo -e "  ${GREEN}▲${NC} The ${YELLOW}:App:${NC} concept is defined once and used throughout the specs."
 echo -e "    Concepts help keep your specs consistent and clear."
 echo ""
 read -r -p "  press [Enter] to continue..." < /dev/tty
@@ -117,9 +115,9 @@ read -r -p "  press [Enter] to continue..." < /dev/tty
 # Onboarding Step 4: Implementation & Test Reqs
 clear
 echo ""
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
-echo -e "  ${YELLOW}${BOLD}Plain Language 101${NC} - Step 4 of 5"
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
+echo -e "  ${YELLOW}${BOLD}***plain specification language intro${NC} - Step 4 of 5"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
 echo ""
 echo -e "  ${WHITE}${BOLD}IMPLEMENTATION & TEST REQS${NC} - how to implement and test"
 echo ""
@@ -128,22 +126,21 @@ echo -e "  This guides how the code should be generated and verified."
 echo ""
 echo -e "${GRAY}  ┌────────────────────────────────────────────────────────┐${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***definitions***${NC}                                    ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***definitions***${NC}                                     ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :App: is a console application.${NC}                    ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :App: is a console application.${NC}                     ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***implementation reqs***${NC}                                ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***implementation reqs***${NC}                             ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :Implementation: should be in Python.${NC}              ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :UnitTests: should use Unittest framework.${NC}         ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :Implementation: should be in Python.${NC}               ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***test reqs***${NC}                                     ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${YELLOW}${BOLD}***test reqs***${NC}                                       ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :ConformanceTests: should use Unittest.${NC}            ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GREEN}${BOLD}- :ConformanceTests: should use pytest.${NC}               ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}***functional specs***${NC}                               ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}***functional specs***${NC}                                ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
-echo -e "${GRAY}  │${NC}  ${GRAY}- :App: should display \"hello, world\".${NC}               ${GRAY}│${NC}"
+echo -e "${GRAY}  │${NC}  ${GRAY}- :App: should display \"hello, world\".${NC}                ${GRAY}│${NC}"
 echo -e "${GRAY}  │${NC}                                                        ${GRAY}│${NC}"
 echo -e "${GRAY}  └────────────────────────────────────────────────────────┘${NC}"
 echo ""
@@ -155,9 +152,9 @@ read -r -p "  press [Enter] to continue..." < /dev/tty
 # Onboarding Step 5: Rendering Code
 clear
 echo ""
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
-echo -e "  ${YELLOW}${BOLD}Plain Language 101${NC} - Step 5 of 5"
-echo -e "${GRAY}────────────────────────────────────────────${NC}"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
+echo -e "  ${YELLOW}${BOLD}***plain specification language intro${NC} - Step 5 of 5"
+echo -e "${GRAY}─────────────────────────────────────────────────────────${NC}"
 echo ""
 echo -e "  ${WHITE}${BOLD}RENDERING CODE${NC} - generate your app"
 echo ""

{codeplain-0.2.5 → codeplain-0.2.7}/module_renderer.py

@@ -260,4 +260,6 @@ class ModuleRenderer:
         self.loaded_modules = list[PlainModule]()
         _, _, rendering_failed = self._render_module(self.filename, self.render_range, True)
         if not rendering_failed:
-            self.event_bus.publish(RenderCompleted())
+            # Get the last module that completed rendering
+            last_module_name = self.loaded_modules[-1].name if self.loaded_modules else ""
+            self.event_bus.publish(RenderCompleted(module_name=last_module_name, build_folder=self.args.build_folder))

{codeplain-0.2.5 → codeplain-0.2.7}/plain2code.py

@@ -3,6 +3,7 @@ import logging
 import logging.config
 import os
 import sys
+from pathlib import Path
 from typing import Optional
 
 import yaml
@@ -20,6 +21,7 @@ from plain2code_console import console
 from plain2code_exceptions import (
     ConflictingRequirements,
     CreditBalanceTooLow,
+    InternalClientError,
     InternalServerError,
     InvalidAPIKey,
     InvalidFridArgument,
@@ -27,9 +29,10 @@ from plain2code_exceptions import (
     MissingAPIKey,
     MissingPreviousFunctionalitiesError,
     MissingResource,
+    ModuleDoesNotExistError,
+    NetworkConnectionError,
     OutdatedClientVersion,
     PlainSyntaxError,
-    UnexpectedState,
 )
 from plain2code_logger import (
     CrashLogHandler,
@@ -40,6 +43,7 @@ from plain2code_logger import (
     get_log_file_path,
 )
 from plain2code_state import RunState
+from plain2code_utils import print_dry_run_output
 from system_config import system_config
 from tui.plain2code_tui import Plain2CodeTUI
 
@@ -70,6 +74,23 @@ def get_render_range_from(start, plain_source):
     return _get_frids_range(plain_source, start)
 
 
+def compute_render_range(args, plain_source_tree):
+    """Compute render range from --render-range or --render-from arguments.
+
+    Args:
+        args: Parsed command line arguments
+        plain_source_tree: Parsed plain source tree
+
+    Returns:
+        List of FRIDs to render, or None to render all
+    """
+    if args.render_range:
+        return get_render_range(args.render_range, plain_source_tree)
+    elif args.render_from:
+        return get_render_range_from(args.render_from, plain_source_tree)
+    return None
+
+
 def _get_frids_range(plain_source, start, end=None):
     frids = list(plain_spec.get_frids(plain_source))
 
@@ -165,7 +186,7 @@ def setup_logging(
     root_logger.info(f"Render ID: {render_id}")  # Ensure render ID is logged in to codeplain.log file
 
 
-def _check_connection(codeplainAPI):
+def _check_connection(codeplainAPI: codeplain_api.CodeplainAPI):
     """Check API connectivity and validate API key and client version."""
     response = codeplainAPI.connection_check(system_config.client_version)
 
@@ -184,7 +205,7 @@ def _check_connection(codeplainAPI):
         )
 
 
-def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # noqa: C901
+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.")
@@ -194,11 +215,7 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
     if args.render_range or args.render_from:
         # Parse the plain file to get the plain_source for FRID extraction
         _, plain_source, _ = plain_file.plain_file_parser(args.filename, template_dirs)
-
-        if args.render_range:
-            render_range = get_render_range(args.render_range, plain_source)
-        elif args.render_from:
-            render_range = get_render_range_from(args.render_from, plain_source)
+        render_range = compute_render_range(args, plain_source)
 
     codeplainAPI = codeplain_api.CodeplainAPI(args.api_key, console)
     codeplainAPI.verbose = args.verbose
@@ -240,6 +257,29 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
 def main():  # noqa: C901
     args = parse_arguments()
 
+    # Handle early-exit flags before heavy initialization
+    if args.dry_run or args.full_plain:
+        template_dirs = file_utils.get_template_directories(args.filename, args.template_dir, DEFAULT_TEMPLATE_DIRS)
+
+        try:
+            if args.full_plain:
+                module_name = Path(args.filename).stem
+                plain_source = plain_file.read_module_plain_source(module_name, template_dirs)
+                [full_plain_source, _] = file_utils.get_loaded_templates(template_dirs, plain_source)
+                console.info("Full plain text:\n")
+                console.info(full_plain_source)
+                return
+
+            if args.dry_run:
+                console.info("Printing dry run output...\n")
+                _, plain_source_tree, _ = plain_file.plain_file_parser(args.filename, template_dirs)
+                render_range = compute_render_range(args, plain_source_tree)
+                print_dry_run_output(plain_source_tree, render_range)
+                return
+        except Exception as e:
+            console.error(f"Error: {str(e)}")
+            return
+
     event_bus = EventBus()
 
     if not args.api:
@@ -258,7 +298,7 @@ def main():  # noqa: C901
             )
 
         console.debug(f"Render ID: {run_state.render_id}")  # Ensure render ID is logged to the console
-        render(args, run_state, codeplain_api, event_bus)
+        render(args, run_state, event_bus)
     except InvalidFridArgument as e:
         exc_info = sys.exc_info()
         console.error(f"Invalid FRID argument: {str(e)}.\n")
@@ -291,7 +331,7 @@ def main():  # noqa: C901
         console.error(f"Invalid API key: {str(e)}\n")
     except OutdatedClientVersion as e:
         console.error(f"Outdated client version: {str(e)}\n")
-    except (InternalServerError, UnexpectedState):
+    except (InternalServerError, InternalClientError):
         exc_info = sys.exc_info()
         console.error(
             f"Internal server error.\n\nPlease report the error to support@codeplain.ai with the attached {args.log_file_name} file."
@@ -313,6 +353,14 @@ def main():  # noqa: C901
         exc_info = sys.exc_info()
         console.error(f"Missing resource: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
+    except NetworkConnectionError as e:
+        exc_info = sys.exc_info()
+        console.error(f"Connection error: {str(e)}\n")
+        console.error("Please check that your internet connection is working.")
+    except ModuleDoesNotExistError as e:
+        exc_info = sys.exc_info()
+        console.error(f"Module does not exist: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
     except Exception as e:
         exc_info = sys.exc_info()
         console.error(f"Error rendering plain code: {str(e)}\n")