shellfie 0.1.1 → 1.1.0

data/lib/shellfie/text_metrics.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Shellfie
+  module TextMetrics
+    UNICODE_VERSION = RbConfig::CONFIG["UNICODE_VERSION"] || "unknown"
+    WIDTH_TABLE_VERSION = "1"
+    AMBIGUOUS_RANGES = [
+      0x00a1..0x00a1, 0x00a4..0x00a4, 0x00a7..0x00a8, 0x00aa..0x00aa, 0x00ad..0x00ae,
+      0x00b0..0x00b4, 0x00b6..0x00ba, 0x00bc..0x00bf, 0x00c6..0x00c6, 0x00d0..0x00d0,
+      0x00d7..0x00d8, 0x00de..0x00e1, 0x00e6..0x00e6, 0x00e8..0x00ea, 0x00ec..0x00ed,
+      0x00f0..0x00f0, 0x00f2..0x00f3, 0x00f7..0x00fa, 0x00fc..0x00fc, 0x00fe..0x00fe,
+      0x0101..0x0101, 0x0111..0x0113, 0x011b..0x011b, 0x0126..0x0127, 0x012b..0x012b,
+      0x0131..0x0133, 0x0138..0x0138, 0x013f..0x0142, 0x0144..0x0144, 0x0148..0x014b,
+      0x014d..0x014d, 0x0152..0x0153, 0x0166..0x0167, 0x016b..0x016b, 0x01ce..0x01dc,
+      0x0251..0x0251, 0x0261..0x0261, 0x02c4..0x02c4, 0x02c7..0x02c7, 0x02c9..0x02cb,
+      0x02cd..0x02d0, 0x02d8..0x02db, 0x02dd..0x02df, 0x0391..0x03a1, 0x03a3..0x03a9,
+      0x03b1..0x03c1, 0x03c3..0x03c9, 0x0401..0x0401, 0x0410..0x044f, 0x0451..0x0451,
+      0x2010..0x2010, 0x2013..0x2016, 0x2018..0x2019, 0x201c..0x201d, 0x2020..0x2022,
+      0x2024..0x2026, 0x2030..0x2030, 0x2032..0x2033, 0x2035..0x2035, 0x203b..0x203e,
+      0x2074..0x2074, 0x207f..0x207f, 0x2081..0x2084, 0x20ac..0x20ac, 0x2103..0x2103,
+      0x2105..0x2105, 0x2109..0x2109, 0x2113..0x2113, 0x2116..0x2116, 0x2121..0x2122,
+      0x2126..0x2126, 0x212b..0x212b, 0x2153..0x2154, 0x215b..0x215e, 0x2160..0x216b,
+      0x2170..0x2179, 0x2189..0x2189, 0x2190..0x2199, 0x21b8..0x21b9, 0x21d2..0x21d4,
+      0x21e7..0x21e7, 0x2200..0x2200, 0x2202..0x2203, 0x2207..0x2208, 0x220b..0x220b,
+      0x220f..0x2211, 0x2215..0x2215, 0x221a..0x221a, 0x221d..0x2220, 0x2223..0x2223,
+      0x2225..0x2225, 0x2227..0x222c, 0x222e..0x222e, 0x2234..0x2237, 0x223c..0x223d,
+      0x2248..0x2248, 0x224c..0x224c, 0x2252..0x2252, 0x2260..0x2261, 0x2264..0x2267,
+      0x226a..0x226b, 0x226e..0x226f, 0x2282..0x2283, 0x2286..0x2287, 0x2295..0x2295,
+      0x2299..0x2299, 0x22a5..0x22a5, 0x22bf..0x22bf, 0x2312..0x2312, 0x2460..0x254b,
+      0x2550..0x2573, 0x2580..0x258f, 0x2592..0x2595, 0x25a0..0x25a1, 0x25a3..0x25a9,
+      0x25b2..0x25b3, 0x25b6..0x25b7, 0x25bc..0x25bd, 0x25c0..0x25c1, 0x25c6..0x25c8,
+      0x25cb..0x25cb, 0x25ce..0x25d1, 0x25e2..0x25e5, 0x25ef..0x25ef, 0x2605..0x2606,
+      0x2609..0x2609, 0x260e..0x260f, 0x261c..0x261c, 0x261e..0x261e, 0x2640..0x2640,
+      0x2642..0x2642, 0x2660..0x2661, 0x2663..0x2665, 0x2667..0x266a, 0x266c..0x266d,
+      0x266f..0x266f, 0xe000..0xf8ff, 0xfffd..0xfffd
+    ].freeze
+
+    module_function
+
+    def graphemes(text)
+      string = text.to_s.dup
+      string.force_encoding(Encoding::UTF_8)
+      string.scrub.scan(/\X/)
+    end
+
+    def cell_width(text, ambiguous_width: 1)
+      graphemes(text).sum { |grapheme| grapheme_width(grapheme, ambiguous_width: ambiguous_width) }
+    end
+
+    def pixel_width(text, font_size, ambiguous_width: 1)
+      (cell_width(text, ambiguous_width: ambiguous_width) * font_size * 0.6).ceil
+    end
+
+    def take_cells(text, max_cells, ambiguous_width: 1)
+      result = +""
+      used_cells = 0
+
+      graphemes(text).each do |char|
+        width = grapheme_width(char, ambiguous_width: ambiguous_width)
+        break if used_cells + width > max_cells
+
+        result << char
+        used_cells += width
+      end
+
+      result
+    end
+
+    def drop_cells(text, cells_to_drop, ambiguous_width: 1)
+      used_cells = 0
+      graphemes(text).each_with_object(+"") do |char, result|
+        width = grapheme_width(char, ambiguous_width: ambiguous_width)
+        if used_cells < cells_to_drop
+          used_cells += width
+          next
+        end
+
+        result << char
+      end
+    end
+
+    def split_cells(text, max_cells, ambiguous_width: 1)
+      return [text.to_s] if max_cells <= 0
+
+      chunks = []
+      current = +""
+      used_cells = 0
+
+      graphemes(text).each do |char|
+        width = grapheme_width(char, ambiguous_width: ambiguous_width)
+        if used_cells.positive? && used_cells + width > max_cells
+          chunks << current
+          current = +""
+          used_cells = 0
+        end
+
+        current << char
+        used_cells += width
+      end
+
+      chunks << current unless current.empty?
+      chunks
+    end
+
+    def char_width(char, ambiguous_width: 1)
+      codepoint = char.ord
+      return 0 if combining?(codepoint)
+      return 0 if codepoint < 32 || codepoint == 0x7f
+      return 2 if wide?(codepoint)
+      return ambiguous_width if ambiguous?(codepoint)
+
+      1
+    end
+
+    def grapheme_width(grapheme, ambiguous_width: 1)
+      codepoints = grapheme.codepoints
+      return 0 if codepoints.empty? || codepoints.all? { |codepoint| combining?(codepoint) }
+      return 2 if grapheme.include?("\u200d") || grapheme.include?("\ufe0f") || grapheme.include?("\u20e3") ||
+                  grapheme.match?(/[\u{1f1e6}-\u{1f1ff}]{2}/)
+
+      codepoints.map { |codepoint| char_width(codepoint.chr(Encoding::UTF_8), ambiguous_width: ambiguous_width) }.max || 0
+    end
+
+    def combining?(codepoint)
+      (0x0300..0x036f).cover?(codepoint) ||
+        (0x1ab0..0x1aff).cover?(codepoint) ||
+        (0x1dc0..0x1dff).cover?(codepoint) ||
+        (0x20d0..0x20ff).cover?(codepoint) ||
+        (0xfe00..0xfe0f).cover?(codepoint) ||
+        (0xfe20..0xfe2f).cover?(codepoint) ||
+        (0xe0100..0xe01ef).cover?(codepoint)
+    end
+
+    def wide?(codepoint)
+      (0x1100..0x115f).cover?(codepoint) ||
+        (0x2329..0x232a).cover?(codepoint) ||
+        (0x2e80..0xa4cf).cover?(codepoint) ||
+        (0xac00..0xd7a3).cover?(codepoint) ||
+        (0xf900..0xfaff).cover?(codepoint) ||
+        (0xfe10..0xfe19).cover?(codepoint) ||
+        (0xfe30..0xfe6f).cover?(codepoint) ||
+        (0xff00..0xff60).cover?(codepoint) ||
+        (0xffe0..0xffe6).cover?(codepoint) ||
+        (0x1f300..0x1faff).cover?(codepoint)
+    end
+
+    def ambiguous?(codepoint)
+      return false if codepoint < 0x00a1
+
+      AMBIGUOUS_RANGES.any? { |range| range.cover?(codepoint) }
+    end
+  end
+end

