velm 0.1.2__py3-none-any.whl

velm/parser_core/parser/parser_scribes/symphony_scribes/symphony_logic_scribe.py

@@ -0,0 +1,152 @@
+# Path: scaffold/parser_core/parser/parser_scribes/symphony_scribes/symphony_logic_scribe.py
+# ------------------------------------------------------------------------------------------
+
+"""
+=================================================================================
+== THE ORACLE OF GNOSTIC LOGIC (V-Ω-LEGENDARY. THE BRANCHING MIND)             ==
+=================================================================================
+LIF: 10,000,000,000,000,000,000,000
+
+This artisan handles the perception of Control Flow: `if:`, `elif:`, and `else:` blocks.
+It uses **Recursive Parsing** to treat the indented body as a mini-symphony,
+nesting the resulting Edicts within a parent Conditional Edict.
+
+It enforces strict grammar on conditions and ensures that no block is a void.
+=================================================================================
+"""
+from typing import List, TYPE_CHECKING, Tuple
+
+from .symphony_block_scribe import SymphonyBlockScribe
+from .....contracts.data_contracts import GnosticVessel, GnosticLineType, ScaffoldItem
+from .....contracts.heresy_contracts import ArtisanHeresy, HeresySeverity
+from .....contracts.symphony_contracts import Edict, EdictType, ConditionalType
+from pathlib import Path
+
+if TYPE_CHECKING:
+    from .....parser_core.parser import ApotheosisParser
+
+
+class SymphonyLogicScribe(SymphonyBlockScribe):
+    """
+    The God-Engine of Gnostic Composition for logic blocks.
+    """
+
+    def __init__(self, parser: 'ApotheosisParser'):
+        super().__init__(parser)
+
+    def _resolve_conditional_type(self, header: str) -> ConditionalType:
+        """
+        [ELEVATION 6: THE TYPE DIVINER]
+        Returns the canonical Enum for the conditional type based on the raw header.
+        """
+        header = header.strip()
+        if header.startswith(('if', '@if')): return ConditionalType.IF
+        if header.startswith(('elif', '@elif')): return ConditionalType.ELIF
+        if header.startswith(('else', '@else')): return ConditionalType.ELSE
+
+        # Fallback should not be reached due to parser triage
+        return ConditionalType.IF
+
+    def _extract_condition(self, raw_header: str, directive: str) -> Tuple[str, str]:
+        """
+        [ELEVATION 1: CONDITION EXTRACTOR & CLEANSER]
+        Surgically removes the keyword and colon.
+        Returns (clean_condition_for_storage, raw_condition_for_logging)
+        """
+        if raw_header.startswith('@'):
+            remainder = raw_header[len(directive) + 1:].strip()
+        else:
+            remainder = raw_header[len(directive):].strip()
+
+        raw_condition = remainder.rstrip(':').strip()
+
+        clean_condition = raw_condition
+        if clean_condition.startswith('{{') and clean_condition.endswith('}}'):
+            clean_condition = clean_condition[2:-2].strip()
+
+        return clean_condition, raw_condition
+
+    def conduct(self, lines: List[str], i: int, vessel: GnosticVessel) -> int:
+        """
+        Conducts the Rite of Logical Branching (V-Ω-TUPLE-CORRECTED).
+
+        *** APOTHEOSIS COMPLETE ***
+        It now proclaims `ScaffoldItems` for logic blocks, making them visible to the AST.
+        """
+        line_num = vessel.line_num
+        raw_header = vessel.raw_scripture.strip()
+        directive = vessel.directive_type
+
+        clean_condition_for_storage, raw_condition_for_logging = self._extract_condition(raw_header, directive)
+        cond_type = self._resolve_conditional_type(raw_header)
+
+        if directive == 'else' and raw_condition_for_logging:
+            self.parser.heresies.append(ArtisanHeresy(
+                f"ELSE_CONDITION_HERESY: 'else' blocks cannot have conditions. Did you mean 'elif'?",
+                line_num=line_num
+            ))
+            return i + 1
+
+        if directive in ('if', 'elif') and not raw_condition_for_logging:
+            raise ArtisanHeresy("LOGIC_HERESY: Conditional block requires a non-empty expression.", line_num=line_num)
+
+        # --- THE DIVINE HEALING: PROCLAIM THE GNOSTIC ANCHOR FOR LOGIC ---
+        logic_anchor_item = ScaffoldItem(
+            path=Path(f"LOGIC:{cond_type.name}:{line_num}"),
+            is_dir=False,
+            content=clean_condition_for_storage,
+            line_num=line_num,
+            raw_scripture=raw_header,
+            original_indent=self.parser._calculate_original_indent(lines[i]),
+            line_type=GnosticLineType.LOGIC,
+            condition_type=cond_type,
+            condition=clean_condition_for_storage
+        )
+        self.parser.raw_items.append(logic_anchor_item)
+        # --- THE APOTHEOSIS IS COMPLETE ---
+
+        block_content, end_index = self._consume_block(lines, i)
+
+        if not block_content.strip():
+            self.parser.heresies.append(ArtisanHeresy(
+                f"EMPTY_LOGIC_HERESY: The '{raw_header}' block is a void. It serves no purpose.",
+                line_num=line_num,
+                severity=HeresySeverity.WARNING
+            ))
+
+        sub_parser = self.parser.__class__(grammar_key='symphony')
+        sub_parser.variables = self.parser.variables.copy()
+
+        _, _, _, sub_edicts, _, _ = sub_parser.parse_string(
+            block_content,
+            self.parser.file_path,
+            line_offset=line_num
+        )
+
+        full_raw_scripture = f"{vessel.raw_scripture}\n{block_content}"
+
+        edict = Edict(
+            type=EdictType.CONDITIONAL,
+            raw_scripture=full_raw_scripture,
+            line_num=line_num,
+            command=clean_condition_for_storage,
+            conditional_type=cond_type,
+            body=sub_edicts
+        )
+
+        self.parser.edicts.append(edict)
+
+        # --- THE DIVINE HEALING PART 2: PROCLAIM THE CLOSING ANCHOR ---
+        closing_anchor_item = ScaffoldItem(
+            path=Path(f"LOGIC:ENDIF:{end_index}"),
+            is_dir=False,
+            line_num=end_index,
+            raw_scripture="@endif",
+            original_indent=self.parser._calculate_original_indent(lines[i]),
+            line_type=GnosticLineType.LOGIC,
+            condition_type=ConditionalType.ENDIF
+        )
+        self.parser.raw_items.append(closing_anchor_item)
+        # --- THE APOTHEOSIS IS COMPLETE ---
+
+        return end_index

