live-markdown 0.1.0__tar.gz

live_markdown-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.3
+Name: live-markdown
+Version: 0.1.0
+Summary: Add your description here
+Requires-Dist: pygments>=2.19.2
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+

live_markdown-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "live-markdown"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "pygments>=2.19.2",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.4,<0.9.0"]
+build-backend = "uv_build"
+[project.scripts]
+lm = "live_markdown.pipe:main"

live_markdown-0.1.0/src/live_markdown/__init__.py

@@ -0,0 +1,356 @@
+import re
+import shutil
+import sys
+
+# Note: In this environment, pygments is available for syntax highlighting.
+try:
+    from pygments import highlight
+    from pygments.formatters import Terminal256Formatter
+    from pygments.lexers import (
+        BashLexer,
+        JavascriptLexer,
+        MarkdownLexer,
+        PythonLexer,
+        get_lexer_by_name,
+    )
+    from pygments.util import ClassNotFound
+except ImportError:
+    # Fallback for environments without pygments
+    print("Pygments not found. Highlighting will be disabled.")
+
+
+class MarkdownStreamer:
+    """
+    A terminal-based streamer that parses Markdown syntax on the fly.
+    Supports recursive rendering with visual indentation for text, but
+    keeps code blocks left-aligned for better readability and copying.
+    """
+
+    # Palette for nesting depths
+    BGS = [
+        "\033[48;5;235m",  # Depth 1: Darkest
+        "\033[48;5;237m",  # Depth 2
+        "\033[48;5;239m",  # Depth 3
+        "\033[48;5;241m",  # Depth 4: Lightest
+    ]
+
+    ANSI = {
+        "reset": "\033[0m",
+        "bold": "\033[1m",
+        "italic": "\033[3m",
+        "strikethrough": "\033[9m",
+        "code_in": "\033[36m",
+        "header": "\033[1;95m",
+        "quote": "\033[1;34m",
+        "hr": "\033[90m",
+        "bullet": "\033[1;33m",
+        "clear_line": "\033[2K",
+        "clear_down": "\033[J",
+        "fill_bg": "\033[K",
+        "move_right": "\033[{}C",
+    }
+
+    def __init__(self):
+        self.buffer = ""
+        self.code_block_depth = 0
+        self.depth_stack = []
+        self.current_code_lang = ""
+        self.current_code_line = ""
+        self.code_history = ""  # Crucial for multiline Python strings/docstrings
+        self.at_line_start = True
+        self.active_styles = set()
+
+        self.word_buffer = ""
+        self.line_pos = 0
+        self.term_width = shutil.get_terminal_size().columns
+        self.last_rendered_line_hl = ""
+
+        try:
+            self.formatter = Terminal256Formatter(style="monokai")
+            self.lexers = {
+                "python": PythonLexer(),
+                "bash": BashLexer(),
+                "javascript": JavascriptLexer(),
+                "js": JavascriptLexer(),
+            }
+        except:
+            self.formatter = None
+            self.lexers = {}
+
+    def get_block_bg(self):
+        if self.code_block_depth == 0:
+            return ""
+        idx = min(self.code_block_depth - 1, len(self.BGS) - 1)
+        return self.BGS[idx]
+
+    def apply_indentation(self, depth=None):
+        """
+        Moves cursor right for text content.
+        NO indentation is applied if inside a code block.
+        """
+        if self.code_block_depth > 0:
+            return
+
+        d = depth if depth is not None else self.code_block_depth
+        if d <= 1:
+            return
+        move_len = (d - 1) * 4
+        sys.stdout.write(self.ANSI["move_right"].format(move_len))
+        self.line_pos += move_len
+
+    def apply_pygments(self, text, lang="python"):
+        if not self.formatter or not text:
+            return f"{self.get_block_bg()}{text}"
+
+        lang = lang.lower()
+        bg = self.get_block_bg()
+        if lang == "markdown":
+            return f"{bg}{text}"
+
+        lexer = self.lexers.get(lang)
+        if not lexer:
+            try:
+                lexer = get_lexer_by_name(lang)
+                self.lexers[lang] = lexer
+            except:
+                return f"{bg}{text}"
+
+        full_context = self.code_history + text
+        full_hl = highlight(full_context, lexer, self.formatter).rstrip("\n")
+
+        if self.code_history:
+            hist_hl = highlight(self.code_history, lexer, self.formatter).rstrip("\n")
+            clean_hl = full_hl[len(hist_hl) :].lstrip("\n")
+        else:
+            clean_hl = full_hl
+
+        clean_hl = clean_hl.replace("\033[0m", "\033[0m" + bg)
+        return f"{bg}{clean_hl}"
+
+    def _clear_and_move_up(self, line_text):
+        visible_text = re.sub(r"\033\[[0-9;]*m", "", line_text)
+        # Indent is 0 for code blocks
+        indent = 0 if self.code_block_depth > 0 else (self.code_block_depth - 1) * 4
+        total_len = max(0, indent) + len(visible_text)
+        visual_rows = (max(0, total_len - 1)) // self.term_width
+
+        sys.stdout.write("\r")
+        for _ in range(visual_rows):
+            sys.stdout.write("\033[F")
+
+        sys.stdout.write(self.ANSI["clear_down"])
+        sys.stdout.flush()
+
+    def _flush_word(self, prefix="", depth=None):
+        if not self.word_buffer:
+            return
+        visible_word = re.sub(r"\033\[[0-9;]*m", "", self.word_buffer)
+        if self.line_pos + len(visible_word) >= self.term_width - 1:
+            sys.stdout.write("\n")
+            self.line_pos = 0
+            self.apply_indentation(depth)
+            sys.stdout.write(prefix)
+        sys.stdout.write(self.word_buffer)
+        self.line_pos += len(visible_word)
+        self.word_buffer = ""
+
+    def process_buffer(self, final=False):
+        while len(self.buffer) > 0 or (final and self.word_buffer):
+            if final and not self.buffer and self.word_buffer:
+                bg = self.get_block_bg()
+                self._flush_word(prefix=bg, depth=self.code_block_depth)
+                sys.stdout.flush()
+                break
+
+            if not final and len(self.buffer) < 25:
+                break
+            bg = self.get_block_bg()
+
+            # --- 1. CODE BLOCK HANDLING ---
+            if self.code_block_depth > 0 and self.current_code_lang != "markdown":
+                close_match = re.match(r"^[ \t]*```[ \t]*\n?", self.buffer)
+                if close_match and self.at_line_start:
+                    if self.current_code_line:
+                        self._clear_and_move_up(self.current_code_line)
+                        self.apply_indentation()  # No-op for code
+                        sys.stdout.write(
+                            self.apply_pygments(
+                                self.current_code_line, self.current_code_lang
+                            )
+                        )
+                        sys.stdout.write(f"{self.ANSI['fill_bg']}\n")
+                    self.code_block_depth -= 1
+                    self.current_code_lang = (
+                        self.depth_stack.pop() if self.depth_stack else ""
+                    )
+                    self.current_code_line = ""
+                    self.code_history = ""
+                    self.buffer = self.buffer[close_match.end() :]
+                    self.at_line_start = True
+                    sys.stdout.write(self.ANSI["reset"])
+                    if self.code_block_depth > 0:
+                        sys.stdout.write(self.get_block_bg())
+                    self.line_pos = 0
+                    continue
+
+                char = self.buffer[0]
+                self.buffer = self.buffer[1:]
+                if char == "\n":
+                    self._clear_and_move_up(self.current_code_line)
+                    self.apply_indentation()  # No-op for code
+                    sys.stdout.write(
+                        self.apply_pygments(
+                            self.current_code_line, self.current_code_lang
+                        )
+                    )
+                    sys.stdout.write(f"{self.ANSI['fill_bg']}\n")
+                    self.code_history += self.current_code_line + "\n"
+                    self.current_code_line = ""
+                    self.last_rendered_line_hl = ""
+                    self.at_line_start = True
+                    self.line_pos = 0
+                else:
+                    new_line_content = self.current_code_line + char
+                    new_hl = self.apply_pygments(
+                        new_line_content, self.current_code_lang
+                    )
+                    visible_len = len(re.sub(r"\033\[[0-9;]*m", "", new_line_content))
+                    # Check wrap without indentation for code
+                    is_wrap = (visible_len) % self.term_width == 0
+                    if not new_hl.startswith(self.last_rendered_line_hl) or is_wrap:
+                        self._clear_and_move_up(self.current_code_line)
+                        self.apply_indentation()  # No-op for code
+                        sys.stdout.write(new_hl)
+                    else:
+                        delta = new_hl[len(self.last_rendered_line_hl) :]
+                        sys.stdout.write(delta)
+                    self.current_code_line = new_line_content
+                    self.last_rendered_line_hl = new_hl
+                    self.at_line_start = False
+                sys.stdout.flush()
+                continue
+
+            # --- 2. MARKDOWN / ROOT HANDLING ---
+            if self.at_line_start:
+                open_match = re.match(
+                    r"^[ \t]*```([a-zA-Z0-9\-\+#]+).*\n?", self.buffer
+                )
+                if open_match:
+                    new_lang = open_match.group(1).lower()
+                    self.depth_stack.append(self.current_code_lang)
+                    self.code_block_depth += 1
+                    self.current_code_lang = new_lang
+                    self.code_history = ""
+                    self.last_rendered_line_hl = ""
+                    self.buffer = self.buffer[open_match.end() :]
+                    self.at_line_start = True
+                    sys.stdout.write(self.get_block_bg())
+                    continue
+                # HR
+                if self.buffer.startswith(("---", "***")):
+                    self.apply_indentation()
+                    sys.stdout.write(
+                        f"{bg}{self.ANSI['hr']}{'─' * (self.term_width - self.line_pos)}{self.ANSI['reset']}\n"
+                    )
+                    self.buffer = self.buffer[3:]
+                    self.line_pos = 0
+                    continue
+                # Headers
+                header_match = re.match(r"^(#+) ", self.buffer)
+                if header_match:
+                    self.apply_indentation()
+                    self.word_buffer = (
+                        f"{bg}{self.ANSI['header']}{header_match.group()}"
+                    )
+                    self._flush_word(prefix=bg)
+                    self.buffer = self.buffer[len(header_match.group()) :]
+                    self.at_line_start = False
+                    continue
+                # Lists
+                list_match = re.match(r"^[ \t]*([\*\-\+]) ", self.buffer)
+                if list_match:
+                    self.apply_indentation()
+                    sys.stdout.write(
+                        f"{self.ANSI['bullet']}{list_match.group(1)}{self.ANSI['reset']}{bg} "
+                    )
+                    self.line_pos += 2
+                    self.buffer = self.buffer[len(list_match.group()) :]
+                    self.at_line_start = False
+                    continue
+                # Quotes
+                if self.buffer.startswith("> "):
+                    self.apply_indentation()
+                    sys.stdout.write(f"{self.ANSI['quote']}┃ {self.ANSI['reset']}{bg}")
+                    self.line_pos += 2
+                    self.buffer = self.buffer[2:]
+                    self.at_line_start = False
+                    continue
+
+            # Inline processing
+            char = self.buffer[0]
+            if char == "\\":
+                if len(self.buffer) > 1:
+                    self.word_buffer += self.buffer[1]
+                    self.buffer = self.buffer[2:]
+                else:
+                    self.buffer = self.buffer[1:]
+            elif self.buffer.startswith("**"):
+                self._toggle_style("bold", bg)
+                self.buffer = self.buffer[2:]
+            elif self.buffer.startswith(("*", "_")):
+                self._toggle_style("italic", bg)
+                self.buffer = self.buffer[1:]
+            elif self.buffer.startswith("~~"):
+                self._toggle_style("strikethrough", bg)
+                self.buffer = self.buffer[2:]
+            elif self.buffer.startswith("`"):
+                self._toggle_style("code_in", bg)
+                self.buffer = self.buffer[1:]
+            elif char in (" ", "\n"):
+                self._flush_word(prefix=bg)
+                if char == "\n":
+                    sys.stdout.write(f"{self.ANSI['fill_bg']}\n")
+                    self.line_pos = 0
+                    self.at_line_start = True
+                    sys.stdout.write(self.ANSI["reset"] + bg)
+                    self.active_styles.clear()
+                else:
+                    sys.stdout.write(f"{bg} ")
+                    self.line_pos += 1
+                self.buffer = self.buffer[1:]
+            else:
+                self.word_buffer += char
+                self.buffer = self.buffer[1:]
+                self.at_line_start = False
+        sys.stdout.flush()
+
+    def _toggle_style(self, style, base_prefix):
+        if style in self.active_styles:
+            self.active_styles.remove(style)
+        else:
+            self.active_styles.add(style)
+        style_string = self.ANSI["reset"] + base_prefix
+        for s in self.active_styles:
+            style_string += self.ANSI[s]
+        self.word_buffer += style_string
+
+    def terminal_stream(self, text):
+        self.term_width = shutil.get_terminal_size().columns
+        for char in text:
+            self.buffer += char
+            self.process_buffer()
+        self.process_buffer(final=True)
+
+
+parser = MarkdownStreamer()
+if __name__ == "__main__":
+    parser = MarkdownStreamer()
+    test_text = """# Nested Test
+> Inside a quote
+> ```javascript
+> function hello() {
+>     console.log("This block should be left-aligned.");
+> }
+> ```
+"""
+    parser.terminal_stream(test_text)