data/lib/shellfie/theme_data.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class ThemeData
+    attr_reader :name, :colors, :window_decoration, :button_colors, :buttons_position, :button_style, :font,
+                :title_alignment
+
+    def self.from_theme(theme, name:, colors: {}, window_decoration: {}, font: {}, headless: false)
+      data = new(
+        name: name,
+        colors: theme.colors.merge(colors || {}),
+        window_decoration: deep_merge(theme.window_decoration, window_decoration || {}),
+        button_colors: theme.button_colors,
+        buttons_position: theme.buttons_position,
+        button_style: theme.button_style,
+        font: theme.font.merge(font || {}),
+        title_alignment: theme.title_alignment
+      )
+      headless ? data.headless : data
+    end
+
+    def self.deep_merge(base, overrides)
+      base.merge(overrides) do |_key, left, right|
+        left.is_a?(Hash) && right.is_a?(Hash) ? deep_merge(left, right) : right
+      end
+    end
+
+    def initialize(name:, colors:, window_decoration:, button_colors:, buttons_position:, button_style:, font:,
+                   title_alignment:)
+      @name = name
+      @colors = deep_freeze_copy(colors)
+      @window_decoration = deep_freeze_copy(window_decoration)
+      @button_colors = deep_freeze_copy(button_colors)
+      @buttons_position = buttons_position
+      @button_style = button_style
+      @font = deep_freeze_copy(font)
+      @title_alignment = title_alignment
+      freeze
+    end
+
+    def color_for(name)
+      return name if name.is_a?(String) && name.start_with?("#")
+
+      colors[name.to_sym] || colors[:foreground]
+    end
+
+    def headless
+      self.class.new(
+        name: name,
+        colors: colors,
+        window_decoration: self.class.deep_merge(
+          window_decoration,
+          title_bar_height: 0,
+          corner_radius: 0,
+          button_size: 0,
+          button_spacing: 0
+        ),
+        button_colors: [],
+        buttons_position: :left,
+        button_style: :none,
+        font: font,
+        title_alignment: :left
+      )
+    end
+
+    private
+
+    def deep_freeze_copy(value)
+      copy = case value
+             when Hash
+               value.each_with_object({}) { |(key, nested), result| result[key] = deep_freeze_copy(nested) }
+             when Array
+               value.map { |nested| deep_freeze_copy(nested) }
+             else
+               value
+             end
+      copy.freeze
+    end
+  end
+end

