tui-td 0.2.7 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f09dac0e163cc0b1f2e699d66fe25fd656003b28ad17867a32154073cec8a62
-  data.tar.gz: a46f622e3a7a89c0451e603e89266575eec49b346af851c8bce393230684c759
+  metadata.gz: e0062b5242a5e1ec97546b733761ce7a7fe559ee85d2e413cdce25798fa0861d
+  data.tar.gz: 2fbf22c11937739e51bc303d4ddbaedd6edb1015ef829046dc9d42bc5a1f2bf8
 SHA512:
-  metadata.gz: adb1c08cd89f21f59e270c73d94f8542ada7949069ebb5c6dcad27dc860264df93f09dea8e8c2053e90f909ca9c5405254e0f51d2afbd6dba194e1b3d293e4d3
-  data.tar.gz: 70597354fa770012221aa26f03a2ce4198f13ebb8ea66f1bacba20f7be740b1487d31c6908de19036889ae3ab0f60fc4a7cf57d993c5b938453f51618ecb9b28
+  metadata.gz: 306311eefc1fc30811cd630ac23f35f02ce7d14250c9bdd1cc63a7508a199193af475947fed85bc24198b3060903ce38b392f056ddba326fc22741b3ba28568c
+  data.tar.gz: 90bcfdd7d9f9f9357758deb5f7ebb8b3a7f20ca919f398909ecd03801106998fcf190c5341141324ec427618e9a32ad40cfbc117ae7bb474b5421e1677b4980e

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 0.2.9
+
+- Fix: `wait_for_stable` uses parsed terminal grid comparison instead of raw byte arrival, preventing interactive TUIs that repaint cell-by-cell (e.g., glow) from timing out
+- Fix: `cmd_capture` catches timeout for interactive TUIs and proceeds with whatever was rendered
+- New tests for `driver.rb` (39), `cli.rb` (19), and `mcp/server.rb` (27) — 85 new tests total
+
+## 0.2.8
+
+- Unicode bitmap font in screenshot renderer: 2766 glyphs from GNU Unifont 17.0.04 covering Latin, Greek, Cyrillic, Arabic, Turkish, Math, Arrows, Box Drawing, Symbols, and Dingbats
+- Cairo renderer as optional fallback for characters not in Unifont (e.g. CJK), with 3x supersampling and box-filter downsampling for sharp edges
+- Rendering priority: Spleen (ASCII 33–126) → Unifont (127+, 2766 glyphs) → Cairo (fallback)
+- Full test coverage for Unifont glyphs and Cairo renderer
+
 ## 0.2.7
 
 - Screenshot rendering for 23 special characters: blocks (▀ ▄ █), triangles (▲ ▼), arrows (↑ ↓ → ←), half blocks (▌ ▐)

data/lib/tui_td/cairo_renderer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module TUITD
+  module CairoRenderer
+    CELL_W = 8
+    CELL_H = 16
+    DEFAULT_FONT = "Arial Unicode MS"
+    FONT_SIZE = 12.0
+    RENDER_SCALE = 3
+
+    @available = false
+    @cache = {}
+
+    begin
+      require "cairo"
+      @available = true
+    rescue LoadError
+      # Cairo not available; render_glyph_onto is a no-op
+    end
+
+    class << self
+      def available?
+        @available
+      end
+
+      def render_glyph_onto(cpn_image, px, py, char, fg_rgb, bold:, italic:)
+        return unless available?
+
+        alpha = glyph_alpha(char, bold: bold, italic: italic)
+        composite(alpha, cpn_image, px, py, fg_rgb)
+      rescue StandardError => e
+        warn "CairoRenderer: #{e.message}" if $DEBUG
+      end
+
+      private
+
+      def glyph_alpha(char, bold:, italic:)
+        key = [char.ord, bold, italic]
+        @cache[key] ||= render_surface(char, bold, italic)
+      end
+
+      def render_surface(char, bold, italic)
+        # Render at higher resolution then box-filter downsample for smoother edges
+        scale = RENDER_SCALE
+        big_w = CELL_W * scale
+        big_h = CELL_H * scale
+        surface = Cairo::ImageSurface.new(Cairo::Format::ARGB32, big_w, big_h)
+        context = Cairo::Context.new(surface)
+
+        context.antialias = Cairo::ANTIALIAS_NONE
+
+        fo = Cairo::FontOptions.new
+        fo.hint_style = Cairo::HINT_STYLE_FULL
+        fo.hint_metrics = Cairo::HINT_METRICS_ON
+        context.font_options = fo
+
+        slant = italic ? Cairo::FONT_SLANT_ITALIC : Cairo::FONT_SLANT_NORMAL
+        weight = bold ? Cairo::FONT_WEIGHT_BOLD : Cairo::FONT_WEIGHT_NORMAL
+        context.select_font_face(DEFAULT_FONT, slant, weight)
+        context.set_font_size(FONT_SIZE * scale)
+
+        extents = context.text_extents(char)
+        x_off = ((big_w - extents.width) / 2.0) - extents.x_bearing
+        y_off = ((big_h - extents.height) / 2.0) - extents.y_bearing
+
+        context.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        context.move_to(x_off, y_off)
+        context.show_text(char)
+
+        data = surface.data
+        stride = surface.stride
+        scale_sq = scale * scale
+
+        alpha_grid = Array.new(CELL_H) { Array.new(CELL_W, 0) }
+        CELL_H.times do |dy|
+          CELL_W.times do |dx|
+            sum = 0
+            scale.times do |sy|
+              row_off = (dy * scale + sy) * stride
+              scale.times do |sx|
+                sum += data.getbyte(row_off + (dx * scale + sx) * 4 + 3)
+              end
+            end
+            alpha_grid[dy][dx] = sum / scale_sq
+          end
+        end
+
+        alpha_grid
+      end
+
+      def composite(alpha_grid, cpn_image, px, py, fg_rgb)
+        fr, fg, fb = fg_rgb
+
+        CELL_H.times do |dy|
+          CELL_W.times do |dx|
+            a = alpha_grid[dy][dx]
+            next if a < 24
+
+            factor = [a, 255].min / 255.0
+            r = (fr * factor).to_i
+            g = (fg * factor).to_i
+            b = (fb * factor).to_i
+            cpn_image[px + dx, py + dy] = ChunkyPNG::Color.rgb(r, g, b)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tui_td/cli.rb

