termrender 0.3.0__tar.gz → 0.4.0__tar.gz

{termrender-0.3.0 → termrender-0.4.0}/.gitignore

@@ -7,3 +7,6 @@ build/
 .eggs/
 *.egg
 .sisyphus/
+
+# Sisyphus
+.sisyphus

{termrender-0.3.0 → termrender-0.4.0}/CHANGELOG.md

@@ -1,6 +1,28 @@
 # CHANGELOG
 
 
+## v0.4.0 (2026-04-05)
+
+### Features
+
+- **parser**: Variable colon counts, backtick fence directives, and gloam-inspired theming
+  ([`47fac7f`](https://github.com/CaptainCrouton89/termrender/commit/47fac7fcf13d33e5d9986d3f9ca42ddaf5e7207d))
+
+Parser changes: - Support 3+ colon openers/closers with stack-based matching - Backtick fence
+  directive syntax (```{name}) via mistune AST interception - Option line stripping (:key: value)
+  into directive attrs
+
+CLI changes: - Syntax validation before tmux pane creation (no orphan panes on bad input) - TTY
+  auto-detect for color (disabled when piping, forced in tmux subprocess)
+
+Theming (gloam-inspired defaults): - Headings: depth-based colored fg + dim tinted bg
+  (yellow→green→cyan→blue→magenta) - Inline code: cyan (aqua) - Panel borders: dim gray with yellow
+  bold titles - Table borders: blue dim, headers: yellow bold on dim-blue bg - Background color
+  support added to style()
+
+24 new tests across two test files.
+
+
 ## v0.3.0 (2026-04-05)
 
 ### Documentation

{termrender-0.3.0 → termrender-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 0.3.0
+Version: 0.4.0
 Summary: Rich terminal rendering of directive-flavored markdown
 Project-URL: Homepage, https://github.com/CaptainCrouton89/termrender
 Project-URL: Repository, https://github.com/CaptainCrouton89/termrender

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/CLAUDE.md

@@ -12,7 +12,9 @@
 
 ## Directive nesting: depth counter, not stack entries
 
-The parser tracks nested directives of the same type with a `depth` integer inside the top stack entry, not separate stack entries (parser.py:241–306). A closer `:::` only pops the stack when `depth == 1`; otherwise it decrements depth and treats the closer as body content. Consequence: innermost closers appear verbatim in the body of the parent and are re-parsed on the recursive `parse()` call at line 351.
+The parser handles two directive syntaxes through different passes: colon directives (`:::name`) are extracted in pass 1 via regex in `_split_directives`, while backtick fence directives (`` ```{name} ``) are resolved in pass 2 via mistune's AST walk in `_convert_ast`. Both paths funnel through `_directive_to_block` for block construction.
+
+For colon directives, the parser tracks nesting with a `depth` integer inside the top stack entry, not separate stack entries (parser.py:241–306). A closer `:::` only pops the stack when `depth == 1`; otherwise it decrements depth and treats the closer as body content. Consequence: innermost closers appear verbatim in the body of the parent and are re-parsed on the recursive `parse()` call at line 351.
 
 Max recursion depth is 50; exceeding it raises `ValueError`, not `DirectiveError`. Both the render path and `--check` path in `__main__.py` catch `ValueError` and map it to exit code 2 (`EXIT_SYNTAX`).
 

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/__main__.py

@@ -160,6 +160,23 @@ def main() -> None:
 
     # --tmux: render in a new tmux side pane, sized to fit
     if args.tmux:
+        # Validate syntax before creating pane — fail fast to caller's terminal
+        try:
+            from termrender.parser import parse as _parse
+            _parse(source)
+        except DirectiveError as e:
+            _error(
+                f"syntax error: {e}",
+                fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
+                code=EXIT_SYNTAX,
+            )
+        except ValueError as e:
+            _error(
+                f"nesting error: {e}",
+                fix="reduce directive nesting depth (max 50 levels)",
+                code=EXIT_SYNTAX,
+            )
+
         import shlex
         import subprocess
         import tempfile
@@ -211,7 +228,8 @@ def main() -> None:
             cmd_parts.append("--cjk")
         cmd_parts.extend(["-w", str(pane_width)])
 
-        pane_cmd = " ".join(cmd_parts) + " | less -R; rm -f " + shlex.quote(tmpfile)
+        # TERMRENDER_COLOR=1 forces color on despite stdout piping to less
+        pane_cmd = "TERMRENDER_COLOR=1 " + " ".join(cmd_parts) + " | less -R; rm -f " + shlex.quote(tmpfile)
 
         try:
             subprocess.run(
@@ -249,7 +267,10 @@ def main() -> None:
         sys.exit(EXIT_OK)
 
     try:
-        output = render(source, width=args.width, color=not args.no_color)
+        use_color = not args.no_color and (
+            sys.stdout.isatty() or os.environ.get("TERMRENDER_COLOR") == "1"
+        )
+        output = render(source, width=args.width, color=use_color)
     except TerminalError as e:
         _error(
             f"terminal error: {e}",

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/parser.py

@@ -36,12 +36,12 @@ def _sanitize_text(text: str) -> str:
     """Strip non-SGR ANSI escape sequences from text."""
     return _UNSAFE_ANSI_RE.sub('', text)
 
-# Directive opener: :::name or :::name{attrs}
+# Directive opener: :::name or ::::name etc. (3+ colons)
 _DIRECTIVE_OPEN = re.compile(
-    r"^:::(\w+)(?:\{([^}]*)\})?\s*$"
+    r"^(:{3,})(\w+)(?:\{([^}]*)\})?\s*$"
 )
-# Directive closer: exactly ::: on its own line
-_DIRECTIVE_CLOSE = re.compile(r"^:::\s*$")
+# Directive closer: 3+ colons on its own line
+_DIRECTIVE_CLOSE = re.compile(r"^(:{3,})\s*$")
 
 # Attribute parser: key=value or key="quoted value"
 _ATTR_PAIR = re.compile(
@@ -61,6 +61,14 @@ _DIRECTIVE_TO_BLOCK: dict[str, BlockType] = {
 
 _SELF_CLOSING_DIRECTIVES = frozenset({"divider"})
 
+# MyST backtick fence directive: ```{name} optional-argument
+_BACKTICK_DIRECTIVE_RE = re.compile(r"^\{(\w[\w-]*)\}(.*)")
+
+# MyST option line: :key: value — intentionally requires a value after the key
+# (the \s+(.+) part). Flag-style options like :nosandbox: (no value) won't match
+# and will be treated as body content.
+_OPTION_LINE_RE = re.compile(r"^:(\w[\w-]*):\s+(.+)$")
+
 _mistune_md = mistune.create_markdown(renderer="ast", plugins=["table"])
 
 
@@ -71,7 +79,7 @@ def _any_self_closing_before(lines: list[str], close_idx: int) -> bool:
         if not line:
             continue
         m = _DIRECTIVE_OPEN.match(lines[j])
-        if m and m.group(1) in _SELF_CLOSING_DIRECTIVES:
+        if m and m.group(2) in _SELF_CLOSING_DIRECTIVES:
             return True
         return False
     return False
@@ -117,7 +125,40 @@ def _convert_inline(nodes: list[dict]) -> list[InlineSpan]:
     return spans
 
 
-def _convert_ast(nodes: list[dict]) -> list[Block]:
+def _strip_options(body: str) -> tuple[dict[str, str], str]:
+    """Strip MyST option lines from the start of a directive body.
+
+    Option lines have the form `:key: value` and appear at the start of the body.
+    Blank lines between option lines are allowed. Scanning stops at the first
+    non-option, non-blank line.
+
+    Returns (options_dict, remaining_body).
+    """
+    if not body or not body.lstrip("\n").startswith(":"):
+        return {}, body
+    lines = body.split("\n")
+    options: dict[str, str] = {}
+    last_option_idx = -1
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if not stripped:
+            # blank lines are OK between options
+            continue
+        m = _OPTION_LINE_RE.match(stripped)
+        if m:
+            options[m.group(1)] = m.group(2)
+            last_option_idx = i
+        else:
+            break
+    if last_option_idx == -1:
+        return {}, body
+    remaining = "\n".join(lines[last_option_idx + 1:])
+    # Strip leading blank lines from remaining body
+    remaining = remaining.lstrip("\n")
+    return options, remaining
+
+
+def _convert_ast(nodes: list[dict], _depth: int = 0) -> list[Block]:
     """Convert mistune AST nodes into Block tree."""
     blocks: list[Block] = []
     for node in nodes:
@@ -142,7 +183,24 @@ def _convert_ast(nodes: list[dict]) -> list[Block]:
         elif ntype == "block_code":
             raw = node.get("raw", "")
             info = node.get("attrs", {}).get("info", "")
-            if info == "mermaid":
+            # MyST backtick fence directive: ```{name} optional-arg
+            m_directive = _BACKTICK_DIRECTIVE_RE.match(info) if info else None
+            if m_directive:
+                dir_name = m_directive.group(1)
+                arg_text = m_directive.group(2).strip()
+                if dir_name == "mermaid":
+                    options, body = _strip_options(raw)
+                    attrs = dict(options)
+                    if arg_text:
+                        attrs["argument"] = arg_text
+                    attrs["source"] = body
+                    blocks.append(Block(type=BlockType.MERMAID, attrs=attrs))
+                else:
+                    attrs: dict[str, Any] = {}
+                    if arg_text:
+                        attrs["argument"] = arg_text
+                    blocks.append(_directive_to_block(dir_name, attrs, raw, _depth=_depth))
+            elif info == "mermaid":
                 blocks.append(Block(
                     type=BlockType.MERMAID,
                     attrs={"source": raw},
@@ -166,7 +224,7 @@ def _convert_ast(nodes: list[dict]) -> list[Block]:
                         if child["type"] == "block_text":
                             item_spans.extend(_convert_inline(child.get("children", [])))
                         else:
-                            sub_blocks.extend(_convert_ast([child]))
+                            sub_blocks.extend(_convert_ast([child], _depth=_depth))
                     items.append(Block(
                         type=BlockType.LIST_ITEM,
                         text=item_spans,
@@ -209,23 +267,23 @@ def _convert_ast(nodes: list[dict]) -> list[Block]:
             blocks.append(Block(type=BlockType.DIVIDER))
 
         elif ntype == "block_quote":
-            children = _convert_ast(node.get("children", []))
+            children = _convert_ast(node.get("children", []), _depth=_depth)
             blocks.append(Block(type=BlockType.QUOTE, children=children))
 
         else:
             # Unknown block type - try to extract any content
             if "children" in node:
-                blocks.extend(_convert_ast(node["children"]))
+                blocks.extend(_convert_ast(node["children"], _depth=_depth))
 
     return blocks
 
 
-def _parse_markdown(source: str) -> list[Block]:
+def _parse_markdown(source: str, _depth: int = 0) -> list[Block]:
     """Parse a markdown string via mistune and convert to Block list."""
     if not source.strip():
         return []
     ast_nodes = _mistune_md(source)
-    return _convert_ast(ast_nodes)
+    return _convert_ast(ast_nodes, _depth=_depth)
 
 
 def _split_directives(source: str) -> list[dict]:
@@ -247,6 +305,9 @@ def _split_directives(source: str) -> list[dict]:
         # Check for directive opener
         m_open = _DIRECTIVE_OPEN.match(line)
         if m_open:
+            colons = m_open.group(1)
+            name = m_open.group(2)
+            attrs_raw = m_open.group(3)
             if not stack:
                 # Top-level directive opening — flush accumulated markdown
                 if current_md_lines:
@@ -256,13 +317,14 @@ def _split_directives(source: str) -> list[dict]:
                     })
                     current_md_lines = []
                 entry = {
-                    "name": m_open.group(1),
-                    "attrs_raw": m_open.group(2),
+                    "name": name,
+                    "attrs_raw": attrs_raw,
                     "body_lines": [],
                     "depth": 1,
+                    "colon_count": len(colons),
                 }
                 # Self-closing directives (no body content expected)
-                if entry["name"] in ("divider",):
+                if entry["name"] in _SELF_CLOSING_DIRECTIVES:
                     segments.append({
                         "type": "directive",
                         "name": entry["name"],
@@ -272,8 +334,9 @@ def _split_directives(source: str) -> list[dict]:
                 else:
                     stack.append(entry)
             else:
-                # Nested directive — track depth and include line in body
-                stack[-1]["depth"] += 1
+                # Nested directive — track depth only if colon count matches
+                if len(colons) == stack[-1]["colon_count"]:
+                    stack[-1]["depth"] += 1
                 stack[-1]["body_lines"].append(line)
             i += 1
             continue
@@ -282,15 +345,20 @@ def _split_directives(source: str) -> list[dict]:
         m_close = _DIRECTIVE_CLOSE.match(line)
         if m_close and not stack:
             if not _any_self_closing_before(lines, i):
+                close_colons = m_close.group(1)
                 raise DirectiveError(
-                    f"line {i + 1}: stray ':::' closer with no open directive"
+                    f"line {i + 1}: stray '{close_colons}' closer with no open directive"
                 )
             # Stray closer after a self-closing directive like divider — skip
             i += 1
             continue
         if m_close and stack:
-            if stack[-1]["depth"] > 1:
-                # Closing a nested directive
+            close_colon_count = len(m_close.group(1))
+            if close_colon_count != stack[-1]["colon_count"]:
+                # Different colon count — treat as body content
+                stack[-1]["body_lines"].append(line)
+            elif stack[-1]["depth"] > 1:
+                # Closing a nested directive with same colon count
                 stack[-1]["depth"] -= 1
                 stack[-1]["body_lines"].append(line)
             else:
@@ -322,10 +390,10 @@ def _split_directives(source: str) -> list[dict]:
     # If stack is not empty, the source has unclosed directives
     if stack:
         unclosed = stack[-1]
-        # Find the line number where this directive was opened
+        colons = ":" * unclosed["colon_count"]
         name = unclosed["name"]
         raise DirectiveError(
-            f"unclosed directive ':::{name}' — missing closing ':::'"
+            f"unclosed directive '{colons}{name}' — missing closing '{colons}'"
         )
 
     return segments
@@ -336,6 +404,12 @@ _MAX_PARSE_DEPTH = 50
 
 def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int = 0) -> Block:
     """Convert a parsed directive into a Block."""
+    # Strip option lines from body; inline attrs take precedence over options
+    options, body = _strip_options(body)
+    for key, value in options.items():
+        if key not in attrs:
+            attrs[key] = value
+
     block_type = _DIRECTIVE_TO_BLOCK.get(name, BlockType.PANEL)
 
     # Tree and Code directives: store raw body, don't parse as markdown
@@ -368,7 +442,7 @@ def parse(source: str, _depth: int = 0) -> Block:
 
     for seg in segments:
         if seg["type"] == "markdown":
-            children.extend(_parse_markdown(seg["content"]))
+            children.extend(_parse_markdown(seg["content"], _depth=_depth))
         else:
             children.append(_directive_to_block(
                 seg["name"], seg["attrs"], seg["body"], _depth=_depth,

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/renderers/borders.py

@@ -11,6 +11,7 @@ def render_box(
     color: bool,
     title: str | None = None,
     border_color: str | None = None,
+    title_color: str | None = None,
     dim: bool = False,
 ) -> list[str]:
     """Render content lines inside a box-drawing border.
@@ -21,6 +22,7 @@ def render_box(
         color: Whether ANSI styling is enabled.
         title: Optional title to display in the top border.
         border_color: Color name for the border (used by panels).
+        title_color: Color for the title text (defaults to border_color).
         dim: Whether to dim the border (used by code blocks).
     """
     # Calculate border character widths dynamically
@@ -46,11 +48,19 @@ def render_box(
         title_visual = visual_len(title_part)
         remaining = inner_w - title_visual
         fill_count = max(0, remaining // dash_v)
-        top_raw = "┌" + title_part + "─" * fill_count + "┐"
+        if title_color and color:
+            # Style title text separately from border chrome
+            styled_title = style(title, color=title_color, bold=True)
+            border_prefix = style("┌─ ", **style_kw)
+            border_suffix = style(" " + "─" * fill_count + "┐", **style_kw)
+            top = border_prefix + styled_title + border_suffix
+        else:
+            top_raw = "┌" + title_part + "─" * fill_count + "┐"
+            top = style(top_raw, **style_kw)
     else:
         fill_count = max(0, inner_w // dash_v)
         top_raw = "┌" + "─" * fill_count + "┐"
-    top = style(top_raw, **style_kw)
+        top = style(top_raw, **style_kw)
     top = visual_ljust(top, width)
 
     # Bottom border

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/renderers/panel.py

@@ -12,9 +12,21 @@ def render(
     block: Block, color: bool, render_child: Callable[[Block, bool], list[str]]
 ) -> list[str]:
     """Render a panel block with box-drawing borders."""
-    border_color = block.attrs.get("color")
+    explicit_color = block.attrs.get("color")
     title = block.attrs.get("title")
 
+    # Gloam-inspired defaults: dim gray borders, yellow bold title
+    # Explicit color= attr overrides both (border + title match)
+    if explicit_color:
+        border_color = explicit_color
+        title_color = None  # title inherits border color
+    elif color:
+        border_color = None  # dim only (gray)
+        title_color = "yellow"
+    else:
+        border_color = None
+        title_color = None
+
     # Render children content
     content_lines: list[str] = []
     for child in block.children:
@@ -26,6 +38,8 @@ def render(
         color=color,
         title=title,
         border_color=border_color,
+        title_color=title_color,
+        dim=color and not explicit_color,
     )
 
 

termrender-0.4.0/src/termrender/renderers/table.py

@@ -0,0 +1,158 @@
+"""Table renderer for termrender."""
+
+from __future__ import annotations
+
+from termrender.blocks import Block, InlineSpan
+from termrender.style import style, visual_len, visual_ljust, visual_center, render_spans, wrap_text
+
+
+def _align_cell(text: str, width: int, align: str | None) -> str:
+    if align == "center":
+        return visual_center(text, width)
+    elif align == "right":
+        vl = visual_len(text)
+        if vl < width:
+            return " " * (width - vl) + text
+        return text
+    else:
+        return visual_ljust(text, width)
+
+
+def _render_span_slice(
+    spans: list[InlineSpan], start: int, end: int, color: bool
+) -> str:
+    """Render the portion of spans covering character range [start, end)."""
+    parts: list[str] = []
+    offset = 0
+    for span in spans:
+        span_start = offset
+        span_end = offset + len(span.text)
+        overlap_start = max(span_start, start)
+        overlap_end = min(span_end, end)
+        if overlap_start < overlap_end:
+            slice_text = span.text[overlap_start - span_start : overlap_end - span_start]
+            if span.code:
+                slice_text = style(slice_text, color="cyan", enabled=color)
+            elif span.bold or span.italic:
+                slice_text = style(slice_text, bold=span.bold, italic=span.italic, enabled=color)
+            parts.append(slice_text)
+        offset = span_end
+        if offset >= end:
+            break
+    return "".join(parts)
+
+
+def _wrap_cell_colored(
+    spans: list[InlineSpan], width: int, color: bool
+) -> list[str]:
+    """Wrap cell content to width, preserving inline styling."""
+    plain = render_spans(spans, False)
+    wrapped = wrap_text(plain, max(width, 1))
+    if not color:
+        return wrapped
+
+    lines: list[str] = []
+    offset = 0
+    for raw_line in wrapped:
+        line_len = len(raw_line)
+        styled = _render_span_slice(spans, offset, offset + line_len, color)
+        lines.append(styled)
+        offset += line_len
+        if offset < len(plain) and plain[offset] == " ":
+            offset += 1
+    return lines
+
+
+def render(block: Block, color: bool) -> list[str]:
+    headers: list[list] = block.attrs.get("headers", [])
+    rows: list[list[list]] = block.attrs.get("rows", [])
+    aligns: list[str | None] = block.attrs.get("aligns", [])
+    w = block.width or 80
+
+    # Default theme: blue borders, yellow headers on dim_blue bg (gloam-inspired)
+    border_color = block.attrs.get("border_color", "blue")
+    header_fg = block.attrs.get("header_color", "yellow")
+    header_bg = block.attrs.get("header_bg", "dim_blue")
+
+    def border(text: str) -> str:
+        """Style border characters."""
+        return style(text, color=border_color, dim=True, enabled=color)
+
+    n_cols = max(len(headers), max((len(r) for r in rows), default=0))
+    if n_cols == 0:
+        return []
+
+    # Render all cells to plain text for width calculation
+    rendered_headers = [render_spans(headers[i], False) if i < len(headers) else "" for i in range(n_cols)]
+    rendered_rows = [
+        [render_spans(row[i], False) if i < len(row) else "" for i in range(n_cols)]
+        for row in rows
+    ]
+
+    # Calculate natural column widths (minimum 3)
+    col_widths = [
+        max(3, visual_len(rendered_headers[i]), *(visual_len(r[i]) for r in rendered_rows))
+        for i in range(n_cols)
+    ]
+
+    # Total width: borders + padding (each cell has 1 space padding on each side)
+    # Layout: │ cell │ cell │  => n_cols + 1 borders + n_cols * 2 padding
+    total = sum(col_widths) + n_cols * 2 + (n_cols + 1)
+
+    # Distribute proportionally if overflow
+    if total > w:
+        available = w - n_cols * 2 - (n_cols + 1)
+        available = max(available, n_cols * 3)
+        total_natural = sum(col_widths)
+        if total_natural > 0:
+            col_widths = [
+                max(3, round(cw / total_natural * available))
+                for cw in col_widths
+            ]
+
+    # Wrap cell content to column widths with inline styling
+    header_spans = [headers[i] if i < len(headers) else [] for i in range(n_cols)]
+    wrapped_headers = [_wrap_cell_colored(header_spans[i], col_widths[i], color) for i in range(n_cols)]
+
+    row_spans = [
+        [row[i] if i < len(row) else [] for i in range(n_cols)]
+        for row in rows
+    ]
+    wrapped_rows = [
+        [_wrap_cell_colored(rs[i], col_widths[i], color) for i in range(n_cols)]
+        for rs in row_spans
+    ]
+
+    def render_multiline_row(wrapped_cells: list[list[str]], is_header: bool) -> list[str]:
+        row_height = max((len(c) for c in wrapped_cells), default=1)
+        out: list[str] = []
+        for line_idx in range(row_height):
+            parts: list[str] = []
+            for i, cell_lines in enumerate(wrapped_cells):
+                text = cell_lines[line_idx] if line_idx < len(cell_lines) else ""
+                align = aligns[i] if i < len(aligns) else None
+                padded = _align_cell(text, col_widths[i], align)
+                if is_header and color:
+                    padded = style(" " + padded + " ", bold=True, color=header_fg, bg=header_bg)
+                else:
+                    padded = " " + padded + " "
+                parts.append(padded)
+            line = border("│") + border("│").join(parts) + border("│")
+            out.append(visual_ljust(line, w))
+        return out
+
+    def separator(left: str, mid: str, right: str) -> str:
+        segs = ["─" * (col_widths[i] + 2) for i in range(n_cols)]
+        raw = left + mid.join(segs) + right
+        line = style(raw, color=border_color, dim=True, enabled=color)
+        return visual_ljust(line, w)
+
+    lines: list[str] = []
+    lines.append(separator("┌", "┬", "┐"))
+    lines.extend(render_multiline_row(wrapped_headers, is_header=True))
+    lines.append(separator("├", "┼", "┤"))
+    for wr in wrapped_rows:
+        lines.extend(render_multiline_row(wr, is_header=False))
+    lines.append(separator("└", "┴", "┘"))
+
+    return lines

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/renderers/text.py

@@ -57,7 +57,7 @@ def _render_span_slice(
         if overlap_start < overlap_end:
             slice_text = span.text[overlap_start - span_start : overlap_end - span_start]
             if span.code:
-                slice_text = style(slice_text, dim=True, enabled=color)
+                slice_text = style(slice_text, color="cyan", enabled=color)
             elif span.bold or span.italic:
                 slice_text = style(slice_text, bold=span.bold, italic=span.italic, enabled=color)
             parts.append(slice_text)
@@ -67,16 +67,27 @@ def _render_span_slice(
     return "".join(parts)
 
 
+# Gloam-inspired heading colors: colored fg + dim tinted bg, by depth
+_HEADING_STYLES: dict[int, dict[str, str]] = {
+    1: {"color": "yellow", "bg": "dim_yellow"},
+    2: {"color": "green", "bg": "dim_green"},
+    3: {"color": "cyan", "bg": "dim_cyan"},
+    4: {"color": "blue", "bg": "dim_blue"},
+    5: {"color": "magenta", "bg": "dim_magenta"},
+}
+
+
 def _render_heading(block: Block, color: bool) -> list[str]:
     level = block.attrs.get("level", 1)
     text = render_spans(block.text, color=False)  # plain text first
 
-    if level == 1:
-        styled = style(text, color="blue", bold=True, enabled=color)
-    elif level == 2:
+    heading_style = _HEADING_STYLES.get(level)
+    if heading_style and color:
+        # Pad text to full width BEFORE styling so bg extends across the line
+        padded = visual_ljust(text, block.width)
+        styled = style(padded, bold=True, enabled=True, **heading_style)
+    elif level <= 2:
         styled = style(text, bold=True, enabled=color)
-    elif level == 3:
-        styled = style(text, italic=True, enabled=color)
     else:
         styled = style(text, dim=True, enabled=color)
 

{termrender-0.3.0 → termrender-0.4.0}/src/termrender/style.py

@@ -97,6 +97,24 @@ COLOR_MAP: dict[str, str] = {
     'gray': '\x1b[90m',
 }
 
+BG_COLOR_MAP: dict[str, str] = {
+    'red': '\x1b[41m',
+    'green': '\x1b[42m',
+    'yellow': '\x1b[43m',
+    'blue': '\x1b[44m',
+    'magenta': '\x1b[45m',
+    'cyan': '\x1b[46m',
+    'white': '\x1b[47m',
+    'gray': '\x1b[100m',
+    # Dim background variants — use bright-black (dark gray) range
+    'dim_red': '\x1b[48;5;52m',
+    'dim_green': '\x1b[48;5;22m',
+    'dim_yellow': '\x1b[48;5;58m',
+    'dim_blue': '\x1b[48;5;17m',
+    'dim_magenta': '\x1b[48;5;53m',
+    'dim_cyan': '\x1b[48;5;23m',
+}
+
 
 def resolve_color(name: str | None) -> str:
     if name is None:
@@ -104,9 +122,16 @@ def resolve_color(name: str | None) -> str:
     return COLOR_MAP.get(name, '')
 
 
+def resolve_bg_color(name: str | None) -> str:
+    if name is None:
+        return ''
+    return BG_COLOR_MAP.get(name, '')
+
+
 def style(
     text: str,
     color: str | None = None,
+    bg: str | None = None,
     bold: bool = False,
     italic: bool = False,
     dim: bool = False,
@@ -115,6 +140,7 @@ def style(
     if not enabled:
         return text
     prefix = resolve_color(color)
+    prefix += resolve_bg_color(bg)
     if bold:
         prefix += BOLD
     if italic:
@@ -246,7 +272,7 @@ def render_spans(spans: list[InlineSpan], color: bool) -> str:
     for span in spans:
         text = span.text
         if span.code:
-            text = style(text, dim=True, enabled=color)
+            text = style(text, color="cyan", enabled=color)
         elif span.bold or span.italic:
             text = style(text, bold=span.bold, italic=span.italic, enabled=color)
         parts.append(text)

termrender-0.4.0/tests/test_myst_gaps.py

@@ -0,0 +1,114 @@
+"""Tests for MyST Markdown syntax support in the parser."""
+
+import unittest
+
+from termrender.blocks import BlockType
+from termrender.parser import parse, _strip_options
+
+
+class TestBacktickFenceDirective(unittest.TestCase):
+    """Feature 1: Backtick fence directive syntax."""
+
+    def test_basic_backtick_fence_directive(self):
+        """```{panel}\ncontent\n``` → BlockType.PANEL"""
+        doc = parse("```{panel}\ncontent\n```")
+        self.assertEqual(len(doc.children), 1)
+        self.assertEqual(doc.children[0].type, BlockType.PANEL)
+
+    def test_backtick_fence_with_option_lines(self):
+        """```{panel}\n:title: Hello\ncontent\n``` → panel with title attr"""
+        doc = parse("```{panel}\n:title: Hello\ncontent\n```")
+        panel = doc.children[0]
+        self.assertEqual(panel.type, BlockType.PANEL)
+        self.assertEqual(panel.attrs["title"], "Hello")
+
+    def test_backtick_mermaid_directive(self):
+        """```{mermaid}\ngraph LR\nA-->B\n``` → BlockType.MERMAID"""
+        doc = parse("```{mermaid}\ngraph LR\nA-->B\n```")
+        self.assertEqual(len(doc.children), 1)
+        block = doc.children[0]
+        self.assertEqual(block.type, BlockType.MERMAID)
+        self.assertIn("graph LR", block.attrs["source"])
+
+    def test_bare_mermaid_still_works(self):
+        """```mermaid\ngraph LR\n``` → BlockType.MERMAID (backward compat)"""
+        doc = parse("```mermaid\ngraph LR\nA-->B\n```")
+        self.assertEqual(doc.children[0].type, BlockType.MERMAID)
+
+    def test_empty_body_backtick_directive(self):
+        """```{panel}\n``` → panel with no children"""
+        doc = parse("```{panel}\n```")
+        panel = doc.children[0]
+        self.assertEqual(panel.type, BlockType.PANEL)
+
+    def test_backtick_fence_with_argument(self):
+        """```{code-block} python\nprint("hi")\n``` → attrs["argument"] = "python" """
+        doc = parse('```{code-block} python\nprint("hi")\n```')
+        block = doc.children[0]
+        self.assertEqual(block.attrs.get("argument"), "python")
+
+    def test_four_backtick_fence(self):
+        """````{panel}\ncontent\n```` → works via mistune"""
+        doc = parse("````{panel}\ncontent\n````")
+        self.assertEqual(len(doc.children), 1)
+        self.assertEqual(doc.children[0].type, BlockType.PANEL)
+
+
+class TestDirectiveOptionLines(unittest.TestCase):
+    """Feature 2: Directive option lines."""
+
+    def test_colon_directive_with_options(self):
+        """:::panel\n:title: Hi\n:color: blue\ncontent\n::: → attrs have title and color"""
+        doc = parse(":::panel\n:title: Hi\n:color: blue\ncontent\n:::")
+        panel = doc.children[0]
+        self.assertEqual(panel.attrs["title"], "Hi")
+        self.assertEqual(panel.attrs["color"], "blue")
+
+    def test_options_dont_override_inline_attrs(self):
+        """:::panel{title="Inline"}\n:title: Option\n::: → title is "Inline" """
+        doc = parse(':::panel{title="Inline"}\n:title: Option\n:::')
+        panel = doc.children[0]
+        self.assertEqual(panel.attrs["title"], "Inline")
+
+    def test_body_after_options_preserved(self):
+        """Body content after option lines is preserved correctly."""
+        doc = parse(":::panel\n:title: Hi\nHello world\n:::")
+        panel = doc.children[0]
+        self.assertEqual(panel.attrs["title"], "Hi")
+        # Body should have been parsed and contain a paragraph with "Hello world"
+        self.assertTrue(len(panel.children) > 0)
+
+    def test_non_option_lines_not_eaten(self):
+        """:not-an-option without trailing colon-space should not be eaten."""
+        doc = parse(":::panel\n:not-an-option\ncontent\n:::")
+        panel = doc.children[0]
+        # ":not-an-option" doesn't match `:key: value` pattern, so no options
+        self.assertNotIn("not-an-option", panel.attrs)
+
+
+class TestStripOptions(unittest.TestCase):
+    """Unit tests for _strip_options."""
+
+    def test_empty_body(self):
+        opts, body = _strip_options("")
+        self.assertEqual(opts, {})
+        self.assertEqual(body, "")
+
+    def test_no_options(self):
+        opts, body = _strip_options("just content\nmore content")
+        self.assertEqual(opts, {})
+        self.assertEqual(body, "just content\nmore content")
+
+    def test_options_with_blank_lines(self):
+        opts, body = _strip_options(":title: Hi\n\n:color: blue\ncontent")
+        self.assertEqual(opts, {"title": "Hi", "color": "blue"})
+        self.assertEqual(body, "content")
+
+    def test_option_key_with_hyphens(self):
+        opts, body = _strip_options(":my-key: value\ncontent")
+        self.assertEqual(opts, {"my-key": "value"})
+        self.assertEqual(body, "content")
+
+
+if __name__ == "__main__":
+    unittest.main()

termrender-0.4.0/tests/test_variable_colons.py

@@ -0,0 +1,162 @@
+import unittest
+
+from termrender.parser import parse, DirectiveError
+from termrender.blocks import BlockType
+from termrender import render
+
+
+class TestVariableColons(unittest.TestCase):
+    """Tests for variable colon counts (3+) in directive markers."""
+
+    def test_basic_four_colon_directive(self):
+        """::::panel parses correctly with 4 colons."""
+        doc = parse("::::panel\ncontent\n::::")
+        self.assertEqual(len(doc.children), 1)
+        self.assertEqual(doc.children[0].type, BlockType.PANEL)
+
+    def test_five_colon_directive(self):
+        """:::::panel parses correctly with 5 colons."""
+        doc = parse(":::::panel\ncontent\n:::::")
+        self.assertEqual(len(doc.children), 1)
+        self.assertEqual(doc.children[0].type, BlockType.PANEL)
+
+    def test_mixed_nesting(self):
+        """Outer ::::panel containing inner :::col — both parse correctly."""
+        source = (
+            "::::panel\n"
+            ":::col\n"
+            "hello\n"
+            ":::\n"
+            "::::"
+        )
+        doc = parse(source)
+        self.assertEqual(len(doc.children), 1)
+        panel = doc.children[0]
+        self.assertEqual(panel.type, BlockType.PANEL)
+        # The inner :::col should be parsed recursively
+        col_children = [c for c in panel.children if c.type == BlockType.COL]
+        self.assertEqual(len(col_children), 1)
+
+    def test_same_colon_nesting_backward_compat(self):
+        """Existing :::panel > :::col nesting still works via depth counter."""
+        source = (
+            ":::panel\n"
+            ":::col\n"
+            "inner\n"
+            ":::\n"
+            ":::"
+        )
+        doc = parse(source)
+        self.assertEqual(len(doc.children), 1)
+        panel = doc.children[0]
+        self.assertEqual(panel.type, BlockType.PANEL)
+        col_children = [c for c in panel.children if c.type == BlockType.COL]
+        self.assertEqual(len(col_children), 1)
+
+    def test_closer_mismatch_raises_error(self):
+        """::::panel closed by ::: raises DirectiveError."""
+        source = "::::panel\ncontent\n:::"
+        with self.assertRaises(DirectiveError) as ctx:
+            parse(source)
+        self.assertIn("::::panel", str(ctx.exception))
+        self.assertIn("::::", str(ctx.exception))
+
+    def test_self_closing_with_variable_colons(self):
+        """::::divider{label="x"} works as self-closing."""
+        doc = parse('::::divider{label="x"}')
+        self.assertEqual(len(doc.children), 1)
+        self.assertEqual(doc.children[0].type, BlockType.DIVIDER)
+        self.assertEqual(doc.children[0].attrs.get("label"), "x")
+
+    def test_self_closing_with_explicit_closer(self):
+        """::::divider{label="x"} followed by :::: is fine."""
+        doc = parse('::::divider{label="x"}\n::::')
+        dividers = [c for c in doc.children if c.type == BlockType.DIVIDER]
+        self.assertEqual(len(dividers), 1)
+
+    def test_deep_nesting_different_colon_counts(self):
+        """4+ levels each with different colon counts."""
+        source = (
+            "::::::panel{title=\"outer\"}\n"
+            ":::::panel{title=\"mid\"}\n"
+            "::::panel{title=\"inner\"}\n"
+            ":::callout{type=\"info\"}\n"
+            "deep content\n"
+            ":::\n"
+            "::::\n"
+            ":::::\n"
+            "::::::"
+        )
+        doc = parse(source)
+        self.assertEqual(len(doc.children), 1)
+        outer = doc.children[0]
+        self.assertEqual(outer.type, BlockType.PANEL)
+        self.assertEqual(outer.attrs.get("title"), "outer")
+
+        # Drill down
+        mid = [c for c in outer.children if c.type == BlockType.PANEL]
+        self.assertEqual(len(mid), 1)
+        self.assertEqual(mid[0].attrs.get("title"), "mid")
+
+        inner = [c for c in mid[0].children if c.type == BlockType.PANEL]
+        self.assertEqual(len(inner), 1)
+        self.assertEqual(inner[0].attrs.get("title"), "inner")
+
+        callout = [c for c in inner[0].children if c.type == BlockType.CALLOUT]
+        self.assertEqual(len(callout), 1)
+
+    def test_render_integration_four_colons(self):
+        """::::panel renders identically to :::panel."""
+        source_3 = ":::panel{title=\"Test\"}\ncontent\n:::"
+        source_4 = "::::panel{title=\"Test\"}\ncontent\n::::"
+        output_3 = render(source_3, width=60, color=False)
+        output_4 = render(source_4, width=60, color=False)
+        self.assertEqual(output_3, output_4)
+
+    def test_three_colon_backward_compat(self):
+        """Existing ::: syntax is fully backward compatible."""
+        source = (
+            ":::panel{title=\"Hello\"}\n"
+            "Some **bold** text\n"
+            ":::"
+        )
+        doc = parse(source)
+        self.assertEqual(len(doc.children), 1)
+        self.assertEqual(doc.children[0].type, BlockType.PANEL)
+        self.assertEqual(doc.children[0].attrs.get("title"), "Hello")
+
+    def test_four_colon_with_attrs(self):
+        """::::panel{title="X" color="red"} parses attrs correctly."""
+        doc = parse('::::panel{title="X" color="red"}\nbody\n::::')
+        panel = doc.children[0]
+        self.assertEqual(panel.attrs["title"], "X")
+        self.assertEqual(panel.attrs["color"], "red")
+
+    def test_stray_closer_different_colons(self):
+        """Stray :::: closer with no open directive raises DirectiveError."""
+        with self.assertRaises(DirectiveError) as ctx:
+            parse("::::")
+        self.assertIn("::::", str(ctx.exception))
+
+    def test_mixed_nesting_columns(self):
+        """Real-world pattern: ::::columns with :::col children."""
+        source = (
+            "::::columns\n"
+            ":::col{width=\"50%\"}\n"
+            "left side\n"
+            ":::\n"
+            ":::col{width=\"50%\"}\n"
+            "right side\n"
+            ":::\n"
+            "::::"
+        )
+        doc = parse(source)
+        self.assertEqual(len(doc.children), 1)
+        columns = doc.children[0]
+        self.assertEqual(columns.type, BlockType.COLUMNS)
+        cols = [c for c in columns.children if c.type == BlockType.COL]
+        self.assertEqual(len(cols), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

termrender-0.3.0/src/termrender/renderers/table.py

@@ -1,95 +0,0 @@
-"""Table renderer for termrender."""
-
-from __future__ import annotations
-
-from termrender.blocks import Block
-from termrender.style import style, visual_len, visual_ljust, visual_center, render_spans, wrap_text
-
-
-def _align_cell(text: str, width: int, align: str | None) -> str:
-    if align == "center":
-        return visual_center(text, width)
-    elif align == "right":
-        vl = visual_len(text)
-        if vl < width:
-            return " " * (width - vl) + text
-        return text
-    else:
-        return visual_ljust(text, width)
-
-
-def render(block: Block, color: bool) -> list[str]:
-    headers: list[list] = block.attrs.get("headers", [])
-    rows: list[list[list]] = block.attrs.get("rows", [])
-    aligns: list[str | None] = block.attrs.get("aligns", [])
-    w = block.width or 80
-
-    n_cols = max(len(headers), max((len(r) for r in rows), default=0))
-    if n_cols == 0:
-        return []
-
-    # Render all cells to plain text for width calculation
-    rendered_headers = [render_spans(headers[i], False) if i < len(headers) else "" for i in range(n_cols)]
-    rendered_rows = [
-        [render_spans(row[i], False) if i < len(row) else "" for i in range(n_cols)]
-        for row in rows
-    ]
-
-    # Calculate natural column widths (minimum 3)
-    col_widths = [
-        max(3, visual_len(rendered_headers[i]), *(visual_len(r[i]) for r in rendered_rows))
-        for i in range(n_cols)
-    ]
-
-    # Total width: borders + padding (each cell has 1 space padding on each side)
-    # Layout: │ cell │ cell │  => n_cols + 1 borders + n_cols * 2 padding
-    total = sum(col_widths) + n_cols * 2 + (n_cols + 1)
-
-    # Distribute proportionally if overflow
-    if total > w:
-        available = w - n_cols * 2 - (n_cols + 1)
-        available = max(available, n_cols * 3)
-        total_natural = sum(col_widths)
-        if total_natural > 0:
-            col_widths = [
-                max(3, round(cw / total_natural * available))
-                for cw in col_widths
-            ]
-
-    # Wrap cell content to column widths
-    wrapped_headers = [wrap_text(rendered_headers[i], col_widths[i]) for i in range(n_cols)]
-    wrapped_rows = [
-        [wrap_text(row[i], col_widths[i]) for i in range(n_cols)]
-        for row in rendered_rows
-    ]
-
-    def render_multiline_row(wrapped_cells: list[list[str]], bold: bool) -> list[str]:
-        row_height = max((len(c) for c in wrapped_cells), default=1)
-        out: list[str] = []
-        for line_idx in range(row_height):
-            parts: list[str] = []
-            for i, cell_lines in enumerate(wrapped_cells):
-                text = cell_lines[line_idx] if line_idx < len(cell_lines) else ""
-                align = aligns[i] if i < len(aligns) else None
-                padded = _align_cell(text, col_widths[i], align)
-                if bold and color:
-                    padded = style(padded, bold=True)
-                parts.append(" " + padded + " ")
-            line = "│" + "│".join(parts) + "│"
-            out.append(visual_ljust(line, w))
-        return out
-
-    def separator(left: str, mid: str, right: str) -> str:
-        segs = ["─" * (col_widths[i] + 2) for i in range(n_cols)]
-        line = left + mid.join(segs) + right
-        return visual_ljust(line, w)
-
-    lines: list[str] = []
-    lines.append(separator("┌", "┬", "┐"))
-    lines.extend(render_multiline_row(wrapped_headers, bold=True))
-    lines.append(separator("├", "┼", "┤"))
-    for wr in wrapped_rows:
-        lines.extend(render_multiline_row(wr, bold=False))
-    lines.append(separator("└", "┴", "┘"))
-
-    return lines