tui-td 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5a923ea75814849ee5cf0633c81c09e2db156e47df52f6f92f2b314f743f3b7
-  data.tar.gz: c5cb55618e38bcc06a477bedce42d61d8f0c497ff38f887462943e8d094863b0
+  metadata.gz: 2716bc85090a6430068ad8820f9736657a3f122571999e34c39529060f59d487
+  data.tar.gz: b73ff229c0396a87a5121b43ff81edf65be1f13de1aed58a7404cd263a0ba84e
 SHA512:
-  metadata.gz: 1d36aac819998194c942dc9fc16c96ef0b4ef9fa7d549649f4bdd78cd59687858939ef7e1303d215a13e1dcd0957350d3839e43af94d4b837eb509ea5541cb58
-  data.tar.gz: 3d9f2fe282a9e32a274cea860ef5592e7666ce48121d590395c926bd0119d0f970ad2d2f232b88b0323742df8ef42b18686cd60ca75007d9f739cc2e8f4bae5b
+  metadata.gz: be25c3cfca1b280dacc7a2b968c887de55fce953e1c9903dd725d1291b34918375771eec7324522407ef783c2fc9010f0ef69b2e7c5fccc142bf6b2bd1396f40
+  data.tar.gz: 0ee80ad5882c21763241f39c781a03a30180baf04707f7af5652bd913254b69c647efa59b06c57ff534b8b797a188adfaf40068f37956cad08b33a4cbc28cae0

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 0.2.6
+
+- ISO-2022 charset switching support (G0/G1 designators, Shift Out/In) with DEC Special Character & Line Drawing mapping
+- SGR mouse reporting mode parsing (1000, 1002, 1003, 1006)
+- Mouse reporting and cursor visibility/style reconstruction in build_frame
+- Fixed `state_data` in `driver.rb` to unconditionally refresh terminal state instead of returning stale cache
+- New `cursor_visible`, `cursor_style`, `mouse_mode`, `mouse_format` attributes on `State`
+- HTML and screenshot styling for new cursor/mouse attributes
+
 ## 0.2.5
 
 - MCP smoke test expanded: 20 → 54 assertions, covers all 10 tools plus error paths (88% server coverage)

data/lib/tui_td/ansi_parser.rb

@@ -80,6 +80,40 @@ module TUITD
       15 => "bright_white",
     }.freeze
 
+    DEC_MAP = {
+      '`' => '◆',
+      'a' => '▒',
+      'b' => "\u2409",
+      'c' => "\u240C",
+      'd' => "\u240D",
+      'e' => "\u240A",
+      'f' => '°',
+      'g' => '±',
+      'h' => "\u2424",
+      'i' => "\u240B",
+      'j' => '┘',
+      'k' => '┐',
+      'l' => '┌',
+      'm' => '└',
+      'n' => '┼',
+      'o' => '⎺',
+      'p' => '⎻',
+      'q' => '─',
+      'r' => '⎼',
+      's' => '⎽',
+      't' => '├',
+      'u' => '┤',
+      'v' => '┴',
+      'w' => '┬',
+      'x' => '│',
+      'y' => '≤',
+      'z' => '≥',
+      '{' => 'π',
+      '|' => '≠',
+      '}' => '£',
+      '~' => '·'
+    }.freeze
+
     # Parse raw terminal output into a structured state Hash
     def self.parse(raw, rows = 40, cols = 120)
       grid = Array.new(rows) do
@@ -87,11 +121,32 @@ module TUITD
       end
 
       cursor = { row: 0, col: 0 }
-      attrs = { fg: "default", bg: "default", bold: false, italic: false, underline: false }
+      attrs = { fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false }
       saved_cursor = nil
       scroll_region = { top: 0, bottom: rows - 1 }
       pending_dsr = false
 
+      normal_grid = grid
+      alt_grid = nil
+
+      normal_cursor = cursor
+      alt_cursor = { row: 0, col: 0 }
+
+      normal_saved_cursor = nil
+      alt_saved_cursor = nil
+
+      use_alt_screen = false
+
+      cursor_visible = true
+      cursor_style = 1 # 1 = blinking block (default)
+
+      g0_charset = :ascii
+      g1_charset = :dec
+      active_charset = :g0
+
+      mouse_mode = :none
+      mouse_format = :normal
+
       # Strip everything before the last full clear (if any)
       # to avoid accumulated garbage
       processed = raw
