echoes 0.2.0

data/lib/echoes/sixel_decoder.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Echoes
+  class SixelDecoder
+    attr_reader :width, :height
+
+    def initialize(params = [])
+      @background_mode = params[1] || 0
+      @color_registers = default_color_registers
+      @current_color = 0
+      @cursor_x = 0
+      @cursor_y = 0
+      @width = 0
+      @height = 0
+      @pixels = {}
+      @declared_width = 0
+      @declared_height = 0
+    end
+
+    def decode(data)
+      i = 0
+      len = data.bytesize
+
+      while i < len
+        byte = data.getbyte(i)
+
+        case byte
+        when 0x21 # '!' repeat
+          i, count, ch = parse_repeat(data, i + 1)
+          paint_sixel(ch, count) if ch
+        when 0x22 # '"' raster attributes
+          i, _, _, ph, pv = parse_raster_attributes(data, i + 1)
+          @declared_width = ph if ph > 0
+          @declared_height = pv if pv > 0
+        when 0x23 # '#' color
+          i = parse_color(data, i + 1)
+        when 0x24 # '$' graphics CR
+          @cursor_x = 0
+          i += 1
+        when 0x2D # '-' graphics newline
+          @cursor_x = 0
+          @cursor_y += 6
+          i += 1
+        when 0x3F..0x7E # sixel character
+          paint_sixel(byte, 1)
+          i += 1
+        else
+          i += 1
+        end
+      end
+
+      @width = @declared_width if @declared_width > @width
+      @height = @declared_height if @declared_height > @height
+      self
+    end
+
+    def to_rgba
+      buf = "\x00".b * (@width * @height * 4)
+      transparent = @background_mode == 1
+
+      @pixels.each do |(x, y), color|
+        next if x >= @width || y >= @height
+
+        offset = (y * @width + x) * 4
+        buf.setbyte(offset,     color[0])
+        buf.setbyte(offset + 1, color[1])
+        buf.setbyte(offset + 2, color[2])
+        buf.setbyte(offset + 3, 255)
+      end
+
+      unless transparent
+        # Set alpha=255 for unset pixels (background fill)
+        (@width * @height).times do |i|
+          offset = i * 4
+          buf.setbyte(offset + 3, 255) if buf.getbyte(offset + 3) == 0
+        end
+      end
+
+      buf
+    end
+
+    private
+
+    def default_color_registers
+      {
+        0  => [0,   0,   0],
+        1  => [51,  51, 204],
+        2  => [204, 51,  51],
+        3  => [51, 204,  51],
+        4  => [204, 51, 204],
+        5  => [51, 204, 204],
+        6  => [204, 204, 51],
+        7  => [135, 135, 135],
+        8  => [68,  68,  68],
+        9  => [84,  84, 255],
+        10 => [255, 84,  84],
+        11 => [84, 255,  84],
+        12 => [255, 84, 255],
+        13 => [84, 255, 255],
+        14 => [255, 255, 84],
+        15 => [255, 255, 255],
+      }
+    end
+
+    def paint_sixel(byte, count)
+      bits = byte - 0x3F
+      color = @color_registers[@current_color] || [0, 0, 0]
+
+      6.times do |bit|
+        next unless (bits >> bit) & 1 == 1
+
+        y = @cursor_y + bit
+        count.times do |dx|
+          x = @cursor_x + dx
+          @pixels[[x, y]] = color
+          @width = x + 1 if x + 1 > @width
+        end
+        @height = y + 1 if y + 1 > @height
+      end
+
+      @cursor_x += count
+      @width = @cursor_x if @cursor_x > @width
+    end
+
+    def parse_repeat(data, i)
+      len = data.bytesize
+      num_str = +""
+      while i < len && data.getbyte(i) >= 0x30 && data.getbyte(i) <= 0x39
+        num_str << data.getbyte(i).chr
+        i += 1
+      end
+      count = num_str.empty? ? 1 : num_str.to_i
+      ch = nil
+      if i < len
+        byte = data.getbyte(i)
+        ch = byte if byte >= 0x3F && byte <= 0x7E
+        i += 1
+      end
+      [i, count, ch]
+    end
+
+    def parse_raster_attributes(data, i)
+      values, i = parse_numeric_params(data, i)
+      [i, values[0] || 0, values[1] || 0, values[2] || 0, values[3] || 0]
+    end
+
+    def parse_color(data, i)
+      values, i = parse_numeric_params(data, i)
+
+      if values.size == 1
+        @current_color = values[0]
+      elsif values.size >= 5
+        pc, pu, px, py, pz = values
+        if pu == 1
+          @color_registers[pc] = hls_to_rgb(px, py, pz)
+        else
+          @color_registers[pc] = [
+            (px * 255 / 100.0).round.clamp(0, 255),
+            (py * 255 / 100.0).round.clamp(0, 255),
+            (pz * 255 / 100.0).round.clamp(0, 255),
+          ]
+        end
+        @current_color = pc
+      end
+      i
+    end
+
+    def parse_numeric_params(data, i)
+      values = []
+      num_str = +""
+      len = data.bytesize
+      while i < len
+        byte = data.getbyte(i)
+        if byte >= 0x30 && byte <= 0x39
+          num_str << byte.chr
+          i += 1
+        elsif byte == 0x3B
+          values << (num_str.empty? ? 0 : num_str.to_i)
+          num_str = +""
+          i += 1
+        else
+          values << (num_str.empty? ? 0 : num_str.to_i)
+          break
+        end
+      end
+      [values, i]
+    end
+
+    def hls_to_rgb(h, l, s)
+      hh = h / 360.0
+      ll = l / 100.0
+      ss = s / 100.0
+
+      if ss == 0
+        v = (ll * 255).round.clamp(0, 255)
+        return [v, v, v]
+      end
+
+      q = ll < 0.5 ? ll * (1.0 + ss) : ll + ss - ll * ss
+      p = 2.0 * ll - q
+
+      r = hue_to_rgb(p, q, hh + 1.0 / 3)
+      g = hue_to_rgb(p, q, hh)
+      b = hue_to_rgb(p, q, hh - 1.0 / 3)
+
+      [(r * 255).round.clamp(0, 255),
+       (g * 255).round.clamp(0, 255),
+       (b * 255).round.clamp(0, 255)]
+    end
+
+    def hue_to_rgb(p, q, t)
+      t += 1.0 if t < 0
+      t -= 1.0 if t > 1
+      return p + (q - p) * 6.0 * t if t < 1.0 / 6
+      return q if t < 1.0 / 2
+      return p + (q - p) * (2.0 / 3 - t) * 6.0 if t < 2.0 / 3
+
+      p
+    end
+  end
+end