data/lib/shellfie/theme_registry.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "themes/base"
+require_relative "themes/configured"
+require_relative "themes/macos"
+require_relative "themes/ubuntu"
+require_relative "themes/windows_terminal"
+require_relative "headless_theme_registry"
+require_relative "theme_data"
+
+module Shellfie
+  class ThemeRegistry
+    WINDOW_THEMES = {
+      "macos" => Themes::MacOS,
+      "ubuntu" => Themes::Ubuntu,
+      "windows" => Themes::WindowsTerminal
+    }.freeze
+
+    COLOR_SCHEMES = {
+      "dracula" => {
+        background: "#282a36",
+        foreground: "#f8f8f2",
+        black: "#21222c",
+        red: "#ff5555",
+        green: "#50fa7b",
+        yellow: "#f1fa8c",
+        blue: "#6272a4",
+        magenta: "#ff79c6",
+        cyan: "#8be9fd",
+        white: "#f8f8f2",
+        bright_black: "#6272a4",
+        bright_red: "#ff6e6e",
+        bright_green: "#69ff94",
+        bright_yellow: "#ffffa5",
+        bright_blue: "#d6acff",
+        bright_magenta: "#ff92df",
+        bright_cyan: "#a4ffff",
+        bright_white: "#ffffff"
+      },
+      "one_dark" => {
+        background: "#282c34",
+        foreground: "#abb2bf",
+        red: "#e06c75",
+        green: "#98c379",
+        yellow: "#e5c07b",
+        blue: "#61afef",
+        magenta: "#c678dd",
+        cyan: "#56b6c2",
+        white: "#abb2bf"
+      },
+      "solarized_dark" => {
+        background: "#002b36",
+        foreground: "#839496",
+        red: "#dc322f",
+        green: "#859900",
+        yellow: "#b58900",
+        blue: "#268bd2",
+        magenta: "#d33682",
+        cyan: "#2aa198",
+        white: "#eee8d5"
+      },
+      "catppuccin_mocha" => {
+        background: "#1e1e2e",
+        foreground: "#cdd6f4",
+        red: "#f38ba8",
+        green: "#a6e3a1",
+        yellow: "#f9e2af",
+        blue: "#89b4fa",
+        magenta: "#cba6f7",
+        cyan: "#94e2d5",
+        white: "#bac2de"
+      }
+    }.freeze
+
+    class << self
+      def build(config)
+        base_name = config.theme == "custom" ? (config.window_theme || "macos") : (config.window_theme || config.theme)
+        base_theme = fetch_window_theme(base_name).new
+        colors = color_scheme(config.color_scheme).merge(config.colors)
+
+        theme = Themes::Configured.new(
+          base_theme,
+          name: config.theme,
+          colors: colors,
+          window_decoration: config.window_decoration,
+          font: font_overrides(config)
+        )
+        theme_data = ThemeData.from_theme(theme, name: config.theme)
+        config.headless ? HeadlessThemeRegistry.build(theme_data) : theme_data
+      end
+
+      def valid_theme?(name)
+        name == "custom" || WINDOW_THEMES.key?(name)
+      end
+
+      def valid_window_theme?(name)
+        WINDOW_THEMES.key?(name)
+      end
+
+      def valid_color_scheme?(name)
+        name.nil? || COLOR_SCHEMES.key?(name)
+      end
+
+      def available_themes
+        (WINDOW_THEMES.keys + ["custom"]).sort
+      end
+
+      def available_color_schemes
+        COLOR_SCHEMES.keys.sort
+      end
+
+      private
+
+      def fetch_window_theme(name)
+        WINDOW_THEMES.fetch(name) do
+          raise ValidationError, "Invalid theme '#{name}'\n  → Available themes: #{available_themes.join(", ")}"
+        end
+      end
+
+      def color_scheme(name)
+        return {} unless name
+
+        COLOR_SCHEMES.fetch(name)
+      end
+
+      def font_overrides(config)
+        config.font == Config::DEFAULTS[:font] ? {} : config.font
+      end
+    end
+  end
+end