@@ -101,12 +156,76 @@ module TUITD
         if processed[i] == "\e" && processed[i + 1] == "["
           # Find end of CSI sequence
           j = i + 2
-          j += 1 while j < processed.length && !processed[j].match?(/[A-HJ-KP-SX@`fhlmnRrsu]/)
+          j += 1 while j < processed.length && !processed[j].match?(/[A-HJ-KP-SX@\`fhlmnRrsuq]/)
           seq = processed[i..j]
 
-          dsr, new_saved = _apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
+          dsr, new_saved, action = _apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
           pending_dsr ||= dsr
-          saved_cursor = new_saved if new_saved
+
+          if new_saved
+            if use_alt_screen
+              alt_saved_cursor = new_saved
+              saved_cursor = alt_saved_cursor
+            else
+              normal_saved_cursor = new_saved
+              saved_cursor = normal_saved_cursor
+            end
+          end
+
+          if action.key?(:alt_screen)
+            new_alt = action[:alt_screen]
+            code = action[:alt_screen_code]
+            if new_alt != use_alt_screen
+              if new_alt
+                # Switch to Alternate Screen
+                # Save normal cursor
+                normal_cursor = { row: cursor[:row], col: cursor[:col] }
+
+                # Lazy initialize alt grid
+                alt_grid ||= Array.new(rows) do
+                  Array.new(cols) { default_cell.dup }
+                end
+
+                # For \e[?1049h, clear alternate screen and reset cursor to 0,0
+                if code == 1049
+                  alt_grid = Array.new(rows) do
+                    Array.new(cols) { default_cell.dup }
+                  end
+                  alt_cursor = { row: 0, col: 0 }
+                end
+
+                grid = alt_grid
+                cursor = alt_cursor
+                saved_cursor = alt_saved_cursor
+                use_alt_screen = true
+              else
+                # Switch to Normal Screen
+                # Save alt cursor
+                alt_cursor = { row: cursor[:row], col: cursor[:col] }
+
+                grid = normal_grid
+                cursor = normal_cursor
+                saved_cursor = normal_saved_cursor
+                use_alt_screen = false
+              end
+            end
+          end
+
+          if action.key?(:cursor_visible)
+            cursor_visible = action[:cursor_visible]
+          end
+
+          if action.key?(:cursor_style)
+            cursor_style = action[:cursor_style]
+          end
+
+          if action.key?(:mouse_mode)
+            mouse_mode = action[:mouse_mode]
+          end
+
+          if action.key?(:mouse_format)
+            mouse_format = action[:mouse_format]
+          end
 
           i = j + 1
         elsif processed[i] == "\n" || processed[i] == "\r\n"
@@ -126,11 +245,23 @@ module TUITD
         elsif processed[i] == "\a"
           # Bell — ignore
           i += 1
+        elsif processed[i] == "\x0e"
+          active_charset = :g1
+          i += 1
+        elsif processed[i] == "\x0f"
+          active_charset = :g0
+          i += 1
         elsif processed[i] == "\e"
           # Handle non-CSI escape sequences
           if processed[i + 1] == "7"
             # DECSC — Save Cursor
-            saved_cursor = { row: cursor[:row], col: cursor[:col] }
+            if use_alt_screen
+              alt_saved_cursor = { row: cursor[:row], col: cursor[:col] }
+              saved_cursor = alt_saved_cursor
+            else
+              normal_saved_cursor = { row: cursor[:row], col: cursor[:col] }
+              saved_cursor = normal_saved_cursor
+            end
             i += 2
           elsif processed[i + 1] == "8"
             # DECRC — Restore Cursor
@@ -139,8 +270,14 @@ module TUITD
               cursor[:col] = saved_cursor[:col]
             end
             i += 2
+          elsif processed[i + 1] == "(" && (processed[i + 2] == "0" || processed[i + 2] == "B")
+            g0_charset = (processed[i + 2] == "0" ? :dec : :ascii)
+            i += 3
+          elsif processed[i + 1] == ")" && (processed[i + 2] == "0" || processed[i + 2] == "B")
+            g1_charset = (processed[i + 2] == "0" ? :dec : :ascii)
+            i += 3
           elsif processed[i + 1] && processed[i + 1].match?(/[()*+\-.\/]/)
-            # ISO 2022 charset: \e( B  \e) 0  etc. (3 chars total)
+            # Other ISO 2022 charset sequences (e.g. G2/G3 or other charsets)
             i += 3
           else
             i += 1
@@ -149,7 +286,12 @@ module TUITD
           # Printable character (including multi-byte UTF-8)
           if cursor[:row] < rows && cursor[:col] < cols
             cell = grid[cursor[:row]][cursor[:col]]
-            cell[:char] = char
+            current_charset = (active_charset == :g1 ? g1_charset : g0_charset)
+            mapped_char = char
+            if current_charset == :dec && DEC_MAP.key?(char)
+              mapped_char = DEC_MAP[char]
+            end
+            cell[:char] = mapped_char
             cell.merge!(attrs)
             cursor[:col] += 1
             cursor[:col] = cols - 1 if cursor[:col] >= cols
@@ -180,9 +322,18 @@ module TUITD
 
       {
         size: { rows: rows, cols: cols },
-        cursor: cursor,
+        cursor: {
+          row: cursor[:row],
+          col: cursor[:col],
+          visible: cursor_visible,
+          style: cursor_style
+        },
         rows: grid,
         pending_dsr: pending_dsr,
+        cursor_visible: cursor_visible,
+        cursor_style: cursor_style,
+        mouse_mode: mouse_mode,
+        mouse_format: mouse_format
       }
     end
 
@@ -192,6 +343,8 @@ module TUITD
       cols = state.dig(:size, :cols) || state["size"]["cols"]
       grid = state[:rows] || state["rows"]
       cursor = state[:cursor] || state["cursor"]
+      mouse_mode = state[:mouse_mode] || state["mouse_mode"] || :none
+      mouse_format = state[:mouse_format] || state["mouse_format"] || :normal
 
       out = +""
       out << "\e[0m"
@@ -205,11 +358,13 @@ module TUITD
           bold = cell[:bold] || cell["bold"] || false
           italic = cell[:italic] || cell["italic"] || false
           underline = cell[:underline] || cell["underline"] || false
+          blink = cell[:blink] || cell["blink"] || false
 
           codes = []
           codes << "1" if bold
           codes << "3" if italic
           codes << "4" if underline
+          codes << "5" if blink
 
           fg_code = _color_code(fg, "38")
           bg_code = _color_code(bg, "48")
@@ -223,6 +378,36 @@ module TUITD
         out << "\n" if ri < rows - 1
       end
 
+      # Reconstruct cursor visibility
+      cursor_vis = true
+      if cursor.is_a?(Hash)
+        cursor_vis = cursor[:visible] != false && cursor["visible"] != false
+      end
+      out << (cursor_vis ? "\e[?25h" : "\e[?25l")
+
+      # Reconstruct cursor style
+      if cursor.is_a?(Hash)
+        style = cursor[:style] || cursor["style"]
+        out << "\e[#{style} q" if style
+      end
+
+      # Reconstruct mouse mode and format
+      if mouse_mode == :normal
+        out << "\e[?1000h"
+      elsif mouse_mode == :drag
+        out << "\e[?1002h"
+      elsif mouse_mode == :all
+        out << "\e[?1003h"
+      else
+        out << "\e[?1000l\e[?1002l\e[?1003l"
+      end
+
+      if mouse_format == :sgr
+        out << "\e[?1006h"
+      else
+        out << "\e[?1006l"
+      end
+
       out << "\e[0m"
       out
     end
@@ -230,13 +415,16 @@ module TUITD
     def self._apply_csi(seq, cursor, attrs, grid, rows, cols, saved_cursor, scroll_region)
       # Strip leading escape char if present
       cleaned = seq.sub(/^\e/, "")
-      match = cleaned.match(/^\[([\d;]*)([A-HJ-KP-SX@`fhlmnRrsu])$/)
-      return [false, nil] unless match
+      match = cleaned.match(/^\[(\??)([\d;]*)( ?)([A-HJ-KP-SX@\`fhlmnRrsuq])$/)
+      return [false, nil, {}] unless match
 
-      params = match[1].split(";").map(&:to_i)
-      command = match[2]
+      is_private = (match[1] == "?")
+      params = match[2].split(";").map(&:to_i)
+      space = match[3]
+      command = match[4]
 
       new_saved = nil
+      action = {}
 
       case command
       when "m"
@@ -309,38 +497,81 @@ module TUITD
         end
         cursor[:row] = 0
         cursor[:col] = 0
-      when "h", "l" # DEC private mode set/reset — skip
-        nil
+      when "h"
+        if is_private
+          params.each do |p|
+            case p
+            when 47, 1047, 1049
+              action[:alt_screen] = true
+              action[:alt_screen_code] = p
+            when 25
+              action[:cursor_visible] = true
+            when 1000
+              action[:mouse_mode] = :normal
+            when 1002
+              action[:mouse_mode] = :drag
+            when 1003
+              action[:mouse_mode] = :all
+            when 1006
+              action[:mouse_format] = :sgr
+            end
+          end
+        end
+      when "l"
+        if is_private
+          params.each do |p|
+            case p
+            when 47, 1047, 1049
+              action[:alt_screen] = false
+              action[:alt_screen_code] = p
+            when 25
+              action[:cursor_visible] = false
+            when 1000, 1002, 1003
+              action[:mouse_mode] = :none
+            when 1006
+              action[:mouse_format] = :normal
+            end
+          end
+        end
+      when "q"
+        if space == " "
+          style_val = params[0] || 0
+          action[:cursor_style] = style_val
+        end
       when "n" # DSR — Device Status Report request
-        return [params[0] == 6, nil]
+        return [params[0] == 6, nil, {}]
       when "R" # DSR response (from terminal side) or CPR — ignore
         nil
       end
 
-      [false, new_saved]
+      [false, new_saved, action]
     end
 
     def self._apply_sgr(params, attrs)
-      return attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false) if params.empty? || params == [0]
+      return attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false) if params.empty? || params == [0]
 
       i = 0
       while i < params.length
         p = params[i]
         case p
         when 0
-          attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false)
+          attrs.merge!(fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false)
         when 1
           attrs[:bold] = true
         when 3
           attrs[:italic] = true
         when 4
           attrs[:underline] = true
+        when 5, 6
+          attrs[:blink] = true
         when 22
           attrs[:bold] = false
         when 23
           attrs[:italic] = false
         when 24
           attrs[:underline] = false
+        when 25
+          attrs[:blink] = false
         when 7
           # Reverse — swap fg and bg
           attrs[:fg], attrs[:bg] = attrs[:bg], attrs[:fg]
@@ -453,7 +684,7 @@ module TUITD
     end
 
     def self.default_cell
-      { char: " ", fg: "default", bg: "default", bold: false, italic: false, underline: false }
+      { char: " ", fg: "default", bg: "default", bold: false, italic: false, underline: false, blink: false }
     end
 
     # Extract a single UTF-8 character at position i in a binary string.

data/lib/tui_td/driver.rb

@@ -142,7 +142,7 @@ module TUITD
 
     # Get structured terminal state as a Hash
     def state_data
-      refresh_state! if @state.nil?
+      refresh_state!
       @state
     end
 

data/lib/tui_td/html_renderer.rb

@@ -72,6 +72,49 @@ module TUITD
           z-index: 1;
           position: relative;
         }
+        .cursor-cell.cursor-hidden {
+          outline: none !important;
+          border: none !important;
+          background-color: transparent !important;
+          color: inherit !important;
+        }
+        .cursor-cell.cursor-block {
+          outline: none;
+          background-color: #fff;
+          color: #000 !important;
+        }
+        .cursor-cell.cursor-block.blink {
+          animation: cursor-block-blink 1s step-end infinite;
+        }
+        .cursor-cell.cursor-underline {
+          outline: none;
+          border-bottom: 2px solid #fff;
+        }
+        .cursor-cell.cursor-underline.blink {
+          animation: cursor-underline-blink 1s step-end infinite;
+        }
+        .cursor-cell.cursor-bar {
+          outline: none;
+          border-left: 2px solid #fff;
+        }
+        .cursor-cell.cursor-bar.blink {
+          animation: cursor-bar-blink 1s step-end infinite;
+        }
+        @keyframes cursor-block-blink {
+          50% { background-color: transparent; color: inherit; }
+        }
+        @keyframes cursor-underline-blink {
+          50% { border-bottom-color: transparent; }
+        }
+        @keyframes cursor-bar-blink {
+          50% { border-left-color: transparent; }
+        }
+        @keyframes term-blink {
+          50% { opacity: 0; }
+        }
+        .term-blink {
+          animation: term-blink 1s step-end infinite;
+        }
       CSS
     end
 
@@ -103,17 +146,20 @@ module TUITD
         bold = cell[:bold] || cell["bold"] || false
         italic = cell[:italic] || cell["italic"] || false
         underline = cell[:underline] || cell["underline"] || false
+        blink = cell[:blink] || cell["blink"] || false
 
-        style_key = [fg, bg, bold, italic, underline]
+        style_key = [fg, bg, bold, italic, underline, blink]
+        is_cur = is_cursor?(ri, ci)
 
-        if current_run && current_run[:key] == style_key
+        if current_run && current_run[:key] == style_key && !current_run[:has_cursor] && !is_cur
           current_run[:chars] << char
         else
           current_run = {
             key: style_key,
             chars: [char],
             style: cell_style(fg, bg, bold, italic, underline),
-            has_cursor: is_cursor?(ri, ci)
+            has_cursor: is_cur,
+            blink: blink
           }
           runs << current_run
         end
@@ -134,17 +180,41 @@ module TUITD
 
     def render_run(run)
       chars = run[:chars].map { |c| escape_html(c) }.join
-      return chars if run[:style].empty? && !run[:has_cursor]
+      return chars if run[:style].empty? && !run[:has_cursor] && !run[:blink]
 
       classes = []
-      classes << "cursor-cell" if run[:has_cursor]
+      if run[:has_cursor]
+        classes << "cursor-cell"
+        cursor_vis = @cursor[:visible] != false && @cursor["visible"] != false
+        if !cursor_vis
+          classes << "cursor-hidden"
+        else
+          style_val = @cursor[:style] || @cursor["style"]
+          case style_val
+          when 0, 1
+            classes << "cursor-block blink"
+          when 2
+            classes << "cursor-block"
+          when 3
+            classes << "cursor-underline blink"
+          when 4
+            classes << "cursor-underline"
+          when 5
+            classes << "cursor-bar blink"
+          when 6
+            classes << "cursor-bar"
+          end
+        end
+      end
+      classes << "term-blink" if run[:blink]
+
       cls = classes.empty? ? "" : %( class="#{classes.join(" ")}")
       style = run[:style].empty? ? "" : %( style="#{run[:style]}")
       %(<span#{cls}#{style}>#{chars}</span>)
     end
 
     def is_cursor?(ri, ci)
-      @cursor[:row] == ri && @cursor[:col] == ci
+      (@cursor[:row] || @cursor["row"]) == ri && (@cursor[:col] || @cursor["col"]) == ci
     end
 
     def css_color(rgb)

data/lib/tui_td/screenshot.rb

@@ -107,6 +107,97 @@ module TUITD
       0x00, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0e, 0x0e, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00,  # } (125)
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x7e, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  # ~ (126)
     ].freeze
+    BOX_CHARS = {
+      # horizontal
+      "─" => [false, false, true, true, :light],
+      "━" => [false, false, true, true, :heavy],
+      "═" => [false, false, true, true, :double],
+      # vertical
+      "│" => [true, true, false, false, :light],
+      "┃" => [true, true, false, false, :heavy],
+      "║" => [true, true, false, false, :double],
+      # corners
+      "┌" => [false, true, false, true, :light],
+      "┍" => [false, true, false, true, :light],
+      "┎" => [false, true, false, true, :light],
+      "┏" => [false, true, false, true, :heavy],
+      "┐" => [false, true, true, false, :light],
+      "┑" => [false, true, true, false, :light],
+      "┒" => [false, true, true, false, :light],
+      "┓" => [false, true, true, false, :heavy],
+      "└" => [true, false, false, true, :light],
+      "▼" => [true, false, false, true, :light],
+      "┖" => [true, false, false, true, :light],
+      "┗" => [true, false, false, true, :heavy],
+      "┘" => [true, false, true, false, :light],
+      "┙" => [true, false, true, false, :light],
+      "┚" => [true, false, true, false, :light],
+      "┛" => [true, false, true, false, :heavy],
+      # double corners
+      "╔" => [false, true, false, true, :double],
+      "╗" => [false, true, true, false, :double],
+      "╚" => [true, false, false, true, :double],
+      "╝" => [true, false, true, false, :double],
+      # T-junctions
+      "├" => [true, true, false, true, :light],
+      "┣" => [true, true, false, true, :heavy],
+      "┤" => [true, true, true, false, :light],
+      "┫" => [true, true, true, false, :heavy],
+      "┬" => [false, true, true, true, :light],
+      "┳" => [false, true, true, true, :heavy],
+      "┴" => [true, false, true, true, :light],
+      "┻" => [true, false, true, true, :heavy],
+      # double T-junctions
+      "╠" => [true, true, false, true, :double],
+      "╣" => [true, true, true, false, :double],
+      "╦" => [false, true, true, true, :double],
+      "╩" => [true, false, true, true, :double],
+      # crosses
+      "┼" => [true, true, true, true, :light],
+      "╋" => [true, true, true, true, :heavy],
+      "╬" => [true, true, true, true, :double],
+      # single lines (ends)
+      "╴" => [false, false, true, false, :light],
+      "╵" => [true, false, false, false, :light],
+      "╶" => [false, false, false, true, :light],
+      "╷" => [false, true, false, false, :light],
+      "╸" => [false, false, true, false, :heavy],
+      "╹" => [true, false, false, false, :heavy],
+      "╺" => [false, false, false, true, :heavy],
+      "╻" => [false, true, false, false, :heavy],
+      # mixed corners/junctions
+      "┿" => [true, true, true, true, :light],
+      "╀" => [true, true, true, true, :light],
+      "╁" => [true, true, true, true, :light],
+      "╂" => [true, true, true, true, :light],
+      "╃" => [true, true, true, true, :heavy],
+      "╄" => [true, true, true, true, :heavy],
+      "╅" => [true, true, true, true, :heavy],
+      "╆" => [true, true, true, true, :heavy],
+      "╇" => [true, true, true, true, :heavy],
+      "╈" => [true, true, true, true, :heavy],
+      "╉" => [true, true, true, true, :heavy],
+      "╊" => [true, true, true, true, :heavy],
+      "╒" => [false, true, false, true, :double],
+      "╓" => [false, true, false, true, :double],
+      "╕" => [false, true, true, false, :double],
+      "╖" => [false, true, true, false, :double],
+      "╘" => [true, false, false, true, :double],
+      "╙" => [true, false, false, true, :double],
+      "╛" => [true, false, true, false, :double],
+      "╜" => [true, false, true, false, :double],
+      "╞" => [true, true, false, true, :double],
+      "╟" => [true, true, false, true, :double],
+      "╡" => [true, true, true, false, :double],
+      "╢" => [true, true, true, false, :double],
+      "╤" => [false, true, true, true, :double],
+      "╥" => [false, true, true, true, :double],
+      "╧" => [true, false, true, true, :double],
+      "╨" => [true, false, true, true, :double],
+      "╪" => [true, true, true, true, :double],
+      "╫" => [true, true, true, true, :double]
+    }.freeze
+
     private_constant :FONT
 
     def initialize(state)
@@ -151,6 +242,12 @@ module TUITD
 
       fill_rect(image, px, py, CELL_W, CELL_H, bg_rgb)
 
+      if box_drawing?(char)
+        draw_box_character(image, px, py, char, fg_rgb)
+        draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+        return
+      end
+
       return if char == " " || char.ord < 32 || char.ord > 126
 
       rows_data = glyph_rows(char)
@@ -200,5 +297,94 @@ module TUITD
       w.times { |dx| image[px + dx, y] = color }
     end
 
+    def box_drawing?(char)
+      char_ord = char.ord
+      char_ord >= 0x2500 && char_ord <= 0x257F
+    end
+
+    def draw_box_character(image, px, py, char, fg_rgb)
+      config = BOX_CHARS[char]
+
+      unless config
+        char_ord = char.ord
+        if [0x2500, 0x2501, 0x2504, 0x2505, 0x2508, 0x2509, 0x254c, 0x254d, 0x2550].include?(char_ord)
+          style = [0x2501, 0x2505, 0x2509, 0x254d].include?(char_ord) ? :heavy : (char_ord == 0x2550 ? :double : :light)
+          config = [false, false, true, true, style]
+        elsif [0x2502, 0x2503, 0x2506, 0x2507, 0x250a, 0x250b, 0x254e, 0x254f, 0x2551].include?(char_ord)
+          style = [0x2503, 0x2507, 0x250b, 0x254f].include?(char_ord) ? :heavy : (char_ord == 0x2551 ? :double : :light)
+          config = [true, true, false, false, style]
+        else
+          config = [true, true, true, true, :light]
+        end
+      end
+
+      up, down, left, right, style = config
+      cx = px + 4
+      cy = py + 8
+
+      color = ChunkyPNG::Color.rgb(*fg_rgb)
+
+      if style == :double
+        if left
+          (px..(cx + 2)).each { |x| image[x, py + 6] = color }
+          (px..(cx + 2)).each { |x| image[x, py + 10] = color }
+        end
+        if right
+          ((cx - 2)..(px + 7)).each { |x| image[x, py + 6] = color }
+          ((cx - 2)..(px + 7)).each { |x| image[x, py + 10] = color }
+        end
+        if up
+          (py..(cy + 2)).each { |y| image[px + 2, y] = color }
+          (py..(cy + 2)).each { |y| image[px + 6, y] = color }
+        end
+        if down
+          ((cy - 2)..(py + 15)).each { |y| image[px + 2, y] = color }
+          ((cy - 2)..(py + 15)).each { |y| image[px + 6, y] = color }
+        end
+      elsif style == :heavy
+        if left
+          (px..cx).each do |x|
+            image[x, cy - 1] = color
+            image[x, cy] = color
+            image[x, cy + 1] = color
+          end
+        end
+        if right
+          (cx..(px + 7)).each do |x|
+            image[x, cy - 1] = color
+            image[x, cy] = color
+            image[x, cy + 1] = color
+          end
+        end
+        if up
+          (py..cy).each do |y|
+            image[cx - 1, y] = color
+            image[cx, y] = color
+            image[cx + 1, y] = color
+          end
+        end
+        if down
+          (cy..(py + 15)).each do |y|
+            image[cx - 1, y] = color
+            image[cx, y] = color
+            image[cx + 1, y] = color
+          end
+        end
+      else # :light
+        if left
+          (px..cx).each { |x| image[x, cy] = color }
+        end
+        if right
+          (cx..(px + 7)).each { |x| image[x, cy] = color }
+        end
+        if up
+          (py..cy).each { |y| image[cx, y] = color }
+        end
+        if down
+          (cy..(py + 15)).each { |y| image[cx, y] = color }
+        end
+      end
+    end
+
   end
 end

data/lib/tui_td/state.rb

@@ -4,7 +4,7 @@ module TUITD
   # Represents the parsed state of a terminal screen.
   # Provides high-level query methods for AI consumption.
   class State
-    attr_reader :rows, :cols, :grid, :cursor
+    attr_reader :rows, :cols, :grid, :cursor, :cursor_visible, :cursor_style, :mouse_mode, :mouse_format
 
     def initialize(data)
       raise ArgumentError, "State data must include :size key" unless data[:size]
@@ -14,6 +14,13 @@ module TUITD
       @cols = data[:size][:cols]
       @grid = data[:rows]
       @cursor = data[:cursor]
+
+      cursor_info = data[:cursor].is_a?(Hash) ? data[:cursor] : {}
+      @cursor_visible = data.key?(:cursor_visible) ? data[:cursor_visible] : (cursor_info[:visible] != false)
+      @cursor_style = data.key?(:cursor_style) ? data[:cursor_style] : (cursor_info[:style] || 1)
+
+      @mouse_mode = data[:mouse_mode] || :none
+      @mouse_format = data[:mouse_format] || :normal
     end
 
     # Get plain text of the entire terminal (no ANSI)

data/lib/tui_td/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TUITD
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tui-td
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Haluk Durmus