live_markdown-0.1.0/src/live_markdown/pipe.py

@@ -0,0 +1,29 @@
+import sys
+
+
+def read_stdin_chunks(chunk_size=16):
+    """
+    Reads from sys.stdin in chunks of a specified size.
+    """
+    buffer = ""
+    while True:
+        # Read a chunk of data from stdin
+        chunk = sys.stdin.read(chunk_size)
+        buffer += chunk
+        if not chunk:
+            break
+        yield chunk
+    return buffer
+
+
+# Example usage: read in 4096 byte chunks (a common buffer size)
+def main():
+    try:
+        from live_markdown import parser
+
+        parser.terminal_stream(read_stdin_chunks(1))
+    except EOFError:
+        pass
+    except KeyboardInterrupt:
+        # Handle cases where input is interactive and needs manual termination (Ctrl+D/Ctrl+Z)
+        pass

live_markdown-0.1.0/src/live_markdown/test_cases.py

@@ -0,0 +1,100 @@
+"""
+A collection of high-complexity Markdown strings designed to stress-test
+terminal-based streamers and parsers.
+"""
+
+TEST_SUITE = {
+    "indentation_hell": """# 🏗️ Indentation Hell
+This test checks if the parser can handle shifting indentation levels without losing track of the background.
+
+    ```python
+    def nested_indent():
+        if True:
+            for i in range(1):
+                print("Level 1 (4 spaces)")
+    ```
+
+        ```javascript
+        console.log("Level 2 (8 spaces)");
+        ```
+
+            ```bash
+            echo "Level 3 (12 spaces)"
+            ```
+""",
+    "ansi_collision": """# 💥 ANSI Collision Test
+This test places high-density formatting right at the typical 80-character terminal wrap boundary.
+
+**Bold**_Italic_`Code`**Bold**_Italic_`Code`**Bold**_Italic_`Code`**Bold**_Italic_`Code`**Bold**_Italic_`Code`**Bold**_Italic_`Code`**Bold**_Italic_`Code`**Bold**_Italic_`Code`
+
+> > > > Deeply nested quotes to see if the prefixing logic correctly calculates width and wraps the text to the next line with the correct prefix.
+""",
+    "code_in_code": """# 🪆 Matryoshka Code Blocks
+Markdown-in-Markdown recursion test.
+
+```markdown
+# Level 1
+This is a markdown block.
+
+```python
+# Level 2
+print("This is python inside markdown")
+```
+```
+""",
+    "mixed_list_logic": """# 📋 Mixed List Logic
+1. First item
+    * Nested bullet
+    * Another bullet with `inline code`
+2. Second item
+    > A blockquote inside a list item.
+    > ```javascript
+    > console.log("Code inside quote inside list");
+    > ```
+3. Third item
+    ---
+    Horizontal rule inside list.
+""",
+    "function_call_chaos": """# 🚀 Function Call Chaos
+This test case features a massive, deeply nested function call with extreme line lengths to stress-test horizontal wrapping and vertical clearing.
+
+```python
+def main_orchestrator():
+    # Deeply nested call within an indented block
+    result = external_api_service.process_complex_request(
+        header_data={"auth_token": "abc_123_xyz_pdq_long_token_string_that_keeps_going_and_going_to_force_a_wrap_within_a_dictionary_definition"},
+        payload=[
+            {
+                "id": 1,
+                "message": "The quick brown fox jumps over the lazy dog while the streamer tries to maintain the background color across four physical lines of terminal output.",
+                "metadata": {
+                    "nested_call": compute_secondary_metrics(
+                        source_id="SRC-999-X-RAY-ZULU-OMEGA-LONG-ID-0001",
+                        threshold=0.999999999999,
+                        callback=lambda x: print(f"Recursive string inside callback with **Markdown** markers: {x}")
+                    )
+                }
+            }
+        ],
+        timeout=None,
+        retry_policy="exponential_backoff_with_jitter_and_multiple_other_parameters_that_extend_this_line_to_the_absolute_edge_of_the_screen_buffer"
+    )
+    return result
+```
+
+> **Note**: If the background color "leaks" or the lines above the function call are duplicated during the streaming of the `payload` section, the wrapping-aware clearing logic has failed.
+""",
+    "unclosed_chaos": """# ⚠️ Unclosed Chaos
+Testing how the streamer handles incomplete syntax.
+
+```python
+def unfinished():
+    print("This block never closes...
+""",
+}
+from live_markdown import parser
+
+for key, val in TEST_SUITE.items():
+    print(key)
+    parser.terminal_stream(val)
+    pass