data/lib/shellfie/themes/base.rb

@@ -23,6 +23,9 @@ module Shellfie
           foreground: "#ffffff",
           title_bar: "#3c3c3c",
           title_text: "#ffffff",
+          title_bar_border: "rgba(255,255,255,0.08)",
+          border: "rgba(255,255,255,0.10)",
+          selection: "rgba(80,140,255,0.28)",
           black: "#000000",
           red: "#ff5555",
           green: "#50fa7b",
@@ -54,11 +57,17 @@ module Shellfie
         :left
       end
 
+      def title_alignment
+        :center
+      end
+
       def font
         {
           family: "Monaco",
           size: 14,
-          line_height: 1.4
+          line_height: 1.4,
+          fallback_family: "Menlo",
+          emoji_family: "Apple Color Emoji"
         }
       end
 

data/lib/shellfie/themes/configured.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Shellfie
+  module Themes
+    class Configured
+      def initialize(base_theme, name:, colors: {}, window_decoration: {}, font: {})
+        @base_theme = base_theme
+        @name = name
+        @colors = colors || {}
+        @window_decoration = window_decoration || {}
+        @font = font || {}
+      end
+
+      def name
+        @name
+      end
+
+      def window_decoration
+        deep_merge(@base_theme.window_decoration, @window_decoration)
+      end
+
+      def colors
+        @base_theme.colors.merge(@colors)
+      end
+
+      def font
+        @base_theme.font.merge(@font)
+      end
+
+      def button_colors
+        @base_theme.button_colors
+      end
+
+      def button_style
+        @base_theme.button_style
+      end
+
+      def buttons_position
+        @base_theme.buttons_position
+      end
+
+      def title_alignment
+        @base_theme.title_alignment
+      end
+
+      def color_for(name)
+        return name if name.is_a?(String) && name.start_with?("#")
+
+        colors[name.to_sym] || colors[:foreground]
+      end
+
+      private
+
+      def deep_merge(base, overrides)
+        base.merge(overrides) do |_key, left, right|
+          left.is_a?(Hash) && right.is_a?(Hash) ? deep_merge(left, right) : right
+        end
+      end
+    end
+  end
+end

