velm 0.1.2__py3-none-any.whl

velm/symphony/renderers/rich_renderer/stream_scribe.py

@@ -0,0 +1,301 @@
+# Path: scaffold/symphony/renderers/rich_renderer/stream_scribe.py
+# ----------------------------------------------------------------
+import re
+import json
+import time
+import hashlib
+from typing import Optional, Tuple, Any
+from rich.console import Console, RenderableType
+from rich.text import Text
+from rich.style import Style
+from rich.json import JSON
+from rich.ansi import AnsiDecoder
+from rich.padding import Padding
+from rich.markup import escape
+from .theme import GnosticTheme
+
+
+class StreamScribe:
+    """
+    =================================================================================
+    == THE WRITER OF THE SCROLL (V-Ω-OMNISCIENT-RENDERER)                          ==
+    =================================================================================
+    LIF: ∞ (THE EYES OF THE GOD-ENGINE)
+
+    The Divine Scribe. It consumes raw output from the kinetic realm (subprocess),
+    transmutes it through 12 layers of Gnostic processing, and inscribes it into
+    the eternal stream as Luminous Truth.
+    """
+
+    # --- THE GRIMOIRE OF REGEX (THE ALL-SEEING EYE) ---
+
+    # Matches ANSI OSC escape sequences used for setting window titles (Noise).
+    TITLE_SEQUENCE_REGEX = re.compile(r'\x1b][0-2];.*?(?:\x07|\x1b\\)')
+
+    # Matches high-entropy strings that look like secrets.
+    SECRET_REGEX = re.compile(r'(api_key|token|secret|password|passwd|key)[\s=:"\']+(\S{8,})', re.IGNORECASE)
+
+    # Matches "Key: Value" patterns for alignment.
+    KV_REGEX = re.compile(r'^\s*([a-zA-Z0-9\-_]+):\s+(.*)$')
+
+    # Matches Prompts.
+    PROMPT_REGEX = re.compile(r'(\?|:|\[y/n\])\s*$', re.IGNORECASE)
+
+    # The Palette of Meaning
+    HIGHLIGHTS = [
+        # Critical States
+        (r'(?i)\b(critical dependency|fatal error|panic|crash|exception)\b', 'bold white on red'),
+        (r'(?i)\b(fail|failed|failure|error|err|broken)\b', 'bold red'),
+
+        # Warnings & Attention
+        (r'(?i)\b(warn|warning|deprecated)\b', 'bold yellow'),
+
+        # Success & Completion
+        (r'(?i)\b(success|succeeded|done|finished|completed|ok|upheld|fixed)\b', 'bold green'),
+
+        # HTTP Verbs
+        (r'\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b', 'bold magenta'),
+
+        # File Paths (POSIX/Windows) with Line Numbers
+        # Captures: path, line, col. e.g. /src/main.py:10:5
+        (r'(?P<link_path>(?:[\.]{0,2}/|[a-zA-Z]:\\)[\w\.\-_/\\]+\.\w+)(?::(?P<line>\d+))?(?::(?P<col>\d+))?',
+         'cyan underline'),
+
+        # URLs
+        (r'https?://\S+', 'blue underline'),
+
+        # Metrics & Units
+        (r'\b\d+(\.\d+)?(ms|s|m|KB|MB|GB|%)\b', 'bold magenta'),
+
+        # Quotes & Brackets (Structure)
+        (r"'.*?'|\".*?\"", 'italic bright_white'),
+        (r'\[.*?\]', 'dim white'),
+
+        # UUIDs / Hashes / IPs
+        (r'\b[a-f0-9]{7,40}\b', 'orange3'),
+        (r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b', 'bold blue'),
+    ]
+
+    def __init__(self, console: Console):
+        self.console = console
+        self.decoder = AnsiDecoder()
+        self.width = console.size.width
+
+        # State Tracking for The Mood Engine
+        self.highest_severity = 0  # 0: Info, 1: Success, 2: Warning, 3: Error
+        self.last_line_time = time.time()
+
+        # Pre-compiled styles for performance
+        self.border_style = Style(color="bright_black", dim=True)
+
+    def _hash_secret(self, secret: str) -> str:
+        """[FACULTY 3] The Deterministic Secret Hasher."""
+        # We show the first 4 chars of the sha256 hash to allow tracing without revealing.
+        h = hashlib.sha256(secret.encode()).hexdigest()[:4]
+        return f"[SECRET:{h}]"
+
+    def _sanitize_and_transmute(self, text: str) -> str:
+        """
+        Purifies the raw text of terminal control sequences and secrets.
+        """
+        # 1. Annihilate Window Title sequences
+        text = self.TITLE_SEQUENCE_REGEX.sub('', text)
+
+        # 2. Transmute Secrets (The Hasher)
+        def replace_secret(match):
+            key = match.group(1)
+            secret = match.group(2)
+            return f"{key} {self._hash_secret(secret)}"
+
+        text = self.SECRET_REGEX.sub(replace_secret, text)
+        return text
+
+    def _apply_gnostic_highlights(self, text_obj: Text):
+        """
+        [FACULTY 9] Layers Gnostic semantic meaning onto the text.
+        """
+        text_str = text_obj.plain
+
+        # 1. Regex Highlights
+        for pattern, style in self.HIGHLIGHTS:
+            # We iterate matches to handle complex groups (like links)
+            for match in re.finditer(pattern, text_str):
+                # If it's a file link, we forge the Hyperlink
+                if 'link_path' in match.groupdict() and match.group('link_path'):
+                    path = match.group('link_path')
+                    line = match.group('line') or "1"
+                    col = match.group('col') or "1"
+                    # VS Code / Modern Terminal Link Format
+                    url = f"file://{path}"  # Simplified, ideally needs absolute path resolution
+                    text_obj.stylize(style, match.start(), match.end())
+                    # Note: Rich Text doesn't support adding hyperlinks via regex easily in one pass
+                    # without complex span manipulation, so we stick to visual styling for now.
+                else:
+                    text_obj.stylize(style, match.start(), match.end())
+
+        # 2. [FACULTY 6] Markdown Projection
+        # Detect backticks `code`
+        for match in re.finditer(r'`([^`]+)`', text_str):
+            text_obj.stylize("bold white on black", match.start(), match.end())
+
+    def _render_rich_content(self, text: str) -> RenderableType:
+        """
+        [FACULTY 1] The JSON Diviner & [FACULTY 10] Markdown Projector.
+        Decides if the line is complex data or simple text.
+        """
+        stripped = text.strip()
+
+        # Try JSON
+        if (stripped.startswith('{') and stripped.endswith('}')) or \
+                (stripped.startswith('[') and stripped.endswith(']')):
+            try:
+                # We ensure it's valid JSON
+                json.loads(stripped)
+                return JSON(stripped)
+            except ValueError:
+                pass
+
+        # Return Text object
+        return None
+
+    def print_header(self, command: str):
+        """
+        Inscribes the Luminous Header.
+        ╭── 📦 command ───...
+        """
+        self.highest_severity = 0  # Reset mood
+        self.last_line_time = time.time()
+
+        max_len = self.width - 10
+        display_cmd = command if len(command) < max_len else command[:max_len - 3] + "..."
+        icon, style_name = GnosticTheme.get_icon_and_style(command)
+
+        prefix = "╭── "
+        # Calculate suffix length to fill the line
+        suffix_len = max(0, self.width - len(prefix) - len(display_cmd) - 3 - 2)
+        suffix = " " + ("─" * suffix_len)
+
+        header_text = Text.assemble(
+            (prefix, self.border_style),
+            (f"{icon} ", "default"),
+            (f"{display_cmd}", "bold white"),
+            (suffix, self.border_style)
+        )
+        self.console.print(header_text)
+
+    def print_log(self, content: str):
+        """
+        [THE CORE RITE]
+        Inscribes a line of the process output.
+        """
+        clean_content = self._sanitize_and_transmute(content)
+
+        # Update Mood Engine
+        lower_content = clean_content.lower()
+        if "error" in lower_content or "fail" in lower_content:
+            self.highest_severity = 3
+        elif "warn" in lower_content:
+            self.highest_severity = max(self.highest_severity, 2)
+
+        # [FACULTY 4] Chronometric Delta
+        now = time.time()
+        delta = now - self.last_line_time
+        self.last_line_time = now
+        delta_str = f"+{delta:.2f}s" if delta > 0.01 else ""
+        delta_style = "dim" if delta < 1.0 else "bold yellow" if delta < 5.0 else "bold red"
+
+        # Check for Rich Content (JSON)
+        rich_renderable = self._render_rich_content(clean_content)
+
+        if rich_renderable:
+            # If JSON, we render it inside a padded block
+            self.console.print(Text("│  ", style=self.border_style), end="")
+            self.console.print(rich_renderable)
+            return
+
+        # Decode ANSI (Faculty 8)
+        text_obj = self.decoder.decode_line(clean_content.rstrip('\n'))
+
+        # [FACULTY 5] Key-Value Alchemy
+        # If line matches "Key: Value", bold the key
+        kv_match = self.KV_REGEX.match(text_obj.plain)
+        if kv_match:
+            key_span = kv_match.span(1)
+            text_obj.stylize("bold cyan", key_span[0], key_span[1])
+
+        # [FACULTY 7] Interactive Sentinel
+        if self.PROMPT_REGEX.search(text_obj.plain):
+            text_obj.stylize("bold yellow blink")
+
+        # Apply Gnostic Highlights
+        self._apply_gnostic_highlights(text_obj)
+
+        # Assemble final line with Border and Delta
+        final_line = Text.assemble(
+            ("│  ", self.border_style),
+            text_obj,
+            (" " * max(1, self.width - len("│  ") - len(text_obj) - len(delta_str) - 1), ""),
+            (delta_str, delta_style)
+        )
+
+        self.console.print(final_line)
+
+    def print_footer(self, success: bool, duration: float):
+        """
+        [FACULTY 10] The Mood Engine determines the footer color.
+        """
+        # Determine final mood
+        if not success:
+            self.highest_severity = 3
+        elif self.highest_severity == 0:
+            self.highest_severity = 1  # Success if no errors seen
+
+        mood_styles = {
+            0: "dim",  # Info only
+            1: "bold green",  # Success
+            2: "bold yellow",  # Warnings
+            3: "bold red"  # Errors
+        }
+        mood_style = mood_styles.get(self.highest_severity, "dim")
+
+        status_icon = "✔" if success else "✘"
+        status_text = "Done" if success else "Failed"
+
+        prefix = "╰──── "
+
+        footer_text = Text.assemble(
+            (prefix, self.border_style),
+            (f"{status_icon} {status_text}", mood_style),
+            (f" ({duration:.2f}s)", "dim")
+        )
+        self.console.print(footer_text)
+
+    def print_vow(self, message: str, success: bool):
+        """Inscribes a Vow Adjudication."""
+        icon = "✔" if success else "✘"
+        style = "bold green" if success else "bold red"
+
+        # Vows break the vertical line to stand out
+        self.console.print(Text.assemble(
+            ("├─ ", self.border_style),
+            (f"{icon} ", style),
+            (message, "white")
+        ))
+
+    def print_state(self, key: str, value: str):
+        """Inscribes a Metaphysical State Change."""
+        self.console.print(Text.assemble(
+            ("│  ", self.border_style),
+            ("⚡ ", "yellow"),
+            ("State: ", "dim"),
+            (key, "cyan"),
+            (" = ", "dim"),
+            (value, "bold white")
+        ))
+
+    def print_system_message(self, message: str, style: str = "dim italic white"):
+        """Inscribes a meta-message from the Engine."""
+        self.console.print(Text.assemble(
+            ("│  ", self.border_style),
+            (f"[{message}]", style)
+        ))

velm/symphony/renderers/rich_renderer/theme.py

@@ -0,0 +1,106 @@
+# scaffold/symphony/renderers/rich_renderer/theme.py
+
+from typing import Tuple, Dict
+
+
+class GnosticTheme:
+    """
+    =============================================================================
+    == THE GNOSTIC THEME (V-Ω-CYBER-AESTHETICS)                                ==
+    =============================================================================
+    The Visual Soul of the Renderer. Maps commands to Sigils and Colors.
+    """
+
+    # The Grimoire of Icons
+    ICONS: Dict[str, str] = {
+        'npm': '📦',
+        'node': '⬢',
+        'yarn': '🧶',
+        'pnpm': '📦',
+        'bun': '🥟',
+        'python': '🐍',
+        'pip': '🧪',
+        'poetry': '📜',
+        'docker': '🐳',
+        'docker-compose': '🐙',
+        'git': '🌲',
+        'go': '🐹',
+        'rustc': '🦀',
+        'cargo': '📦',
+        'terraform': '🏗️',
+        'kubectl': '☸️',
+        'aws': '☁️',
+        'make': '🔨',
+        'sh': '🐚',
+        'bash': '🐚',
+        'echo': '📢',
+        'rm': '🔥',
+        'mkdir': '📂',
+        'touch': '📄',
+        'scaffold': '🏗️',
+        'default': '⚙️'
+    }
+
+    # The Palette of Power (Command Headers)
+    STYLES: Dict[str, str] = {
+        'npm': 'bold red',
+        'node': 'bold green',
+        'python': 'bold blue',
+        'pip': 'bold yellow',
+        'poetry': 'bold cyan',
+        'docker': 'bold cyan',
+        'git': 'dim white',
+        'go': 'bold cyan',
+        'rust': 'bold orange3',
+        'terraform': 'bold magenta',
+        'echo': 'bold white',
+        'default': 'white'
+    }
+
+    # --- NEW: The Luminous Log Palette ---
+    # These map to the regex groups in StreamScribe
+    LOG_STYLES = {
+        "log.success": "bold green",  # DONE, SUCCESS
+        "log.warning": "bold yellow",  # WARN, WARNING
+        "log.error": "bold red",  # ERR, ERROR, Failed
+        "log.path": "cyan underline",  # /path/to/file.js
+        "log.number": "bold magenta",  # 10ms, 5.2s, 100%
+        "log.url": "blue underline",  # https://...
+        "log.quote": "italic bright_white",  # "quoted strings"
+        "log.bracket": "dim white",  # [text]
+        "log.key": "cyan",  # key=
+        "log.uuid": "orange3"  # a1b2...
+    }
+
+    # Spinner types for the Living Stream
+    SPINNER_DEFAULT = 'dots'
+    SPINNER_INSTALL = 'bouncingBar'
+    SPINNER_BUILD = 'star'
+    SPINNER_NETWORK = 'earth'
+    SPINNER_WAIT = 'clock'
+
+    @classmethod
+    def get_icon_and_style(cls, command_text: str) -> Tuple[str, str]:
+        """Divines the correct sigil and color for a command."""
+        cmd_start = command_text.strip().split(' ')[0]
+        # Handle "python -m" etc
+        if cmd_start == "python" or cmd_start == "python3":
+            return cls.ICONS['python'], cls.STYLES['python']
+
+        icon = cls.ICONS.get(cmd_start, cls.ICONS['default'])
+        style = cls.STYLES.get(cmd_start, cls.STYLES['default'])
+        return icon, style
+
+    @classmethod
+    def get_spinner(cls, command_text: str) -> str:
+        """Divines the appropriate animation for the wait."""
+        cmd = command_text.lower()
+        if "install" in cmd or "download" in cmd or "fetch" in cmd:
+            return cls.SPINNER_INSTALL
+        if "build" in cmd or "compile" in cmd or "transmute" in cmd:
+            return cls.SPINNER_BUILD
+        if "network" in cmd or "connect" in cmd or "ssh" in cmd:
+            return cls.SPINNER_NETWORK
+        if "wait" in cmd or "sleep" in cmd:
+            return cls.SPINNER_WAIT
+        return cls.SPINNER_DEFAULT

velm/symphony/renderers/rich_renderer/utils.py

@@ -0,0 +1,29 @@
+# Path: scaffold/symphony/renderers/rich_renderer/utils.py
+# --------------------------------------------------------
+from .theme import GnosticTheme
+
+
+def get_command_icon(command: str) -> str:
+    return GnosticTheme.get_icon_and_style(command)[0]
+
+
+def determine_spinner(command: str) -> str:
+    """
+    [THE ORACLE OF ANIMATION]
+    Divines the appropriate spinner style based on the command intent.
+    """
+    cmd = command.lower()
+
+    if "install" in cmd or "download" in cmd or "fetch" in cmd:
+        return GnosticTheme.SPINNER_INSTALL  # bouncingBar
+
+    if "build" in cmd or "compile" in cmd or "transmute" in cmd:
+        return GnosticTheme.SPINNER_BUILD  # star
+
+    if "network" in cmd or "connect" in cmd or "ssh" in cmd:
+        return GnosticTheme.SPINNER_NETWORK  # earth
+
+    if "wait" in cmd or "sleep" in cmd:
+        return GnosticTheme.SPINNER_WAIT  # clock
+
+    return GnosticTheme.SPINNER_DEFAULT  # dots

velm/symphony/renderers/stream_renderer/__init__.py

@@ -0,0 +1,13 @@
+# Path: scaffold/symphony/renderers/stream_renderer/__init__.py
+# -------------------------------------------------------------
+
+"""
+=================================================================================
+== THE SANCTUM OF THE LINEAR PROPHET (V-Ω-MODULAR-GATEWAY)                     ==
+=================================================================================
+This sanctum exposes the unified StreamRenderer facade.
+It is the chosen voice for raw, unbuffered, real-time feedback.
+"""
+from .facade import StreamRenderer
+
+__all__ = ["StreamRenderer"]

velm/symphony/renderers/stream_renderer/codex.py

@@ -0,0 +1,51 @@
+# Path: scaffold/symphony/renderers/stream_renderer/codex.py
+# ----------------------------------------------------------
+
+from typing import Dict
+
+
+class StreamCodex:
+    """
+    =================================================================================
+    == THE CODEX OF THE RAW STREAM (V-Ω-ASCII-PURITY)                              ==
+    =================================================================================
+    LIF: 10,000,000,000
+
+    A strictly textual palette. No emojis. No complex glyphs.
+    Optimized for parsing by IDEs (VS Code) and CI/CD logs.
+    """
+
+    # --- THE SIGILS OF TEXT ---
+    ICONS: Dict[str, str] = {
+        "start": ">>",  # Action Start
+        "stop": "##",  # Action End
+        "action": ">>",  # Executing
+        "output": "|",  # Stream Line prefix
+        "error": "!!",  # Error
+        "success": "[OK]",  # Success
+        "failure": "[FAIL]",  # Failure
+        "warning": "[WARN]",  # Warning
+        "info": "--",  # Info
+        "meta": "::",  # State Change
+        "vow": "??"  # Vow Check
+    }
+
+    # --- THE PALETTE OF TRUTH ---
+    # Colors are still allowed (ANSI), as most terminals/IDEs render them.
+    STYLES: Dict[str, str] = {
+        "header": "bold magenta",
+        "prologue": "bold cyan",
+        "stream_stdout": "white",
+        "stream_stderr": "yellow",
+        "success": "green",
+        "failure": "red",
+        "meta": "dim white"
+    }
+
+    @classmethod
+    def get_icon(cls, key: str) -> str:
+        return cls.ICONS.get(key, "")
+
+    @classmethod
+    def get_style(cls, key: str) -> str:
+        return cls.STYLES.get(key, "white")

velm/symphony/renderers/stream_renderer/emitter.py

@@ -0,0 +1,116 @@
+# Path: scaffold/symphony/renderers/stream_renderer/emitter.py
+# ------------------------------------------------------------
+
+import sys
+import datetime
+from rich.console import Console
+from rich.text import Text
+from rich.markup import escape
+
+from .codex import StreamCodex
+from ....logger import get_console
+
+
+class LinearEmitter:
+    """
+    =================================================================================
+    == THE GNOSTIC SCRIBE OF THE STREAM (V-Ω-ETERNAL-APOTHEOSIS)                   ==
+    =================================================================================
+    LIF: 10,000,000,000,000 (ABSOLUTE CLARITY)
+
+    The divine artisan responsible for inscribing Gnostic events into the linear
+    stream. It has been ascended to become a **Telepathic Conduit**, a master of
+    structured logging whose every proclamation is a self-aware, machine-readable
+    scripture.
+
+    ### THE PANTHEON OF 12 ASCENDED FACULTIES:
+
+    1.  **The Tag of Origin:** Every line is prefixed with its Gnostic origin
+        (`[meta]`, `[stdout]`, `[stderr]`, `[vow]`), transforming the stream into a
+        parseable database.
+    2.  **The Flush of Immediacy:** Every rite forces a `sys.stdout.flush()`,
+        guaranteeing zero-latency, real-time proclamation.
+    3.  **The ANSI Alchemist:** It perceives ANSI color codes in the raw stream and
+        righteously preserves them, allowing colored output from child processes
+        to pass through the veil.
+    4.  **The Redaction Scribe:** It possesses its own Gaze for secrets, ensuring
+        no profane Gnosis is ever written to the stream.
+    5.  **The Timestamp Anchor:** Meta-events are anchored in time with millisecond
+        precision, creating a perfect forensic chronicle.
+    6.  **The Heresy Channel:** Proclaims paradoxes and errors to `stderr`, keeping
+        the primary `stdout` channel pure for data piping.
+    7.  **The Gnostic Triage:** It intelligently routes proclamations based on their
+        soul (Meta vs. Raw), applying the correct formatting for each.
+    8.  **The Unbreakable Ward:** Its rites are shielded from encoding paradoxes,
+        gracefully handling profane byte sequences.
+    9.  **The Sovereign Soul:** It is a pure, self-contained artisan, its will
+        governed only by the sacred laws of the `StreamCodex`.
+    10. **The Luminous Voice:** It uses the `rich.Text` object as its internal vessel,
+        allowing for the future possibility of complex styling while honoring the
+        current vow of simplicity.
+    11. **The Block Proclaimer:** It renders distinct, high-contrast rule lines to
+        visually separate the grand movements of the Symphony.
+    12. **The Final Word:** It is the one true, definitive voice for machine-to-machine
+        Gnostic communion in a linear, textual reality.
+    """
+
+    def __init__(self):
+        self.console = get_console()
+        self.codex = StreamCodex()
+
+    def emit_meta(self, message: str, style_key: str = "meta", icon_key: str = "meta"):
+        """
+        Proclaims a Gnostic Meta-Event (e.g., "Starting Action", "Vow Passed").
+        These are messages FROM the Scaffold engine about its state.
+        """
+        # [FACULTY 5] The Timestamp Anchor
+        ts = datetime.datetime.now().strftime("%H:%M:%S.%f")[:-3]
+        # [FACULTY 1] The Tag of Origin
+        tag = f"[{style_key}]"
+
+        # We use a Text object for color and style, even in this "basic" renderer
+        text = Text.assemble(
+            (f"[{ts}] {tag.ljust(10)} ", "dim"),
+            (message, self.codex.get_style(style_key))
+        )
+        self.console.print(text)
+        # [FACULTY 2] The Flush of Immediacy
+        sys.stdout.flush()
+
+    def emit_raw_stream(self, content: str, is_stderr: bool = False):
+        """
+        Proclaims raw output from a kinetic process.
+        This is the voice OF the executed command.
+        """
+        # [FACULTY 1] The Tag of Origin
+        tag = "[stderr]" if is_stderr else "[stdout]"
+        stream = sys.stderr if is_stderr else sys.stdout
+
+        # We process line by line to add the prefix
+        lines = content.splitlines()
+        for line in lines:
+            # [FACULTY 4] The Redaction Scribe (Handled by Titan, but can double-check here)
+            # This is where we ensure the output is just the raw line prefixed by our tag.
+            # We don't use Rich formatting here to ensure the output is as pure as possible.
+            stream.write(f"{tag.ljust(10)} {line}\n")
+
+        # [FACULTY 2] The Flush of Immediacy
+        stream.flush()
+
+    def emit_block(self, title: str):
+        """Draws a separator block to signify a major phase change."""
+        self.console.rule(title, style=self.codex.get_style("header"))
+
+    def emit_heresy(self, message: str, details: str = ""):
+        """
+        [FACULTY 6] The Heresy Channel. Proclaims paradoxes to stderr.
+        """
+        tag = "[heresy]"
+        ts = datetime.datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+        sys.stderr.write(f"[{ts}] {tag.ljust(10)} {message}\n")
+        if details:
+            for line in details.splitlines():
+                sys.stderr.write(f"{' ' * 23}  | {line}\n")
+
+        sys.stderr.flush()