velm/parser_core/parser/parser_scribes/symphony_scribes/symphony_parallel_scribe.py

@@ -0,0 +1,156 @@
+# scaffold/parser_core/parser_scribes/symphony_scribes/symphony_parallel_scribe.py
+
+import re
+from typing import List, TYPE_CHECKING, Dict, Any, Optional
+
+from .symphony_block_scribe import SymphonyBlockScribe
+from .....contracts.data_contracts import GnosticVessel, GnosticLineType
+from .....contracts.heresy_contracts import ArtisanHeresy, HeresySeverity
+from .....contracts.symphony_contracts import Edict, EdictType
+
+if TYPE_CHECKING:
+    from .....parser_core.parser import ApotheosisParser
+
+
+class SymphonyParallelScribe(SymphonyBlockScribe):
+    """
+    =================================================================================
+    == THE WEAVER OF SPACETIME (V-Ω-LEGENDARY. THE CONCURRENT ARTISAN)             ==
+    =================================================================================
+    LIF: 10,000,000,000,000
+
+    This artisan handles `parallel:` and `&&:` blocks. It parses the block body
+    recursively but enforces strict Gnostic Laws to ensure concurrent safety.
+
+    It forbids Vows (non-deterministic) and State Changes (race conditions) within
+    the parallel reality.
+    """
+
+    def __init__(self, parser: 'ApotheosisParser'):
+        super().__init__(parser)  # Registers as "SymphonyParallelScribe" via base magic or manual override if needed
+
+    def conduct(self, lines: List[str], i: int, vessel: GnosticVessel) -> int:
+        """
+        Conducts the Rite of Parallelism (V-Ω-TUPLE-CORRECTED).
+        """
+        line_num = vessel.line_num
+        raw_header = vessel.raw_scripture.strip()
+
+        # [ELEVATION 1 & 2: PARAMETER ALCHEMIST & SYNTAX UNIFIER]
+        # We extract parameters from "parallel(workers=2):" or "&&:"
+        # vessel.command holds the stripped line content (e.g. "parallel(workers=2)")
+        params_str = ""
+        match = re.match(r'^(?:parallel|&&|multiverse)(?:\((.*)\))?:?$', vessel.command)
+        if match:
+            params_str = match.group(1)
+
+        parameters = self._parse_alchemical_parameters(params_str)
+        if parameters:
+            self.Logger.verbose(f"L{line_num}: Parallel configuration perceived: {parameters}")
+
+        # [ELEVATION 9: THE INDENTATION NORMALIZER]
+        # Consume the body using the base scribe's logic
+        block_content, end_index = self._consume_block(lines, i)
+
+        # [ELEVATION 3 & 8: EMPTY MULTIVERSE SENTINEL & COMMENT FILTER]
+        if not block_content.strip():
+            # We check if it was truly empty or just comments.
+            # Since _consume_block returns raw text, we can't easily tell without parsing.
+            pass
+
+        # [ELEVATION 4: THE RECURSIVE MIND]
+        # Summon a new parser to interpret the threads
+        sub_parser = self.parser.__class__(grammar_key='symphony')
+
+        # We parse the block content to get the sub-edicts (threads)
+        # [FIX] THE LAW OF THE GNOSTIC DOWRY (6-Tuple Unpacking)
+        # (parser, items, commands, edicts, vars, dossier)
+        _, _, _, sub_edicts, _, _ = sub_parser.parse_string(
+            block_content,
+            self.parser.file_path,
+            line_offset=line_num
+        )
+
+        if not sub_edicts:
+            self.parser.heresies.append(ArtisanHeresy(
+                "EMPTY_MULTIVERSE_HERESY: A parallel block must contain at least one thread of execution.",
+                line_num=line_num,
+                severity=HeresySeverity.WARNING
+            ))
+
+        # --- THE GNOSTIC INQUISITION OF THREADS ---
+        for sub_edict in sub_edicts:
+            # [ELEVATION 5: THE VOW SENTINEL]
+            if sub_edict.type == EdictType.VOW:
+                self.parser.heresies.append(ArtisanHeresy(
+                    "VOW_IN_PARALLEL_HERESY: Vows (`??`) cannot be made inside a parallel block due to non-deterministic completion order.",
+                    line_num=sub_edict.line_num
+                ))
+
+            # [ELEVATION 6: THE STATE GUARDIAN]
+            elif sub_edict.type == EdictType.STATE:
+                self.parser.heresies.append(ArtisanHeresy(
+                    "STATE_IN_PARALLEL_HERESY: State changes (`%%`) are forbidden in parallel blocks to prevent race conditions.",
+                    line_num=sub_edict.line_num
+                ))
+
+            # [ELEVATION 7: THE NESTED PARADOX WARD]
+            elif sub_edict.type == EdictType.PARALLEL_RITE:
+                self.parser.heresies.append(ArtisanHeresy(
+                    "NESTED_MULTIVERSE_HERESY: Nested parallel blocks are forbidden to preserve sanity.",
+                    line_num=sub_edict.line_num
+                ))
+
+        # [ELEVATION 10: THE RAW SCRIPTURE WEAVER]
+        full_raw_scripture = f"{vessel.raw_scripture}\n{block_content}"
+
+        # [ELEVATION 11: THE ARGUMENT PACKER]
+        directive_args = [f"{k}={v}" for k, v in parameters.items()]
+
+        # Forge the Edict
+        edict = Edict(
+            type=EdictType.PARALLEL_RITE,
+            raw_scripture=full_raw_scripture,
+            line_num=line_num,
+            parallel_edicts=sub_edicts,
+            directive_args=directive_args
+        )
+
+        self.parser.edicts.append(edict)
+
+        # [ELEVATION 12: THE ATOMIC RETURN]
+        return end_index
+
+    def _parse_alchemical_parameters(self, params_str: Optional[str]) -> Dict[str, Any]:
+        """
+        [THE ALCHEMIST'S GAZE]
+        Parses key=value parameters from the header string.
+        """
+        parameters: Dict[str, Any] = {}
+        if not params_str: return parameters
+
+        # Reusing the robust regex from Polyglot Scribe for consistency
+        param_regex = re.compile(r"""
+            \s* (\w+) \s* = \s* (
+                " (?: \\. | [^"\\] )* " |
+                ' (?: \\. | [^'\\] )* ' |
+                \d+ |
+                (?i:true|false) |
+                [\w.-]+
+            ) \s*
+        """, re.VERBOSE)
+
+        for match in param_regex.finditer(params_str):
+            key, value = match.groups()
+            if value.lower() == 'true':
+                parameters[key] = True
+            elif value.lower() == 'false':
+                parameters[key] = False
+            elif value.isdigit():
+                parameters[key] = int(value)
+            elif (value.startswith("'") and value.endswith("'")) or \
+                    (value.startswith('"') and value.endswith('"')):
+                parameters[key] = value[1:-1]
+            else:
+                parameters[key] = value
+        return parameters