data/lib/echoes/tab.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Echoes
+  class Tab
+    attr_reader :pane_tree
+    attr_accessor :title
+
+    def initialize(command:, rows:, cols:, cwd: nil, embedded: false, editor_file: nil)
+      @command = command
+      @rows = rows
+      @cols = cols
+      @embedded = embedded
+      pane = Pane.new(command: command, rows: rows, cols: cols, cwd: cwd,
+                      embedded: embedded, editor_file: editor_file)
+      @pane_tree = PaneTree.new(pane)
+      @title = pane.title
+    end
+
+    # --- Active pane delegation (backward compatibility) ---
+
+    def active_pane
+      @pane_tree.active_pane
+    end
+
+    def screen
+      active_pane.screen
+    end
+
+    def parser
+      active_pane.parser
+    end
+
+    def pty_read
+      active_pane.pty_read
+    end
+
+    def pty_write
+      active_pane.pty_write
+    end
+
+    def pty_pid
+      active_pane.pty_pid
+    end
+
+    def write_input(bytes)
+      active_pane.write_input(bytes)
+    end
+
+    def submit_line(line)
+      active_pane.submit_line(line)
+    end
+
+    def read_available_output(max = 16384)
+      active_pane.read_available_output(max)
+    end
+
+    def scroll_offset
+      active_pane.scroll_offset
+    end
+
+    def scroll_offset=(val)
+      active_pane.scroll_offset = val
+    end
+
+    def scroll_accum
+      active_pane.scroll_accum
+    end
+
+    def scroll_accum=(val)
+      active_pane.scroll_accum = val
+    end
+
+    # --- Pane operations ---
+
+    def split_vertical
+      new_pane = create_pane
+      layout = @pane_tree.layout(0, 0, @cols, @rows)
+      current_rect = layout.find { |r| r[:pane] == active_pane }
+      if current_rect
+        half_cols = current_rect[:w] / 2
+        active_pane.resize(current_rect[:h], half_cols)
+        new_pane.resize(current_rect[:h], current_rect[:w] - half_cols)
+      end
+      @pane_tree.split(active_pane, :vertical, new_pane)
+      new_pane
+    end
+
+    def split_horizontal
+      new_pane = create_pane
+      layout = @pane_tree.layout(0, 0, @cols, @rows)
+      current_rect = layout.find { |r| r[:pane] == active_pane }
+      if current_rect
+        half_rows = current_rect[:h] / 2
+        active_pane.resize(half_rows, current_rect[:w])
+        new_pane.resize(current_rect[:h] - half_rows, current_rect[:w])
+      end
+      @pane_tree.split(active_pane, :horizontal, new_pane)
+      new_pane
+    end
+
+    def close_active_pane
+      return false if @pane_tree.single_pane?
+
+      pane = active_pane
+      @pane_tree.remove(pane)
+      pane.close
+      resize_panes
+      true
+    end
+
+    def next_pane
+      @pane_tree.active_pane = @pane_tree.next_pane(active_pane)
+    end
+
+    def prev_pane
+      @pane_tree.active_pane = @pane_tree.prev_pane(active_pane)
+    end
+
+    def panes
+      @pane_tree.panes
+    end
+
+    # --- Lifecycle ---
+
+    def alive?
+      panes.any?(&:alive?)
+    end
+
+    def resize(rows, cols)
+      @rows = rows
+      @cols = cols
+      resize_panes
+    end
+
+    def close
+      panes.each(&:close)
+    end
+
+    private
+
+    def create_pane
+      Pane.new(command: @command, rows: @rows, cols: @cols)
+    end
+
+    def resize_panes
+      layout = @pane_tree.layout(0, 0, @cols, @rows)
+      layout.each do |rect|
+        rect[:pane].resize(rect[:h], rect[:w])
+      end
+    end
+  end
+end