data/lib/shellfie/themes/macos.rb

@@ -43,7 +43,9 @@ module Shellfie
         {
           family: "SF Mono",
           size: 14,
-          line_height: 1.4
+          line_height: 1.4,
+          fallback_family: "Menlo",
+          emoji_family: "Apple Color Emoji"
         }
       end
     end

data/lib/shellfie/themes/ubuntu.rb

@@ -49,7 +49,8 @@ module Shellfie
         {
           family: "Ubuntu Mono",
           size: 14,
-          line_height: 1.4
+          line_height: 1.4,
+          fallback_family: "DejaVu Sans Mono"
         }
       end
     end

data/lib/shellfie/themes/windows_terminal.rb

@@ -13,6 +13,7 @@ module Shellfie
         {
           title_bar_height: 32,
           button_size: 10,
+          button_width: 46,
           button_spacing: 0,
           corner_radius: 0,
           shadow: { blur: 15, offset_x: 0, offset_y: 5, color: "rgba(0,0,0,0.25)" }
@@ -52,11 +53,16 @@ module Shellfie
         :right
       end
 
+      def title_alignment
+        :left
+      end
+
       def font
         {
           family: "Cascadia Mono",
           size: 14,
-          line_height: 1.3
+          line_height: 1.3,
+          fallback_family: "Consolas"
         }
       end
     end

data/lib/shellfie/transcript_renderer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "animation_frame_builder"
+require_relative "ansi_parser"
+require_relative "output_writer"
+
+module Shellfie
+  class TranscriptRenderer
+    def initialize(config)
+      @config = config
+    end
+
+    def render(output_path, format:, io: nil)
+      OutputWriter.write(output_path, extension: format, io: io) do |temporary_path|
+        value = case format
+                when "json" then JSON.pretty_generate(document)
+                when "ansi" then ansi_text
+                when "asciicast", "cast" then asciicast
+                else text
+                end
+        File.write(temporary_path, value)
+      end
+    end
+
+    private
+
+    attr_reader :config
+
+    def final_lines
+      return config.lines if config.frames.empty?
+
+      AnimationFrameBuilder.new(config).build.last[:lines]
+    end
+
+    def text
+      final_lines.flat_map do |line|
+        command = "#{line.prompt}#{line.command}" if line.prompt || line.command
+        [command, line.output].compact.map { |value| plain_text(value) }
+      end.join("\n") + "\n"
+    end
+
+    def ansi_text
+      final_lines.flat_map do |line|
+        command = "#{line.prompt}#{line.command}" if line.prompt || line.command
+        [command, line.output].compact
+      end.join("\n") + "\n"
+    end
+
+    def asciicast
+      width = [config.window[:width].to_i / 8, 1].max
+      header = { version: 2, width: width, height: [final_lines.size, 1].max, env: { "TERM" => "xterm-256color" } }
+      elapsed = 0.0
+      source = config.frames.empty? ? [{ text: ansi_text, delay: 0 }] : config.frames.map do |frame|
+        { text: frame_to_ansi(frame), delay: frame.delay }
+      end
+      events = source.map do |event|
+        value = [elapsed.round(6), "o", event[:text]]
+        elapsed += event[:delay].to_f / 1_000
+        value
+      end
+      ([JSON.generate(header)] + events.map { |event| JSON.generate(event) }).join("\n") + "\n"
+    end
+
+    def frame_to_ansi(frame)
+      command = "#{frame.prompt}#{frame.command}" if frame.prompt || frame.command
+      [command, frame.output].compact.join("\r\n") + "\r\n"
+    end
+
+    def document
+      {
+        version: 1,
+        title: config.title,
+        lines: final_lines.map { |line| plain_value(line.to_h) },
+        events: config.frames.map { |frame| plain_value(frame.to_h) }
+      }
+    end
+
+    def plain_value(value)
+      case value
+      when String then plain_text(value)
+      when Array then value.map { |item| plain_value(item) }
+      when Hash then value.transform_values { |item| plain_value(item) }
+      else value
+      end
+    end
+
+    def plain_text(value)
+      AnsiParser.new(state_mode: :line).parse(value.to_s).map(&:text).join
+    end
+  end
+end

data/lib/shellfie/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shellfie
-  VERSION = "0.1.1"
+  VERSION = "1.1.0"
 end