velm/parser_core/parser/parser_scribes/symphony_scribes/symphony_polyglot_scribe.py

@@ -0,0 +1,293 @@
+# scaffold/parser_core/parser_scribes/symphony_scribes/symphony_polyglot_scribe.py
+
+import re
+from textwrap import dedent
+from typing import List, TYPE_CHECKING, Dict, Any, Tuple, Optional
+
+from .symphony_block_scribe import SymphonyBlockScribe
+from .....contracts.data_contracts import GnosticVessel, GnosticLineType
+from .....contracts.heresy_contracts import ArtisanHeresy
+from .....contracts.symphony_contracts import Edict, EdictType
+
+if TYPE_CHECKING:
+    from .....parser_core.parser import ApotheosisParser
+
+
+class SymphonyPolyglotScribe(SymphonyBlockScribe):
+    """
+    =================================================================================
+    == THE GNOSTIC AMBASSADOR (V-Ω-LEGENDARY. THE POLYGLOT INTERPRETER)            ==
+    =================================================================================
+    LIF: 10,000,000,000,000,000,000
+
+    This divine artisan is the bridge between the Symphony and the Foreign Tongues.
+    It perceives blocks of code written in alien languages (Python, Node, Bash, Go)
+    and transmutes them into a sacred `POLYGLOT_ACTION` Edict.
+
+    It is not merely a copy-paste engine; it is a **Contextual Alchemist**.
+    It extracts metadata, dependencies, and configuration from within the script's
+    very soul (comments and headers), allowing the Conductor to prepare a perfect,
+    sandboxed reality for the foreign rite.
+
+    ### The Pantheon of Faculties:
+    1.  **The Header Parser:** Decodes complex parameters like `py(filesystem='read-only', timeout=30):`.
+    2.  **The Metadata Miner:** Digs into the script body for Gnostic directives like `# requirements: pandas, requests`.
+    3.  **The Import resolver:** Recognizes `# import: ./utils.py` to weave external code into the ephemeral execution context.
+    4.  **The Indented Consumer:** Flawlessly consumes indented blocks, preserving their relative structure while stripping the container's indentation.
+    """
+
+    def __init__(self, parser: 'ApotheosisParser'):
+        # We invoke the name of the base block scribe to register our identity
+        super().__init__(parser)
+
+    def conduct(self, lines: List[str], i: int, vessel: GnosticVessel) -> int:
+        """
+        =================================================================================
+        == THE GNOSTIC AMBASSADOR (V-Ω-DUAL-TONGUED. THE POLYGLOT TRIAGE)              ==
+        =================================================================================
+        LIF: 10,000,000,000,000
+
+        This Scribe is a master of Gnostic Triage. It perceives the Architect's will
+        and summons the correct internal artisan for either the modern Indented Soul
+        or the ancient Delimited Soul.
+        """
+        # --- I. THE GNOSTIC TRIAGE ---
+        raw_header = vessel.raw_scripture.strip()
+
+        # PATH A: The Modern Rite (Indented Soul)
+        # Gaze for the colon, which signals an indented block.
+        if raw_header.endswith(':'):
+            return self._conduct_indented_rite(lines, i, vessel)
+
+        # PATH B: The Ancient Rite (Delimited Soul)
+        # Gaze for the '>>' sigil, which signals a delimited block.
+        elif '>>' in raw_header:
+            return self._conduct_delimited_rite(lines, i, vessel)
+
+        else:
+            # A heresy that should be architecturally impossible.
+            self.parser.heresies.append(ArtisanHeresy(
+                "AMBIGUOUS_POLYGLOT_HERESY: The polyglot scripture is malformed.",
+                line_num=vessel.line_num
+            ))
+            return i + 1
+
+    def _conduct_indented_rite(self, lines: List[str], i: int, vessel: GnosticVessel) -> int:
+        """Conducts the modern, Pythonic rite: `py:...`"""
+        line_num = vessel.line_num
+        language = vessel.language
+
+        self.Logger.verbose(f"L{line_num}: Perceiving an Indented Soul for a '{language}' vessel.")
+
+        # --- MOVEMENT I: THE ALCHEMY OF PARAMETERS ---
+        params_str = ""
+        match = re.match(r'^[a-z]{2,8}(?:\((.*)\))?:?$', vessel.command.strip())
+        if match: params_str = match.group(1)
+
+        parameters = self._parse_alchemical_parameters(params_str)
+        if parameters: self.Logger.verbose(f"   -> Configuration perceived: {parameters}")
+
+        # --- MOVEMENT II: THE CONSUMPTION OF THE BODY ---
+        parent_indent = self.parser._calculate_original_indent(lines[i])
+        content_lines, end_index = self.parser._consume_indented_block_with_context(lines, i + 1, parent_indent)
+
+        # --- MOVEMENT III & IV: METADATA & ARGUMENT FORGING ---
+        # (This logic is pure and shared, so we delegate to a common artisan)
+        pure_script_block, directive_args = self._forge_final_gnosis(content_lines, parameters)
+
+        # --- MOVEMENT V: THE FORGING OF THE EDICT ---
+        full_raw_scripture = vessel.raw_scripture + "\n" + "\n".join(content_lines)
+        edict = Edict(
+            type=EdictType.POLYGLOT_ACTION,
+            raw_scripture=full_raw_scripture,
+            line_num=line_num,
+            language=language,
+            script_block=pure_script_block,
+            directive_args=directive_args,
+            command=vessel.command
+        )
+
+        self.parser.edicts.append(edict)
+        self.Logger.verbose(f"   -> Polyglot Rite (Indented) recorded. Handing control back at line {end_index}.")
+
+        return end_index
+
+    def _conduct_delimited_rite(self, lines: List[str], i: int, vessel: GnosticVessel) -> int:
+        """Conducts the ancient, shell-like rite: `py >> ... <<`"""
+        line_num = vessel.line_num
+        language = vessel.language
+
+        self.Logger.verbose(f"L{line_num}: Perceiving a Delimited Soul for a '{language}' vessel.")
+
+        # --- MOVEMENT I: THE CONSUMPTION OF THE BODY ---
+        # The body starts on the next line and ends with '<<'
+        content_lines = []
+        j = i + 1
+        found_end = False
+        while j < len(lines):
+            line = lines[j]
+            if line.strip() == '<<':
+                found_end = True
+                j += 1  # Consume the '<<' line
+                break
+            content_lines.append(line)
+            j += 1
+
+        end_index = j
+
+        if not found_end:
+            raise ArtisanHeresy("UNCLOSED_POLYGLOT_HERESY: Delimited polyglot block was not closed with '<<'.",
+                                line_num=line_num)
+
+        # --- MOVEMENT II & III: METADATA & ARGUMENT FORGING ---
+        pure_script_block, directive_args = self._forge_final_gnosis(content_lines, {})  # No params in header
+
+        # --- MOVEMENT IV: THE FORGING OF THE EDICT ---
+        full_raw_scripture = "\n".join(lines[i:end_index])
+        edict = Edict(
+            type=EdictType.POLYGLOT_ACTION,
+            raw_scripture=full_raw_scripture,
+            line_num=line_num,
+            language=language,
+            script_block=pure_script_block,
+            directive_args=directive_args,
+            command=vessel.command
+        )
+
+        self.parser.edicts.append(edict)
+        self.Logger.verbose(f"   -> Polyglot Rite (Delimited) recorded. Handing control back at line {end_index}.")
+
+        return end_index
+
+    def _forge_final_gnosis(self, content_lines: List[str], parameters: Dict[str, Any]) -> Tuple[str, List[str]]:
+        """
+        [THE PURE ALCHEMIST] A universal helper that forges the final script and args
+        from the raw content and header parameters.
+        """
+        # 1. The Mining of Metadata
+        script_block_lines, dependencies, imports, return_type = self._consume_gnostic_metadata(content_lines)
+
+        # 2. The Gnostic Purification (Dedent)
+        # We must handle the case of an empty block gracefully
+        if not script_block_lines:
+            pure_script_block = ""
+        else:
+            pure_script_block = dedent("\n".join(script_block_lines))
+
+        # 3. The Forging of the Arguments
+        directive_args = [f"{k}={v}" for k, v in parameters.items()]
+        if dependencies:
+            directive_args.append(f"requirements={','.join(dependencies)}")
+            self.Logger.verbose(f"   -> Dependencies mined: {dependencies}")
+        if imports:
+            directive_args.append(f"imports={','.join(imports)}")
+            self.Logger.verbose(f"   -> Imports requested: {imports}")
+        if return_type:
+            directive_args.append(f"return={return_type}")
+
+        return pure_script_block, directive_args
+
+    def _parse_alchemical_parameters(self, params_str: Optional[str]) -> Dict[str, Any]:
+        """
+        [THE ALCHEMIST'S GAZE]
+        A divine, sentient artisan for parsing key-value Gnosis from a parameter string.
+        It handles:
+        - Unquoted values: key=value
+        - Quoted values: key="value with spaces"
+        - Booleans: key=true (Case insensitive)
+        - Integers: key=123
+        """
+        parameters: Dict[str, Any] = {}
+        if not params_str: return parameters
+
+        # The Regex of Extraction:
+        # \s*(\w+)      -> Capture the Key (alphanumeric)
+        # \s*=\s*       -> The Equals bridge
+        # ( ... )       -> Capture the Value group
+        # " ... "       -> Double quoted string (handling escaped quotes)
+        # ' ... '       -> Single quoted string
+        # \d+           -> Integers
+        # true|false    -> Booleans
+        # [\w.-]+       -> Simple strings (filenames, identifiers)
+        param_regex = re.compile(r"""
+            \s* (\w+) \s* = \s* (
+                " (?: \\. | [^"\\] )* " |
+                ' (?: \\. | [^'\\] )* ' |
+                \d+ |
+                (?i:true|false) |
+                [\w.-]+
+            ) \s*
+        """, re.VERBOSE)
+
+        for match in param_regex.finditer(params_str):
+            key, value = match.groups()
+
+            # The Rite of Type Transmutation
+            if value.lower() == 'true':
+                parameters[key] = True
+            elif value.lower() == 'false':
+                parameters[key] = False
+            elif value.isdigit():
+                parameters[key] = int(value)
+            elif (value.startswith("'") and value.endswith("'")) or \
+                    (value.startswith('"') and value.endswith('"')):
+                parameters[key] = value[1:-1]  # Unbox the string
+            else:
+                parameters[key] = value  # Raw string
+
+        return parameters
+
+    def _consume_gnostic_metadata(self, lines: List[str]) -> Tuple[List[str], List[str], List[str], Optional[str]]:
+        """
+        [THE SCRIBE OF THE INDENTED SOUL]
+        Scans the raw lines of the block. If a line is a special Gnostic Comment,
+        it extracts the metadata and removes the line from the final script.
+
+        Supported Directives:
+        - # requirements: package1, package2
+        - # packages: package1 (alias for requirements)
+        - # import: ./local/file.py
+        - # return: json (Hints to the conductor how to parse stdout)
+        """
+        script_lines = []
+        dependencies: List[str] = []
+        imports: List[str] = []
+        return_type: Optional[str] = None
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Dependency Injection
+            if stripped.startswith(('# requirements:', '# packages:')):
+                # Extract everything after the colon, split by comma
+                try:
+                    deps_str = stripped.split(':', 1)[1]
+                    found_deps = [p.strip() for p in deps_str.split(',') if p.strip()]
+                    dependencies.extend(found_deps)
+                except IndexError:
+                    pass # Malformed requirement line, ignore
+                # We do NOT add this line to script_lines; it is consumed.
+
+            # File Injections
+            elif stripped.startswith('# import:'):
+                try:
+                    import_path = stripped.split(':', 1)[1].strip()
+                    if import_path:
+                        imports.append(import_path)
+                except IndexError:
+                    pass
+                # Consumed.
+
+            # Output Type Hinting
+            elif stripped.startswith('# return:'):
+                try:
+                    return_type = stripped.split(':', 1)[1].strip()
+                except IndexError:
+                    pass
+                # Consumed.
+
+            else:
+                # It is pure code. Preserve it.
+                script_lines.append(line)
+
+        return script_lines, dependencies, imports, return_type

velm/prophecy/__Init__.py

@@ -0,0 +1,25 @@
+# Path: scaffold/prophecy/__init__.py
+
+"""
+=================================================================================
+== THE SACRED GATEWAY TO THE GNOSTIC ORACLE                                    ==
+=================================================================================
+This scripture is the one true, public gateway to the God-Engine of Gnostic
+Perception. It proclaims the one, pure, and unbreakable rite that all other
+artisans must summon to receive a prophecy of a project's soul.
+
+It is a Gnostic firewall, guarding the divine, complex machinery of the Oracle
+behind a simple, elegant, and eternal contract.
+=================================================================================
+"""
+from .oracle import prophesy_initial_gnosis
+
+# =================================================================================
+# == THE DIVINE PROCLAMATION: THE ONE TRUE RITE OF PROPHECY                      ==
+# =================================================================================
+# By proclaiming only this one, sacred name, we make an unbreakable vow. The rest
+# of the cosmos shall know only of this rite, not of the God-Engine that performs it.
+# This is the pinnacle of architectural purity and encapsulation.
+__all__ = [
+    "prophesy_initial_gnosis",
+]