data/lib/echoes/terminal.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'io/console'
+
+module Echoes
+  class Terminal
+    attr_reader :screen
+
+    def initialize(command: Echoes.config.shell, rows: nil, cols: nil)
+      size = IO.console&.winsize || [24, 80]
+      @rows = rows || size[0]
+      @cols = cols || size[1]
+      @command = command
+      @screen = Screen.new(rows: @rows, cols: @cols)
+      @parser = Parser.new(@screen, writer: ->(s) { @write_io&.write(s) rescue nil })
+    end
+
+    def run
+      PTY.spawn(@command) do |read_io, write_io, pid|
+        @read_io = read_io
+        @write_io = write_io
+        @pid = pid
+
+        @read_io.winsize = [@rows, @cols]
+
+        setup_signal_handlers
+
+        STDIN.raw do
+          reader = Thread.new { read_loop }
+          write_loop
+          reader.kill
+        end
+      end
+    end
+
+    private
+
+    def read_loop
+      loop do
+        data = @read_io.read_nonblock(4096)
+        @parser.feed(data)
+        render
+      rescue IO::WaitReadable
+        IO.select([@read_io])
+        retry
+      rescue EOFError, Errno::EIO
+        break
+      end
+    end
+
+    def write_loop
+      loop do
+        data = STDIN.read_nonblock(4096)
+        @write_io.write(data)
+      rescue IO::WaitReadable
+        IO.select([STDIN])
+        retry
+      rescue EOFError, Errno::EIO
+        break
+      end
+    end
+
+    def render
+      buf = +"\e[H"
+      last_fg = nil
+      last_bg = nil
+      last_bold = false
+      last_underline = false
+      last_inverse = false
+
+      @screen.grid.each_with_index do |row, r|
+        row.each do |cell|
+          if cell.fg != last_fg || cell.bg != last_bg || cell.bold != last_bold ||
+             cell.underline != last_underline || cell.inverse != last_inverse
+            codes = [0]
+            codes << 1 if cell.bold
+            codes << 2 if cell.faint
+            codes << 3 if cell.italic
+            codes << 4 if cell.underline
+            codes << 5 if cell.blink
+            codes << 7 if cell.inverse
+            codes << 8 if cell.concealed
+            codes << 9 if cell.strikethrough
+            if cell.fg.is_a?(Array)
+              codes.push(38, 2, *cell.fg)
+            elsif cell.fg
+              codes << (cell.fg < 8 ? cell.fg + 30 : cell.fg - 8 + 90)
+            end
+            if cell.bg.is_a?(Array)
+              codes.push(48, 2, *cell.bg)
+            elsif cell.bg
+              codes << (cell.bg < 8 ? cell.bg + 40 : cell.bg - 8 + 100)
+            end
+            buf << "\e[#{codes.join(';')}m"
+            last_fg = cell.fg
+            last_bg = cell.bg
+            last_bold = cell.bold
+            last_underline = cell.underline
+            last_inverse = cell.inverse
+          end
+          buf << cell.char
+        end
+        buf << "\r\n" unless r == @screen.rows - 1
+      end
+
+      buf << "\e[0m"
+      buf << "\e[#{@screen.cursor.row + 1};#{@screen.cursor.col + 1}H"
+      buf << (@screen.cursor.visible ? "\e[?25h" : "\e[?25l")
+      STDOUT.write(buf)
+    end
+
+    def setup_signal_handlers
+      Signal.trap(:WINCH) do
+        if IO.console
+          @rows, @cols = IO.console.winsize
+          @screen.resize(@rows, @cols)
+          @read_io.winsize = [@rows, @cols]
+          render
+        end
+      end
+    end
+  end
+end

