codeplain 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

plain2code.py

@@ -2,7 +2,7 @@ import importlib.resources
 import logging
 import logging.config
 import os
-import traceback
+import sys
 from typing import Optional
 
 import yaml
@@ -17,7 +17,20 @@ from event_bus import EventBus
 from module_renderer import ModuleRenderer
 from plain2code_arguments import parse_arguments
 from plain2code_console import console
-from plain2code_exceptions import MissingAPIKey, PlainSyntaxError
+from plain2code_exceptions import (
+    ConflictingRequirements,
+    CreditBalanceTooLow,
+    InternalServerError,
+    InvalidAPIKey,
+    InvalidFridArgument,
+    LLMInternalError,
+    MissingAPIKey,
+    MissingPreviousFunctionalitiesError,
+    MissingResource,
+    OutdatedClientVersion,
+    PlainSyntaxError,
+    UnexpectedState,
+)
 from plain2code_logger import (
     CrashLogHandler,
     IndentedFormatter,
@@ -46,10 +59,6 @@ UNRECOVERABLE_ERROR_EXIT_CODES = [69]
 TIMEOUT_ERROR_EXIT_CODE = 124
 
 
-class InvalidFridArgument(Exception):
-    pass
-
-
 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]
@@ -93,6 +102,7 @@ def setup_logging(
     log_to_file: bool,
     log_file_name: str,
     plain_file_path: Optional[str],
+    render_id: str,
 ):
     # Set default level to INFO for everything not explicitly configured
     logging.getLogger().setLevel(logging.INFO)
@@ -152,11 +162,29 @@ def setup_logging(
         crash_handler.setFormatter(formatter)
         root_logger.addHandler(crash_handler)
 
+    root_logger.info(f"Render ID: {render_id}")  # Ensure render ID is logged in to codeplain.log file
 
-def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # noqa: C901
-    # Check system requirements before proceeding
-    system_config.verify_requirements()
 
+def _check_connection(codeplainAPI):
+    """Check API connectivity and validate API key and client version."""
+    response = codeplainAPI.connection_check(system_config.client_version)
+
+    if not response.get("api_key_valid", False):
+        raise InvalidAPIKey(
+            "Provided API key is invalid. Please provide a valid API key using the CODEPLAIN_API_KEY environment variable "
+            "or the --api-key argument."
+        )
+
+    if not response.get("client_version_valid", False):
+        min_version = response.get("min_client_version", "unknown")
+        raise OutdatedClientVersion(
+            f"Your client version ({system_config.client_version}) is outdated. Minimum required version is {min_version}. "
+            "Please update using:"
+            "  uv tool upgrade codeplain"
+        )
+
+
+def render(args, run_state: RunState, codeplain_api, 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.")
@@ -177,6 +205,8 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
     assert args.api is not None and args.api != "", "API URL is required"
     codeplainAPI.api_url = args.api
 
+    _check_connection(codeplainAPI)
+
     module_renderer = ModuleRenderer(
         codeplainAPI,
         args.filename,
@@ -194,6 +224,7 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
         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()
@@ -206,18 +237,19 @@ def render(args, run_state: RunState, codeplain_api, event_bus: EventBus):  # no
     return
 
 
-def main():
+def main():  # noqa: C901
     args = parse_arguments()
 
     event_bus = EventBus()
 
-    setup_logging(args, event_bus, args.log_to_file, args.log_file_name, args.filename)
-
     if not args.api:
         args.api = "https://api.codeplain.ai"
 
     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)
+
+    exc_info = None
     try:
         # Validate API key is present
         if not args.api_key:
@@ -225,42 +257,71 @@ def main():
                 "API key is required. Please set the CODEPLAIN_API_KEY environment variable or provide it with the --api-key argument."
             )
 
+        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)
     except InvalidFridArgument as e:
-        console.error(f"Error rendering plain code: {str(e)}.\n")
-        # No need to print render ID since this error is going to be thrown at the very start so user will be able to
-        # see the render ID that's printed at the very start of the rendering process.
-        dump_crash_logs(args)
+        exc_info = sys.exc_info()
+        console.error(f"Invalid FRID argument: {str(e)}.\n")
     except FileNotFoundError as e:
-        console.error(f"Error rendering plain code: {str(e)}\n")
+        exc_info = sys.exc_info()
+        console.error(f"File not found: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
-        dump_crash_logs(args)
-    except plain_file.InvalidPlainFileExtension as e:
-        console.error(f"Error rendering plain code: {str(e)}\n")
-        dump_crash_logs(args)
     except TemplateNotFoundError as e:
-        console.error(f"Error: Template not found: {str(e)}\n")
+        exc_info = sys.exc_info()
+        console.error(f"Template not found: {str(e)}\n")
         console.error(system_config.get_error_message("template_not_found"))
-        dump_crash_logs(args)
     except PlainSyntaxError as e:
-        console.error(f"Error rendering plain code: {str(e)}\n")
-        dump_crash_logs(args)
+        exc_info = sys.exc_info()
+        console.error(f"Plain syntax error: {str(e)}\n")
     except KeyboardInterrupt:
+        exc_info = sys.exc_info()
         console.error("Keyboard interrupt")
-        # Don't print the traceback here because it's going to be from keyboard interrupt and we don't really care about that
         console.debug(f"Render ID: {run_state.render_id}")
-        dump_crash_logs(args)
     except RequestException as e:
+        exc_info = sys.exc_info()
+        console.error(f"Error rendering plain code: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except MissingPreviousFunctionalitiesError as e:
+        exc_info = sys.exc_info()
         console.error(f"Error rendering plain code: {str(e)}\n")
         console.debug(f"Render ID: {run_state.render_id}")
-        dump_crash_logs(args)
     except MissingAPIKey as e:
         console.error(f"Missing API key: {str(e)}\n")
+    except InvalidAPIKey as e:
+        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):
+        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."
+        )
+        console.debug(f"Render ID: {run_state.render_id}")
+    except ConflictingRequirements as e:
+        exc_info = sys.exc_info()
+        console.error(f"Conflicting requirements: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except CreditBalanceTooLow as e:
+        exc_info = sys.exc_info()
+        console.error(f"Credit balance too low: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except LLMInternalError as e:
+        exc_info = sys.exc_info()
+        console.error(f"LLM internal error: {str(e)}\n")
+        console.debug(f"Render ID: {run_state.render_id}")
+    except MissingResource as e:
+        exc_info = sys.exc_info()
+        console.error(f"Missing resource: {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")
         console.debug(f"Render ID: {run_state.render_id}")
-        traceback.print_exc()
-        dump_crash_logs(args)
+    finally:
+        if exc_info:
+            # Log traceback using the logging system
+            logging.error("Render crashed with exception:", exc_info=exc_info)
+            dump_crash_logs(args)
 
 
 if __name__ == "__main__":  # noqa: C901

plain2code_console.py

@@ -52,7 +52,7 @@ class Plain2CodeConsole(Console):
             return
 
         tree = self._create_tree_from_files(root_folder, files)
-        super().print(f"\n[b]{header}[/b]", style=style)
+        super().print(f"\n{header}", style=style)
 
         super().print(tree, style=style)
 
@@ -87,9 +87,7 @@ class Plain2CodeConsole(Console):
                         else:
                             file_lines = len(content.splitlines())
                             file_tokens = len(self.llm_encoding.encode(content))
-                            current_level = current_level.add(
-                                f"{part} [b]({file_lines} lines, {file_tokens} tokens)[/b]"
-                            )
+                            current_level = current_level.add(f"{part} ({file_lines} lines, {file_tokens} tokens)")
                     else:
                         current_level = current_level.add(part)
                 else:
@@ -107,7 +105,7 @@ class Plain2CodeConsole(Console):
             if resource_name["target"] in linked_resources:
                 file_tokens = len(self.llm_encoding.encode(linked_resources[resource_name["target"]]))
                 self.input(
-                    f"- {resource_name['text']} [b][#4169E1]({resource_name['target']}, {file_tokens} tokens)[/#4169E1][/b]"
+                    f"- {resource_name['text']} [#4169E1]({resource_name['target']}, {file_tokens} tokens)[/#4169E1]"
                 )
 
         self.input()

plain2code_exceptions.py

@@ -25,25 +25,45 @@ class PlainSyntaxError(Exception):
     pass
 
 
-class OnlyRelativeLinksAllowed(Exception):
+class UnexpectedState(Exception):
     pass
 
 
-class LinkMustHaveTextSpecified(Exception):
+class MissingAPIKey(Exception):
     pass
 
 
-class NoRenderFound(Exception):
+class InvalidAPIKey(Exception):
     pass
 
 
-class MultipleRendersFound(Exception):
+class OutdatedClientVersion(Exception):
     pass
 
 
-class UnexpectedState(Exception):
+class InvalidFridArgument(Exception):
     pass
 
 
-class MissingAPIKey(Exception):
+class InvalidGitRepositoryError(Exception):
+    """Raised when the git repository is in an invalid state."""
+
+    pass
+
+
+class InvalidLiquidVariableName(Exception):
+    pass
+
+
+class ModuleDoesNotExistError(Exception):
+    pass
+
+
+class InternalServerError(Exception):
+    pass
+
+
+class MissingPreviousFunctionalitiesError(Exception):
+    """Raised when trying to render from a FRID but previous FRID commits are missing."""
+
     pass

plain2code_logger.py

@@ -4,7 +4,6 @@ import time
 from typing import Optional
 
 from event_bus import EventBus
-from plain2code_console import console
 from plain2code_events import LogMessageEmitted
 
 
@@ -42,6 +41,7 @@ class TuiLoggingHandler(logging.Handler):
         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)
@@ -49,8 +49,11 @@ class TuiLoggingHandler(logging.Handler):
     def emit(self, record):
         try:
             # Extract structured data from the log record
-
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(record.created))
+            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}"
             event = LogMessageEmitted(
                 logger_name=record.name,
                 level=record.levelname,
@@ -63,6 +66,10 @@ class TuiLoggingHandler(logging.Handler):
                 self.event_bus.publish(event)
             else:
                 self._buffer.append(event)
+        except RuntimeError:
+            # We're going to get this crash after the TUI app is closed (forcefully).
+            # NOTE: This should be more thought out.
+            pass
         except Exception:
             self.handleError(record)
 
@@ -123,5 +130,4 @@ def dump_crash_logs(args, formatter=None):
     if crash_handler and args.filename:
         log_file_path = get_log_file_path(args.filename, args.log_file_name)
 
-        if crash_handler.dump_to_file(log_file_path, formatter):
-            console.error(f"\nLogs have been dumped to {log_file_path}")
+        crash_handler.dump_to_file(log_file_path, formatter)

plain2code_utils.py

@@ -24,15 +24,17 @@ def print_dry_run_output(plain_source_tree: dict, render_range: Optional[list[st
             console.info(
                 "-------------------------------------"
                 f"Rendering functional requirement {frid}"
-                f"[b]{functional_requirement_text}[/b]"
+                f"{functional_requirement_text}"
                 "-------------------------------------"
             )
             if plain_spec.ACCEPTANCE_TESTS in specifications:
                 for i, acceptance_test in enumerate(specifications[plain_spec.ACCEPTANCE_TESTS], 1):
-                    console.info(f"\nGenerating acceptance test #{i}:\n\n{acceptance_test}")
+                    console.info(f"Generating acceptance test #{i}:\n\n{acceptance_test}")
         else:
-            console.info("-------------------------------------")
-            console.info(f"Skipping rendering iteration: {frid}")
-            console.info("-------------------------------------")
+            console.info(
+                "-------------------------------------\n"
+                f"Skipping rendering iteration: {frid}\n"
+                "-------------------------------------"
+            )
 
         frid = plain_spec.get_next_frid(plain_source_tree, frid)

plain_file.py

@@ -44,22 +44,6 @@ class PlainFileParseResult:
     required_concepts: list[str]
 
 
-class OnlyRelativeLinksAllowed(Exception):
-    pass
-
-
-class LinkMustHaveTextSpecified(Exception):
-    pass
-
-
-class InvalidPlainFileExtension(Exception):
-    pass
-
-
-class PlainModuleNotFound(Exception):
-    pass
-
-
 class PlainRenderer(MarkdownRenderer):
     def render_link(self, token: Link) -> Iterable[Fragment]:
         yield from self.embed_span(
@@ -95,12 +79,12 @@ def check_section_for_linked_resources(section):
     for link in traverse(section, klass=Link):
         parsed_url = urlparse(link.node.target)
         if parsed_url.scheme != "" or os.path.isabs(link.node.target):
-            raise OnlyRelativeLinksAllowed(
+            raise PlainSyntaxError(
                 f"Only relative links are allowed (text: {link.node.children[0].content}, target: {link.node.target})."
             )
 
         if len(link.node.children) != 1:
-            raise LinkMustHaveTextSpecified(f"Link must have text specified (link: {link.node.target}).")
+            raise PlainSyntaxError(f"Link must have text specified (link: {link.node.target}).")
 
         linked_resources.append({"text": link.node.children[0].content, "target": link.node.target})
 
@@ -222,7 +206,7 @@ def _process_single_acceptance_test_requirement(functional_requirement: mistleto
             # Handle the case when the heading is not valid. This case includes cases such as:
             # - Writing `acceptance test` instead of `acceptance tests` (or any other syntax diffs).
             # - Instead of specifying `acceptance tests` below the functional requirement, creator of the plain file
-            #   might have specified some other building block (e.g. `technical specs`)
+            #   might have specified some other building block (e.g. `implementation reqs`)
             raise PlainSyntaxError(acceptance_test_heading_problem)
 
         if is_acceptance_test_heading:
@@ -529,7 +513,7 @@ def parse_plain_source(  # noqa: C901
 def read_module_plain_source(module_name: str, template_dirs: list[str]) -> str:
     plain_source_text = file_utils.open_from(template_dirs, module_name + PLAIN_SOURCE_FILE_EXTENSION)
     if plain_source_text is None:
-        raise PlainModuleNotFound(f"Module does not exist ({module_name}).")
+        raise PlainSyntaxError(f"Module does not exist ({module_name}).")
     return plain_source_text
 
 
@@ -566,12 +550,9 @@ def process_required_modules(
         if len(all_required_modules) > 0 and module_name == all_required_modules[-1]:
             continue
 
-        try:
-            plain_file_parse_result = parse_plain_file(
-                module_name, code_variables, template_dirs, imported_modules=[], modules_trace=[]
-            )
-        except PlainModuleNotFound:
-            raise PlainSyntaxError(f"Required module not found ({module_name}).")
+        plain_file_parse_result = parse_plain_file(
+            module_name, code_variables, template_dirs, imported_modules=[], modules_trace=[]
+        )
 
         if len(plain_file_parse_result.required_modules) == 0:
             if len(all_required_modules) > 0:
@@ -644,7 +625,7 @@ def plain_file_parser(  # noqa: C901
     # and we need to pass them to the marshalled_plain_source_tree after it's rendered
     plain_source_file_path = Path(plain_source_file_name)
     if plain_source_file_path.suffix != PLAIN_SOURCE_FILE_EXTENSION:
-        raise InvalidPlainFileExtension(
+        raise PlainSyntaxError(
             f"Invalid plain file extension: {plain_source_file_path.suffix}. Expected: {PLAIN_SOURCE_FILE_EXTENSION}."
         )
 
@@ -652,16 +633,13 @@ def plain_file_parser(  # noqa: C901
 
     code_variables = {}
 
-    try:
-        plain_file_parse_result = parse_plain_file(
-            module_name,
-            code_variables,
-            template_dirs,
-            imported_modules=[],
-            modules_trace=[],
-        )
-    except PlainModuleNotFound as e:
-        raise PlainSyntaxError(e.message)
+    plain_file_parse_result = parse_plain_file(
+        module_name,
+        code_variables,
+        template_dirs,
+        imported_modules=[],
+        modules_trace=[],
+    )
 
     if len(plain_file_parse_result.required_concepts) > 0:
         missing_required_concepts_msg = "Missing required concepts: "

plain_modules.py

@@ -7,6 +7,7 @@ from git.exc import NoSuchPathError
 
 import git_utils
 import plain_spec
+from plain2code_exceptions import ModuleDoesNotExistError
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
 
 CODEPLAIN_MEMORY_SUBFOLDER = ".memory"
@@ -16,10 +17,6 @@ MODULE_FUNCTIONALITIES = "functionalities"
 REQUIRED_MODULES_FUNCTIONALITIES = "required_modules_functionalities"
 
 
-class ModuleDoesNotExistError(Exception):
-    pass
-
-
 class PlainModule:
     def __init__(self, name: str, build_folder: str):
         self.name = name

plain_spec.py

@@ -5,9 +5,11 @@ from typing import Optional
 
 from liquid2.filter import with_context
 
+from plain2code_exceptions import InvalidLiquidVariableName
+
 DEFINITIONS = "definitions"
-NON_FUNCTIONAL_REQUIREMENTS = "technical specs"
-TEST_REQUIREMENTS = "test specs"
+NON_FUNCTIONAL_REQUIREMENTS = "implementation reqs"
+TEST_REQUIREMENTS = "test reqs"
 FUNCTIONAL_REQUIREMENTS = "functional specs"
 ACCEPTANCE_TESTS = "acceptance_tests"
 ACCEPTANCE_TEST_HEADING = "acceptance tests"
@@ -23,10 +25,6 @@ ALLOWED_SPECIFICATION_HEADINGS = [
 ALLOWED_IMPORT_SPECIFICATION_HEADINGS = [DEFINITIONS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS]
 
 
-class InvalidLiquidVariableName(Exception):
-    pass
-
-
 def collect_specification_linked_resources(specification, specification_heading, linked_resources_list):
     linked_resources = []
     if "linked_resources" in specification:
@@ -180,6 +178,26 @@ def get_previous_frid(plain_source_tree, frid):
     raise Exception(f"Functional requirement {frid} does not exist.")
 
 
+def get_frids_before(plain_source_tree, target_frid: str) -> list[str]:
+    """
+    Get all FRIDs that appear before the target FRID in the specification.
+
+    Args:
+        plain_source_tree: The plain source tree
+        target_frid: The FRID to find predecessors for
+
+    Returns:
+        List of FRIDs that appear before target_frid, in order
+    """
+    previous_frids = []
+    for frid in get_frids(plain_source_tree):
+        if frid == target_frid:
+            break
+        previous_frids.append(frid)
+
+    return previous_frids
+
+
 def get_specification_item_markdown(specification_item, code_variables, replace_code_variables):
     markdown = specification_item["markdown"]
     if "code_variables" in specification_item:

render_machine/actions/create_dist.py

@@ -21,6 +21,6 @@ class CreateDist(BaseAction):
                 render_context.conformance_tests.get_module_conformance_tests_folder(render_context.module_name),
                 render_context.conformance_tests_dest,
             )
-        console.info(f"Render {render_context.run_state.render_id} completed successfully.")
+        console.info(f"[#79FC96]Render {render_context.run_state.render_id} completed successfully.[/#79FC96]")
 
         return self.SUCCESSFUL_OUTCOME, None

render_machine/actions/exit_with_error.py

@@ -18,7 +18,7 @@ class ExitWithError(BaseAction):
 
         if render_context.frid_context is not None:
             console.info(
-                f"To continue rendering from the last successfully rendered functional requirement, provide the [red][b]--render-from {render_context.frid_context.frid}[/b][/red] flag."
+                f"To continue rendering from the last successfully rendered functional requirement, provide the [red]--render-from {render_context.frid_context.frid}[/red] flag."
             )
 
         if render_context.run_state.render_id is not None:

render_machine/actions/prepare_testing_environment.py

@@ -14,7 +14,7 @@ class PrepareTestingEnvironment(BaseAction):
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         if render_context.verbose:
             console.info(
-                f"[b]Running testing environment preparation script {render_context.prepare_environment_script} for build folder {render_context.build_folder}.[/b]"
+                f"Running testing environment preparation script {render_context.prepare_environment_script} for build folder {render_context.build_folder}."
             )
         exit_code, _, preparation_temp_file_path = render_utils.execute_script(
             render_context.prepare_environment_script,

render_machine/actions/render_conformance_tests.py

@@ -24,7 +24,7 @@ class RenderConformanceTests(BaseAction):
 
     def _render_conformance_tests(self, render_context: RenderContext):
         if render_context.verbose:
-            console.info("[b]Implementing test requirements:[/b]")
+            console.info("Implementing test requirements:")
             console.print_list(
                 render_context.conformance_tests_running_context.current_testing_frid_specifications[
                     plain_spec.TEST_REQUIREMENTS
@@ -149,9 +149,7 @@ class RenderConformanceTests(BaseAction):
         ]
 
         if render_context.verbose:
-            console.info("\n[b]Generating acceptance test:[/b]")
-            console.info(f"[b]{acceptance_test}[/b]")
-            console.info()
+            console.info(f"Generating acceptance test:\n  {acceptance_test}")
 
         with console.status(
             f"[{console.INFO_STYLE}]Generating acceptance test for functional requirement {render_context.frid_context.frid}...\n"

render_machine/actions/render_functional_requirement.py

@@ -25,14 +25,14 @@ class RenderFunctionalRequirement(BaseAction):
         _, memory_files_content = MemoryManager.fetch_memory_files(render_context.memory_manager.memory_folder)
 
         if render_context.verbose:
-            msg = f"Module: {render_context.module_name}\n"
-            msg += f"Rendering functional requirement {render_context.frid_context.frid}"
+            msg = "-------------------------------------\n"
+            msg += f"Module: {render_context.module_name}\n"
+            msg += f"Rendering functionality {render_context.frid_context.frid}"
             if render_context.frid_context.functional_requirement_render_attempts > 1:
                 msg += f", attempt number {render_context.frid_context.functional_requirement_render_attempts}/{MAX_CODE_GENERATION_RETRIES}."
-            msg += f"\n[b]{render_context.frid_context.functional_requirement_text}[/b]"
-            console.info("-------------------------------------")
+            msg += f"\n{render_context.frid_context.functional_requirement_text}\n"
+            msg += "-------------------------------------"
             console.info(msg)
-            console.info("-------------------------------------")
 
         try:
             if render_context.verbose:
@@ -54,7 +54,7 @@ class RenderFunctionalRequirement(BaseAction):
                     render_context.run_state,
                 )
         except FunctionalRequirementTooComplex as e:
-            error_message = f"The functional requirement:\n[b]{render_context.frid_context.functional_requirement_text}[/b]\n is too complex to be implemented. Please break down the functional requirement into smaller parts ({str(e)})."
+            error_message = f"The functional requirement:\n{render_context.frid_context.functional_requirement_text}\n is too complex to be implemented. Please break down the functional requirement into smaller parts ({str(e)})."
             if e.proposed_breakdown:
                 error_message += "\nProposed breakdown:"
                 for _, part in e.proposed_breakdown["functional_requirements"].items():

render_machine/actions/run_conformance_tests.py

@@ -32,17 +32,18 @@ class RunConformanceTests(BaseAction):
 
         if render_context.verbose:
             console.info(
-                f"\n[b]Running conformance tests script {render_context.conformance_tests_script} "
+                f"Running conformance tests script {render_context.conformance_tests_script} "
                 + f"for {conformance_tests_folder_name} ("
                 + f"functional requirement {render_context.conformance_tests_running_context.current_testing_frid} "
                 + f"in module {render_context.conformance_tests_running_context.current_testing_module_name}"
-                + ").[/b]"
+                + ")."
             )
         exit_code, conformance_tests_issue, conformance_tests_temp_file_path = render_utils.execute_script(
             render_context.conformance_tests_script,
             [render_context.build_folder, conformance_tests_folder_name],
             render_context.verbose,
             "Conformance Tests",
+            render_context.conformance_tests_running_context.current_testing_frid,
         )
         render_context.script_execution_history.latest_conformance_test_output_path = conformance_tests_temp_file_path
         render_context.script_execution_history.should_update_script_outputs = True

render_machine/actions/run_unit_tests.py

@@ -17,7 +17,7 @@ class RunUnitTests(BaseAction):
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
         if render_context.verbose:
             console.info(
-                f"[b]Running unit tests script {render_context.unittests_script}.[/b] (attempt: {render_context.unit_tests_running_context.fix_attempts + 1})"
+                f"Running unit tests script {render_context.unittests_script}. (attempt: {render_context.unit_tests_running_context.fix_attempts + 1})"
             )
         exit_code, unittests_issue, unittests_temp_file_path = render_utils.execute_script(
             render_context.unittests_script,