live_markdown-0.1.0/src/live_markdown/test_parser.py

@@ -0,0 +1,408 @@
+import re
+import shutil
+import sys
+import time
+
+# Note: In this environment, pygments is available for syntax highlighting.
+try:
+    from pygments import highlight
+    from pygments.formatters import Terminal256Formatter
+    from pygments.lexers import (
+        BashLexer,
+        JavascriptLexer,
+        MarkdownLexer,
+        PythonLexer,
+        get_lexer_by_name,
+    )
+    from pygments.util import ClassNotFound
+except ImportError:
+    # Fallback for environments without pygments (though usually available here)
+    print("Pygments not found. Highlighting will be disabled.")
+
+
+class MarkdownStreamer:
+    """
+    A terminal-based streamer that parses Markdown syntax on the fly.
+    Supports recursive rendering with visual indentation and symmetrical colored dividers.
+    """
+
+    # Palette for nesting depths
+    BGS = [
+        "\033[48;5;235m",  # Depth 1: Darkest
+        "\033[48;5;237m",  # Depth 2
+        "\033[48;5;239m",  # Depth 3
+        "\033[48;5;241m",  # Depth 4: Lightest
+    ]
+
+    # Palette for divider lines (slightly darker/different than the block itself)
+    DIVIDER_BGS = [
+        "\033[48;5;232m",  # Divider 1
+        "\033[48;5;234m",  # Divider 2
+        "\033[48;5;236m",  # Divider 3
+        "\033[48;5;238m",  # Divider 4
+    ]
+
+    ANSI = {
+        "reset": "\033[0m",
+        "bold": "\033[1m",
+        "italic": "\033[3m",
+        "code_in": "\033[36m",
+        "header": "\033[1;95m",
+        "quote": "\033[1;34m",
+        "hr": "\033[90m",
+        "clear_line": "\033[2K",
+        "fill_bg": "\033[K",
+    }
+
+    def __init__(self):
+        self.buffer = ""
+        self.code_block_depth = 0
+        self.depth_stack = []  # Tracks language history to allow exiting markdown
+        self.current_code_lang = ""
+        self.current_code_line = ""
+        self.at_line_start = True
+        self.active_styles = set()
+
+        # Word Wrapping State
+        self.word_buffer = ""
+        self.line_pos = 0
+        self.term_width = shutil.get_terminal_size().columns
+
+        # Pygments setup
+        try:
+            self.formatter = Terminal256Formatter(style="monokai")
+            self.lexers = {
+                "python": PythonLexer(),
+                "bash": BashLexer(),
+                "javascript": JavascriptLexer(),
+                "js": JavascriptLexer(),
+            }
+        except:
+            self.formatter = None
+            self.lexers = {}
+
+    def get_block_bg(self):
+        """Returns the background ANSI code based on current depth."""
+        if self.code_block_depth == 0:
+            return ""
+        idx = min(self.code_block_depth - 1, len(self.BGS) - 1)
+        return self.BGS[idx]
+
+    def get_divider_bg(self, depth=None):
+        """Returns the background ANSI code for the divider based on specific or current depth."""
+        d = depth if depth is not None else self.code_block_depth
+        if d == 0:
+            return ""
+        idx = min(d - 1, len(self.DIVIDER_BGS) - 1)
+        return self.DIVIDER_BGS[idx]
+
+    def get_indent(self, depth=None):
+        """Returns pure spaces for indentation based on depth."""
+        d = depth if depth is not None else self.code_block_depth
+        if d <= 1:
+            return ""
+        return "    " * (d - 1)
+
+    def draw_background_divider(self, depth=None):
+        """Prints an empty line with a unique divider background color."""
+        d = depth if depth is not None else self.code_block_depth
+        if d == 0:
+            return
+        bg = self.get_divider_bg(d)
+        divider = f"{bg}{self.ANSI['fill_bg']}\n"
+        sys.stdout.write(divider)
+
+    def apply_pygments(self, text, lang="python"):
+        """
+        Applies syntax highlighting. Always ensures the block background is present.
+        """
+        if not self.formatter:
+            return text
+
+        lang = lang.lower()
+        bg = self.get_block_bg()
+        indent = self.get_indent()
+
+        if lang == "markdown":
+            return f"{bg}{indent}{text}"
+
+        lexer = self.lexers.get(lang)
+        if not lexer:
+            try:
+                lexer = get_lexer_by_name(lang)
+                self.lexers[lang] = lexer
+            except:
+                return f"{bg}{indent}{text}"
+
+        if not text:
+            return f"{bg}{indent}"
+
+        highlighted = highlight(text, lexer, self.formatter)
+        clean_hl = highlighted.rstrip("\n")
+        # Ensure resetting style doesn't lose the block background
+        clean_hl = clean_hl.replace("\033[0m", "\033[0m" + bg)
+
+        return f"{bg}{indent}{clean_hl}"
+
+    def _clear_and_move_up(self, highlighted_text):
+        """
+        Clears the current line(s) by calculating how many visual lines
+        the text occupied based on terminal width.
+        """
+        if not highlighted_text:
+            sys.stdout.write(f"\r{self.ANSI['clear_line']}")
+            return
+
+        # Strip ANSI to calculate actual visible length
+        visible_text = re.sub(r"\033\[[0-9;]*m", "", highlighted_text)
+
+        # Calculate rows: visible text length / terminal width
+        visual_rows = (
+            (len(visible_text) - 1) // self.term_width if len(visible_text) > 0 else 0
+        )
+
+        # Move up to the start of the wrapped block
+        for _ in range(visual_rows):
+            sys.stdout.write("\033[F")
+
+        sys.stdout.write("\r")
+
+        # Clear every line that was part of the wrapped text
+        for i in range(visual_rows + 1):
+            sys.stdout.write(self.ANSI["clear_line"])
+            if i < visual_rows:
+                sys.stdout.write("\n")
+
+        # Return to the original top-left position of the cleared block
+        for _ in range(visual_rows):
+            sys.stdout.write("\033[F")
+        sys.stdout.write("\r")
+
+    def _flush_word(self, prefix=""):
+        if not self.word_buffer:
+            return
+
+        visible_word = re.sub(r"\033\[[0-9;]*m", "", self.word_buffer)
+
+        if self.line_pos + len(visible_word) >= self.term_width - 1:
+            sys.stdout.write("\n" + prefix)
+            self.line_pos = len(re.sub(r"\033\[[0-9;]*m", "", prefix))
+
+        sys.stdout.write(self.word_buffer)
+        self.line_pos += len(visible_word)
+        self.word_buffer = ""
+
+    def process_buffer(self, final=False):
+        while len(self.buffer) >= (1 if final else 30):
+            bg = self.get_block_bg()
+            indent = self.get_indent()
+
+            # --- 1. CODE BLOCK HANDLING (Literal Highlighting Mode) ---
+            # If we are in a literal code block (NOT markdown), backticks should close it.
+            if self.code_block_depth > 0 and self.current_code_lang != "markdown":
+                close_match = re.match(r"^[ \t]*```[ \t]*\n?", self.buffer)
+                if close_match and self.at_line_start:
+                    if self.current_code_line:
+                        typing_hl = self.apply_pygments(
+                            self.current_code_line, self.current_code_lang
+                        )
+                        self._clear_and_move_up(typing_hl)
+                        final_hl = self.apply_pygments(
+                            self.current_code_line, self.current_code_lang
+                        )
+                        sys.stdout.write(f"{final_hl}{self.ANSI['fill_bg']}\n")
+
+                    self.code_block_depth -= 1
+                    # Restore previous language from stack
+                    if self.depth_stack:
+                        self.current_code_lang = self.depth_stack.pop()
+                    else:
+                        self.current_code_lang = ""
+
+                    self.current_code_line = ""
+                    self.buffer = self.buffer[close_match.end() :]
+                    self.at_line_start = True
+                    sys.stdout.write(self.ANSI["reset"])
+                    if self.code_block_depth > 0:
+                        sys.stdout.write(self.get_block_bg())
+                    self.line_pos = 0
+                    continue
+
+                # Normal character processing for literal code blocks
+                char = self.buffer[0]
+                self.buffer = self.buffer[1:]
+                if char == "\n":
+                    typing_hl = self.apply_pygments(
+                        self.current_code_line, self.current_code_lang
+                    )
+                    self._clear_and_move_up(typing_hl)
+                    final_hl = self.apply_pygments(
+                        self.current_code_line, self.current_code_lang
+                    )
+                    sys.stdout.write(f"{final_hl}{self.ANSI['fill_bg']}\n")
+                    self.current_code_line = ""
+                    self.at_line_start = True
+                else:
+                    old_typing_hl = self.apply_pygments(
+                        self.current_code_line, self.current_code_lang
+                    )
+                    self._clear_and_move_up(old_typing_hl)
+                    self.current_code_line += char
+                    new_typing_hl = self.apply_pygments(
+                        self.current_code_line, self.current_code_lang
+                    )
+                    sys.stdout.write(f"{new_typing_hl}{self.ANSI['fill_bg']}")
+                    self.at_line_start = False
+                sys.stdout.flush()
+                continue
+
+            # --- 2. MARKDOWN / ROOT HANDLING ---
+            if self.at_line_start:
+                # Priority 1: Opening a new block (at depth 0 or depth 1 markdown)
+                open_match = re.match(r"^[ \t]*```([a-zA-Z]+)[ \t]*\n?", self.buffer)
+                if open_match:
+                    new_lang = open_match.group(1).lower()
+                    self.depth_stack.append(self.current_code_lang)
+                    self.code_block_depth += 1
+                    self.current_code_lang = new_lang
+                    self.buffer = self.buffer[open_match.end() :]
+                    self.at_line_start = True
+                    sys.stdout.write(self.get_block_bg())
+                    continue
+
+                # Priority 2: Closing current markdown block
+                # We only close a markdown block if we see plain backticks (no language)
+                if self.current_code_lang == "markdown":
+                    close_match = re.match(r"^[ \t]*```[ \t]*(\n|$)", self.buffer)
+                    if close_match:
+                        self.code_block_depth -= 1
+                        if self.depth_stack:
+                            self.current_code_lang = self.depth_stack.pop()
+                        else:
+                            self.current_code_lang = ""
+                        self.buffer = self.buffer[close_match.end() :]
+                        self.at_line_start = True
+                        sys.stdout.write(self.ANSI["reset"])
+                        if self.code_block_depth > 0:
+                            sys.stdout.write(self.get_block_bg())
+                        self.line_pos = 0
+                        continue
+
+                if self.buffer.startswith("---"):
+                    sys.stdout.write(
+                        f"{bg}{self.ANSI['hr']}{'─' * self.term_width}{self.ANSI['reset']}\n"
+                    )
+                    self.buffer = self.buffer[3:]
+                    self.line_pos = 0
+                    continue
+
+                if self.buffer.startswith("#"):
+                    match = re.match(r"^(#+) ", self.buffer)
+                    if match:
+                        self.word_buffer = (
+                            f"{bg}{indent}{self.ANSI['header']}{match.group()}"
+                        )
+                        self._flush_word(prefix=bg + indent)
+                        self.buffer = self.buffer[len(match.group()) :]
+                        self.at_line_start = False
+                        continue
+
+            # Standard Inline Markdown
+            is_quote = "> " in self.buffer[:5] or (
+                self.at_line_start and self.buffer.startswith("> ")
+            )
+            quote_prefix = (
+                f"{self.ANSI['quote']}┃ {self.ANSI['reset']}{bg}" if is_quote else ""
+            )
+            full_prefix = bg + indent + quote_prefix
+
+            if self.at_line_start:
+                sys.stdout.write(bg + indent)
+                self.line_pos += len(indent)
+                if self.buffer.startswith("> "):
+                    sys.stdout.write(quote_prefix)
+                    self.line_pos += 2
+                    self.buffer = self.buffer[2:]
+
+            char = self.buffer[0]
+            if char == "\\":
+                if len(self.buffer) > 1:
+                    self.word_buffer += self.buffer[1]
+                    self.buffer = self.buffer[2:]
+                else:
+                    self.buffer = self.buffer[1:]
+            elif self.buffer.startswith("**"):
+                self._toggle_style("bold", bg + indent)
+                self.buffer = self.buffer[2:]
+            elif self.buffer.startswith("_"):
+                self._toggle_style("italic", bg + indent)
+                self.buffer = self.buffer[1:]
+            elif self.buffer.startswith("`"):
+                self._toggle_style("code_in", bg + indent)
+                self.buffer = self.buffer[1:]
+            elif char in (" ", "\n"):
+                self._flush_word(prefix=full_prefix)
+                if char == "\n":
+                    sys.stdout.write(f"{self.ANSI['fill_bg']}\n")
+                    self.line_pos = 0
+                    self.at_line_start = True
+                    sys.stdout.write(self.ANSI["reset"] + bg)
+                    self.active_styles.clear()
+                else:
+                    sys.stdout.write(f"{bg} ")
+                    self.line_pos += 1
+                self.buffer = self.buffer[1:]
+            else:
+                self.word_buffer += char
+                self.buffer = self.buffer[1:]
+                self.at_line_start = False
+
+            sys.stdout.flush()
+
+    def _toggle_style(self, style, base_prefix):
+        if style in self.active_styles:
+            self.active_styles.remove(style)
+        else:
+            self.active_styles.add(style)
+        style_string = self.ANSI["reset"] + base_prefix
+        for s in self.active_styles:
+            style_string += self.ANSI[s]
+        self.word_buffer += style_string
+
+    def terminal_stream(self, text):
+        self.term_width = shutil.get_terminal_size().columns
+        for char in text:
+            self.buffer += char
+            self.process_buffer()
+        self.process_buffer(final=True)
+
+    def end_of_stream(self, text):
+        sys.stdout.write(self.ANSI["reset"])
+        print("\n\n" + "=" * 20)
+        print("STREAM FINISHED")
+        print("=" * 20)
+
+
+if __name__ == "__main__":
+    parser = MarkdownStreamer()
+    # Test case showing nested code blocks where 'markdown' is the parent
+    nested_test = """# Recursive Logic Test
+Encountering backticks with a language should deepen the nest.
+Encountering plain backticks should close the CURRENT nest level.
+
+```markdown
+This is depth 1 (Markdown).
+
+```python
+def hello():
+    print("I am at depth 2")
+```
+
+Back to depth 1 markdown.
+```
+
+Finished the test at root level.
+"""
+    parser.terminal_stream(nested_test)
+    # sys.stdout.write(parser.ANSI["reset"])
+    # parser.end_of_stream(nested_test)