data/lib/echoes/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Echoes
+  VERSION = "0.2.0"
+end

data/lib/echoes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# When invoked outside Bundler (e.g. from the .app launcher with bare
+# `ruby exe/echoes`), `require 'rubish'` and `require 'rvim'` would
+# pick up gem-installed copies that may lag the path-pinned source
+# in the Gemfile and lack methods echoes calls. Prepend the sibling
+# repo lib paths so the source versions win over Rubygems' default
+# activation. The Gemfile already encodes the same sibling assumption
+# via `path: "../rubish"` / `path: "../rvim"`, so this is just the
+# Bundler-less mirror of that.
+%w[rubish rvim].each do |sibling|
+  lib = File.expand_path("../../#{sibling}/lib", __dir__)
+  $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+end
+
+require_relative "echoes/version"
+require_relative "echoes/configuration"
+require_relative "echoes/cell"
+require_relative "echoes/cursor"
+require_relative "echoes/screen"
+require_relative "echoes/parser"
+require_relative "echoes/copy_mode"
+require_relative "echoes/pane"
+require_relative "echoes/pane_tree"
+require_relative "echoes/tab"
+require_relative "echoes/sixel_decoder"
+require_relative "echoes/terminal"
+require_relative "echoes/objc"
+require_relative "echoes/preferences"
+require_relative "echoes/client"
+require_relative "echoes/gui"
+
+module Echoes
+  class Error < StandardError; end
+end
+
+Echoes.load_config

data/sig/echoes.rbs

@@ -0,0 +1,4 @@
+module Echoes
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: echoes
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+  - Akira Matsuda
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+  - !ruby/object:Gem::Dependency
+    name: syslog
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :runtime
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+  - !ruby/object:Gem::Dependency
+    name: fiddle
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :runtime
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+description: |
+    Echoes is a pure-Ruby macOS terminal emulator with first-class
+    integrations for rubish (in-process shell) and rvim (in-process
+    vim editor) panes, plus a private OSC namespace for in-pane
+    Ruby tools that want to drive UI features (gradient backgrounds,
+    rectangular fills, proportional-font text) other terminals
+    can't. Written in pure Ruby on top of AppKit via Fiddle.
+email:
+  - ronnie@dio.jp
+executables:
+  - echoes
+extensions: []
+extra_rdoc_files: []
+files:
+  - CLAUDE.md
+  - Echoes.app/Contents/Info.plist
+  - Echoes.app/Contents/MacOS/Echoes
+  - EchoesEmbed.app/Contents/Info.plist
+  - EchoesEmbed.app/Contents/MacOS/EchoesEmbed
+  - LICENSE.txt
+  - README.md
+  - Rakefile
+  - exe/echoes
+  - lib/echoes.rb
+  - lib/echoes/cell.rb
+  - lib/echoes/client.rb
+  - lib/echoes/configuration.rb
+  - lib/echoes/copy_mode.rb
+  - lib/echoes/cursor.rb
+  - lib/echoes/editor.rb
+  - lib/echoes/embedded_shell.rb
+  - lib/echoes/embedded_shell_helper.rb
+  - lib/echoes/gui.rb
+  - lib/echoes/installer.rb
+  - lib/echoes/objc.rb
+  - lib/echoes/pane.rb
+  - lib/echoes/pane_tree.rb
+  - lib/echoes/parser.rb
+  - lib/echoes/preferences.rb
+  - lib/echoes/screen.rb
+  - lib/echoes/sixel_decoder.rb
+  - lib/echoes/tab.rb
+  - lib/echoes/terminal.rb
+  - lib/echoes/version.rb
+  - sig/echoes.rbs
+homepage: "https://github.com/amatsuda/echoes"
+licenses:
+  - MIT
+metadata:
+  homepage_uri: "https://github.com/amatsuda/echoes"
+  source_code_uri: "https://github.com/amatsuda/echoes"
+post_install_message: |
+    To launch Echoes from Spotlight / Dock / Cmd-Space, run:
+    
+        echoes install
+    
+    This drops thin Echoes.app and EchoesEmbed.app shortcuts in
+    ~/Applications/ that exec into the real gem-bundled launchers.
+    Re-run `echoes install` after each `gem update echoes` to refresh
+    the shortcuts; `echoes uninstall` removes them.
+rdoc_options: []
+require_paths:
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+requirements: []
+rubygems_version: 4.1.0.dev
+specification_version: 4
+summary: A pure-Ruby AppKit-based macOS terminal emulator.
+test_files: []