@@ -211,8 +211,18 @@ module TUITD
       cmd = args.join(" ")
 
       driver = Driver.new(cmd, **globals.slice(:rows, :cols, :timeout, :chdir))
-      driver.start
-      driver.wait_for_stable
+      begin
+        driver.start
+      rescue TimeoutError
+        # Interactive TUI that never stabilizes (e.g., glow without -p).
+        # Proceed with whatever was rendered before the timeout.
+        driver.refresh
+      end
+      begin
+        driver.wait_for_stable
+      rescue TimeoutError
+        # Ignored — already have rendered state from start
+      end
 
       case globals[:format]
       when :json

data/lib/tui_td/driver.rb

@@ -96,17 +96,28 @@ module TUITD
       refresh_state!
     end
 
-    # Wait for output to stabilize (no new data for N milliseconds)
+    # Wait for output to stabilize (grid content unchanged for N milliseconds)
     def wait_for_stable(stable_ms: 300)
       deadline = monotonic + @timeout
       last_change = monotonic
+      last_grid = nil
 
       loop do
         raise TimeoutError, "Timeout waiting for stable output" if monotonic > deadline
 
-        if read_available!
-          last_change = monotonic
-        elsif (monotonic - last_change) * 1000 >= stable_ms
+        had_data = read_available!
+        process_alive = process_alive?
+
+        if had_data
+          current_grid = parse_grid_snapshot
+          if current_grid != last_grid
+            last_grid = current_grid
+            last_change = monotonic
+          end
+        elsif !process_alive
+          # Process exited and no more data — final state reached
+          break
+        elsif last_grid && (monotonic - last_change) * 1000 >= stable_ms
           break
         end
 
@@ -246,6 +257,19 @@ module TUITD
       end
     end
 
+    def parse_grid_snapshot
+      @output_mutex.synchronize do
+        ANSIParser.parse(@output_buffer, @rows, @cols)[:rows]
+      end
+    end
+
+    def process_alive?
+      return false unless @pid
+      Process.waitpid(@pid, Process::WNOHANG).nil?
+    rescue Errno::ECHILD
+      false
+    end
+
     def monotonic
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end

data/lib/tui_td/screenshot.rb

@@ -2,6 +2,8 @@
 
 require "chunky_png"
 require_relative "ansi_utils"
+require_relative "cairo_renderer"
+require_relative "unifont_glyphs"
 
 module TUITD
   class Screenshot
@@ -356,12 +358,32 @@ module TUITD
         return
       end
 
-      return if char == " " || char_ord < 32 || char_ord > 126
+      return if char == " " || char_ord < 32
 
-      rows_data = glyph_rows(char)
-      return unless rows_data
+      # ASCII printable (33-126): use Spleen bitmap font (pixel-perfect)
+      if char_ord <= 126
+        rows_data = glyph_rows(char)
+        if rows_data
+          draw_glyph(image, px, py, rows_data, fg_rgb, bold: bold, italic: italic)
+          draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+          return
+        end
+      end
+
+      # Unicode (127+): try Unifont bitmap first (pixel-perfect like Spleen)
+      if char_ord > 126
+        unifont_rows = UnifontGlyphs.rows(char_ord)
+        if unifont_rows
+          draw_glyph(image, px, py, unifont_rows, fg_rgb, bold: bold, italic: italic)
+          draw_underline(image, px, py, CELL_W, fg_rgb) if underline
+          return
+        end
+      end
 
-      draw_glyph(image, px, py, rows_data, fg_rgb, bold: bold, italic: italic)
+      # Fallback: render via Cairo for characters not in Unifont
+      if CairoRenderer.available?
+        CairoRenderer.render_glyph_onto(image, px, py, char, fg_rgb, bold: bold, italic: italic)
+      end
 
       draw_underline(image, px, py, CELL_W, fg_rgb) if underline
     end