echoes 0.2.0

data/lib/echoes/editor.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'reline'
+
+module Echoes
+  # Vim-equivalent editor pane backed by `Rvim::Editor`. Editing,
+  # `:w` (write), `:q` (quit), search, visual mode, undo/redo and
+  # the rest of rvim's surface all work — this class is the
+  # rendering shim that turns rvim's editor state into the styled
+  # segments echoes' Screen wants. The bottom row is reserved for
+  # the statusline (mode / filename / modified marker / line:col)
+  # or, when in command/search mode, for the cmdline (`:`, `/`,
+  # or `?` prompt with the typed text and cursor).
+  class Editor
+    # rvim's syntax highlighter labels each token with a vim-style
+    # color symbol (`:Comment`, `:String`, …). Map to ANSI palette
+    # indices that this Screen's Cell.fg uses.
+    COLOR_MAP = {
+      Comment:    8,    # bright black / grey
+      String:     2,    # green
+      Keyword:    5,    # magenta
+      Symbol:     3,    # yellow
+      Number:     3,    # yellow
+      Constant:   6,    # cyan
+      Function:   4,    # blue
+      Type:       6,    # cyan
+      Special:    3,    # yellow
+      PreProc:    5,    # magenta
+      Operator:  14,    # bright cyan
+      Identifier: 7,    # white
+    }.freeze
+
+    DEFAULT_SEGMENT = {
+      fg: nil, bg: nil,
+      bold: false, italic: false, underline: false, inverse: false,
+    }.freeze
+
+    attr_reader :file
+
+    def initialize(file:, rows:, cols:)
+      require 'rvim'
+      @editor = Rvim::Editor.new(Reline.core.config)
+      @rows = rows
+      @cols = cols
+      @file = file
+      resize(rows: rows, cols: cols)
+      @editor.open(file) if file && File.exist?(file)
+      @lang = @file ? Rvim::Syntax.detect_language(@file) : nil
+    end
+
+    # Match rvim's window dimensions to the host pane's. Called on
+    # construction and on later `Pane#resize`.
+    def resize(rows:, cols:)
+      @rows = rows
+      @cols = cols
+      win = @editor.current_window
+      return unless win
+      win.height = rows
+      win.width  = cols
+    end
+
+    # Forward a single character (or escape sequence) to the editor.
+    # Accepts Strings like 'j', 'G', "\x04" (Ctrl-D), or "\e[A". Maps
+    # macOS NSEvent special-key codepoints to vim equivalents so the
+    # arrow keys "just work" in viewer mode.
+    SPECIAL_KEY_MAP = {
+      "\u{F700}" => 'k',  # Up
+      "\u{F701}" => 'j',  # Down
+      "\u{F702}" => 'h',  # Left
+      "\u{F703}" => 'l',  # Right
+      "\u{F72C}" => "\x02",  # PageUp → Ctrl-B
+      "\u{F72D}" => "\x06",  # PageDown → Ctrl-F
+      "\u{F729}" => 'g',  # Home (caller may follow with another 'g')
+      "\u{F72B}" => 'G',  # End
+    }.freeze
+
+    def feed_key(ch)
+      mapped = SPECIAL_KEY_MAP[ch] || ch
+      mapped.each_char { |c| @editor.send(:dispatch_synthesized_key, c) }
+      true
+    rescue
+      false
+    end
+
+    # Visible window's lines as Arrays of styled-segment Hashes
+    # (`{text:, fg:, bg:, bold:, italic:, underline:, inverse:}`),
+    # one Array per visible row. The last row is the statusline (or
+    # cmdline, in `:`/`/`/`?` modes); the rows above are buffer text
+    # padded with vim-style `~` markers when shorter than the pane.
+    def visible_segments
+      win = @editor.current_window
+      lines = @editor.current_buffer&.lines || []
+      top = win&.scroll_top || 0
+      body_rows = [@rows - 1, 1].max  # reserve last row for status/cmdline
+      slice = lines[top, body_rows] || []
+      out = slice.map { |line| line_to_segments(line) }
+      while out.size < body_rows
+        out << [DEFAULT_SEGMENT.merge(text: '~', fg: 4)]
+      end
+      out << bottom_row_segments
+      out
+    end
+
+    # (row, col) of the cursor within the viewport. In cmdline modes
+    # (:ex / :search_*) the cursor sits on the bottom row at the end
+    # of the cmdline text; otherwise it tracks the editor cursor in
+    # the buffer body.
+    def cursor_position
+      if cmdline_mode?
+        text = cmdline_text
+        [@rows - 1, text.length.clamp(0, @cols - 1)]
+      else
+        win = @editor.current_window
+        top = win&.scroll_top || 0
+        row = (@editor.line_index || 0) - top
+        col = @editor.byte_pointer || 0
+        body_max = [@rows - 2, 0].max
+        [row.clamp(0, body_max), col.clamp(0, @cols - 1)]
+      end
+    end
+
+    # rvim sets `quit` after `:q` / `:q!` / `:wq`. The host polls this
+    # via `Pane#alive?` and reaps the pane like it would a dead shell.
+    def closed?
+      @editor.quit?
+    end
+
+    # Short label for the current vim mode (used in the statusline
+    # and exposed for window-title / future status-bar plumbing).
+    def mode_label
+      return :cmdline if cmdline_mode?
+      return :visual  if @editor.visual_mode
+      return :insert  if @editor.send(:editing_mode_label) == :vi_insert
+      :normal
+    end
+
+    # Filename for the window title; appends `[+]` while the buffer
+    # has unsaved changes (vim convention). Returns `'[No Name]'` for
+    # buffers opened with no path (e.g. `:enew`).
+    def display_filename
+      base = @file && !@file.empty? ? File.basename(@file) : '[No Name]'
+      @editor.modified ? "#{base} [+]" : base
+    end
+
+    private
+
+    def cmdline_mode?
+      [:ex, :search_forward, :search_backward].include?(@editor.prompt_mode)
+    end
+
+    # The text the user sees on the bottom row when in cmdline mode:
+    # the leader char (`:`, `/`, `?`) followed by what they've typed.
+    def cmdline_text
+      leader =
+        case @editor.prompt_mode
+        when :search_forward  then '/'
+        when :search_backward then '?'
+        else                       ':'
+        end
+      "#{leader}#{@editor.prompt_buffer}"
+    end
+
+    # One row of segments for the bottom of the pane. Either the
+    # cmdline (in :ex/search mode) or the inverse-video statusline.
+    def bottom_row_segments
+      if cmdline_mode?
+        text = cmdline_text
+        [DEFAULT_SEGMENT.merge(text: text.byteslice(0, @cols).to_s)]
+      else
+        statusline_segments
+      end
+    end
+
+    # Inverse-video statusline: "MODE  filename [+]   <padding>   line:col".
+    # `status_message` (if rvim has one — e.g. ':"…" written') wins
+    # over the mode label so saves and errors are visible.
+    def statusline_segments
+      status = @editor.status_message
+      left =
+        if status && !status.empty?
+          status.to_s
+        else
+          mode = mode_label_text
+          fname = display_filename
+          mode.empty? ? fname : "#{mode}  #{fname}"
+        end
+      lineno = (@editor.line_index || 0) + 1
+      col    = (@editor.byte_pointer || 0) + 1
+      right  = "#{lineno}:#{col}"
+
+      max = @cols
+      pad = max - left.length - right.length
+      pad = 1 if pad < 1
+      text = "#{left}#{' ' * pad}#{right}"
+      text = text.byteslice(0, max).to_s
+
+      [DEFAULT_SEGMENT.merge(text: text, inverse: true)]
+    end
+
+    def mode_label_text
+      case mode_label
+      when :insert then '-- INSERT --'
+      when :visual then '-- VISUAL --'
+      else              ''
+      end
+    end
+
+    def line_to_segments(line)
+      return [DEFAULT_SEGMENT.merge(text: '')] if line.nil? || line.empty?
+      spans = (@lang ? Rvim::Syntax.highlight(line, @lang) : []).sort_by { |s, _e, _c| s }
+      result = []
+      pos = 0
+      spans.each do |start, last, color_sym|
+        if start > pos
+          result << DEFAULT_SEGMENT.merge(text: line.byteslice(pos, start - pos).to_s)
+        end
+        text = line.byteslice(start, last - start + 1).to_s
+        result << DEFAULT_SEGMENT.merge(text: text, fg: COLOR_MAP[color_sym])
+        pos = last + 1
+      end
+      result << DEFAULT_SEGMENT.merge(text: line.byteslice(pos..).to_s) if pos < line.bytesize
+      result.empty? ? [DEFAULT_SEGMENT.merge(text: line)] : result
+    end
+  end
+end

data/lib/echoes/embedded_shell.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'io/console'
+require 'json'
+require 'securerandom'
+
+module Echoes
+  # Drives a per-pane subprocess (`embedded_shell_helper.rb`) that owns
+  # the pty as its controlling tty and runs a `Rubish::REPL` in its own
+  # session. Every external command rubish forks inherits the helper's
+  # session/ctty, so Ctrl-C (ETX → SIGINT) works for any execution
+  # shape — single command, pipeline, loop, sequence, conditional.
+  #
+  # The helper communicates with this class over a JSON-line control
+  # pipe. Standard rubish output (prompts, command stdout/stderr) flows
+  # through the pty in the usual way. The control pipe carries:
+  #
+  #   - synchronous queries: complete_at, prompt, prompt_segments,
+  #     try_parse, tokenize, history, last_status, cwd, …
+  #   - async events from helper to host: command_done, …
+  #
+  # API surface is identical to the previous in-process version so
+  # callers (Pane, etc.) don't need to change.
+  class EmbeddedShell
+    HELPER_SCRIPT = File.expand_path('embedded_shell_helper.rb', __dir__)
+    DEFAULT_SYNC_TIMEOUT = 5.0
+    # Mirror of EmbeddedShellHelper::DONE_SENTINEL — the helper writes
+    # this OSC sequence to the pty after a command's last output bytes
+    # are flushed but before it sends the command_done event on the
+    # control pipe. The pty reader scans for it and strips it; the
+    # presence of the sentinel + the event together is what
+    # `reap_if_done` waits for.
+    DONE_SENTINEL = "\e]7771\a"
+
+    # `no_rc:` skips rubish's startup-file loading (~/.rubishrc, /etc/bashrc,
+    # …) and history file restore in the helper. Tests pass true so the
+    # subprocess starts from a known-clean environment; production
+    # callers leave it false so the user's config takes effect.
+    def initialize(no_rc: false)
+      ENV['GIT_PAGER'] ||= 'cat'
+      ENV['PAGER']     ||= 'cat'
+
+      helper_env = {'ECHOES_HELPER_NO_RC' => no_rc ? '1' : nil}
+      @master, slave = PTY.open
+      # Bidirectional JSON-line control pipes. Helper reads requests on
+      # fd 3 and writes responses/events on fd 4.
+      ctl_in_r,  ctl_in_w  = IO.pipe   # parent → helper
+      ctl_out_r, ctl_out_w = IO.pipe   # helper → parent
+      @control_write = ctl_in_w
+      @control_read  = ctl_out_r
+      @control_write.sync = true
+
+      @output_buffer  = +''
+      @output_lock    = Mutex.new
+      @pending_lock   = Mutex.new
+      @pending        = {}            # id → Queue
+      @running        = false
+      @last_status    = 0
+      @last_cwd       = Dir.pwd
+
+      load_paths = $LOAD_PATH.flat_map { |p| ['-I', p] }
+      @helper_pid = Process.spawn(
+        helper_env, RbConfig.ruby, *load_paths, HELPER_SCRIPT,
+        in: slave, out: slave, err: slave,
+        3 => ctl_in_r, 4 => ctl_out_w,
+        close_others: true,
+      )
+      slave.close
+      ctl_in_r.close
+      ctl_out_w.close
+
+      @sentinel_seen = false
+      @reader = Thread.new(@master) do |m|
+        # Accumulator handles a sentinel that straddles two chunks.
+        # After splitting on any complete sentinels, hold back ONLY the
+        # bytes at the tail of `acc` that match a prefix of the sentinel
+        # — anything else is safe to flush right away. Holding back
+        # blindly (e.g. always the last N-1 bytes) corrupts the host's
+        # parser when a long OSC sequence happens to end inside that
+        # window: the trailing bytes get released much later, by which
+        # time the parser has moved on and renders them as text.
+        acc = +''
+        begin
+          loop do
+            chunk = m.readpartial(4096)
+            acc << chunk
+            while (idx = acc.index(DONE_SENTINEL))
+              before = acc[0...idx]
+              @output_lock.synchronize { @output_buffer << before } unless before.empty?
+              acc = acc[(idx + DONE_SENTINEL.bytesize)..] || +''
+              @sentinel_seen = true
+            end
+            keep = pending_sentinel_prefix_len(acc)
+            if acc.bytesize > keep
+              flush_n = acc.bytesize - keep
+              @output_lock.synchronize { @output_buffer << acc.byteslice(0, flush_n) }
+              acc = acc.byteslice(flush_n, acc.bytesize - flush_n) || +''
+            end
+          end
+        rescue EOFError, IOError, Errno::EIO
+          # helper exited or was killed
+        end
+        @output_lock.synchronize { @output_buffer << acc } unless acc.empty?
+      end
+
+      @control_reader = Thread.new(@control_read) do |io|
+        begin
+          while (line = io.gets)
+            handle_control_line(line)
+          end
+        rescue IOError, Errno::EIO
+          # helper exited
+        end
+      end
+    end
+
+    # Submit a complete line of input. Returns immediately; output flows
+    # through the pty asynchronously and `command_done` will set
+    # @running back to false. The line is added to history (rubish-side)
+    # by the helper before execution.
+    def submit_line(line, rows: 24, cols: 80)
+      return if running?
+      @master.winsize = [rows, cols] rescue nil
+      @running = true
+      rpc_async('execute', line: line)
+    end
+
+    # Synchronous wrapper for scripts and tests that don't have a
+    # dispatch loop. Submits and blocks until the command completes
+    # (or `timeout` seconds pass — in which case ETX is sent).
+    def submit_and_wait(line, rows: 24, cols: 80, timeout: 30)
+      submit_line(line, rows: rows, cols: cols)
+      deadline = Time.now + timeout
+      while running?
+        if Time.now > deadline
+          interrupt
+          break
+        end
+        sleep 0.01
+      end
+      reap_if_done
+      nil
+    end
+
+    def running?
+      @running
+    end
+
+    # True until the helper subprocess has terminated (e.g. user typed
+    # `exit`). Reaps with WNOHANG so the call is non-blocking; once we
+    # observe the death we cache it so subsequent calls don't ECHILD on
+    # an already-reaped pid.
+    def alive?
+      return false if @helper_dead
+      return true unless @helper_pid
+      pid, _ = Process.waitpid2(@helper_pid, Process::WNOHANG)
+      if pid
+        @helper_dead = true
+        return false
+      end
+      true
+    rescue Errno::ECHILD
+      @helper_dead = true
+      false
+    end
+
+    # Drain any output bytes the pty reader has buffered. Empty String
+    # if none. Never blocks.
+    def read_available_output
+      @output_lock.synchronize do
+        data = @output_buffer.dup
+        @output_buffer.clear
+        data
+      end
+    end
+
+    # Write keystrokes to the pty master. The kernel's line discipline
+    # routes them to whatever is reading on the slave (the running
+    # command's stdin).
+    def forward_input(bytes)
+      @master.write(bytes)
+    rescue IOError, Errno::EIO, Errno::EPIPE
+    end
+
+    # ETX. The line discipline converts to SIGINT delivered to the
+    # foreground process group of the slave's controlling session —
+    # which is the helper's session, so any rubish-forked child
+    # receives it.
+    def interrupt
+      @master.write("\x03") rescue nil
+    end
+
+    # Updates the pty master's winsize. The kernel propagates to the
+    # slave (which is the helper's ctty) and emits SIGWINCH to the
+    # foreground process group, so vim/less/etc. repaint.
+    def resize(rows:, cols:)
+      @master.winsize = [rows, cols]
+    rescue IOError, Errno::EIO
+    end
+
+    # Compatibility method the host calls each tick. With the helper
+    # architecture the pty/ctty live for the pane's lifetime, but the
+    # host still needs a one-shot "command finished" signal so it can
+    # emit the next prompt. Returns true on the tick where BOTH the
+    # control_out command_done event has arrived AND the pty sentinel
+    # has been observed by the reader thread (so the caller's next
+    # `read_available_output` is guaranteed to have drained the
+    # command's last bytes).
+    def reap_if_done
+      return false unless @done_pending && @sentinel_seen
+      @done_pending = false
+      @sentinel_seen = false
+      true
+    end
+
+    # ---- queries to the helper (synchronous) ----
+
+    def complete_at(line:, point:)
+      rpc_sync('complete', line: line, point: point) || []
+    end
+
+    def prompt
+      rpc_sync('prompt') || ''
+    end
+
+    def prompt_segments
+      (rpc_sync('prompt_segments') || []).map { |s| symbolize_segment(s) }
+    end
+
+    # Right-aligned prompt (rubish's RPROMPT). Returns an Array of
+    # segments — possibly empty — same shape as `prompt_segments`.
+    def right_prompt_segments
+      (rpc_sync('right_prompt_segments') || []).map { |s| symbolize_segment(s) }
+    end
+
+    def continuation_prompt
+      rpc_sync('continuation_prompt') || '> '
+    end
+
+    def try_parse(line)
+      (rpc_sync('try_parse', line: line) || 'error').to_sym
+    end
+
+    def tokenize(line)
+      (rpc_sync('tokenize', line: line) || []).map { |t| TokenView.new(t['type'].to_sym, t['value']) }
+    end
+
+    def history
+      rpc_sync('history') || []
+    end
+
+    def last_status
+      @last_status
+    end
+
+    def cwd
+      # Cached from command_done events; only refresh on demand if
+      # nothing has been run yet.
+      @last_cwd ||= rpc_sync('cwd')
+      @last_cwd
+    end
+
+    # Returns when the helper has exited and pipes are closed. For
+    # tests / shutdown.
+    def shutdown
+      rpc_async('shutdown') rescue nil
+      Process.waitpid(@helper_pid) rescue nil
+      @master.close rescue nil
+      @control_write.close rescue nil
+      @control_read.close rescue nil
+      @reader.join(1) rescue nil
+      @control_reader.join(1) rescue nil
+    end
+
+    private
+
+    # Mirror of Rubish::Lexer::Token's small interface (type/value)
+    # over a value object so colorize_input doesn't need to know it
+    # came across a pipe.
+    TokenView = Struct.new(:type, :value)
+
+    # Longest tail of `acc` that's also a prefix of DONE_SENTINEL —
+    # i.e. how many bytes might be the start of a sentinel that
+    # crosses into the next pty chunk. 0 if the tail can't possibly
+    # be a sentinel prefix, so the whole acc is safe to flush.
+    def pending_sentinel_prefix_len(acc)
+      max = [DONE_SENTINEL.bytesize - 1, acc.bytesize].min
+      max.downto(1) do |n|
+        return n if DONE_SENTINEL.byteslice(0, n) == acc.byteslice(-n, n)
+      end
+      0
+    end
+
+    def handle_control_line(line)
+      msg = JSON.parse(line) rescue nil
+      return unless msg
+      if msg.key?('event')
+        handle_event(msg)
+      elsif (id = msg['id'])
+        queue = @pending_lock.synchronize { @pending.delete(id) }
+        queue&.push(msg['result'])
+      end
+    end
+
+    def handle_event(msg)
+      case msg['event']
+      when 'command_done'
+        @last_status = msg['exit_status'].to_i
+        @last_cwd    = msg['cwd'] if msg['cwd']
+        @done_pending = true
+        @running = false
+      end
+    end
+
+    def rpc_async(op, **args)
+      send_request(op, **args)
+    end
+
+    def rpc_sync(op, **args)
+      id = SecureRandom.uuid
+      queue = Queue.new
+      @pending_lock.synchronize { @pending[id] = queue }
+      send_request(op, id: id, **args)
+      result = queue.pop_with_timeout(DEFAULT_SYNC_TIMEOUT) if queue.respond_to?(:pop_with_timeout)
+      result = wait_with_timeout(queue, DEFAULT_SYNC_TIMEOUT) if result.nil?
+      result
+    rescue Errno::EPIPE, IOError
+      nil
+    end
+
+    def wait_with_timeout(queue, timeout)
+      deadline = Time.now + timeout
+      until queue.closed? || queue.size > 0
+        return nil if Time.now > deadline
+        sleep 0.005
+      end
+      queue.pop
+    end
+
+    def send_request(op, **args)
+      payload = {'op' => op}
+      args.each { |k, v| payload[k.to_s] = v }
+      @control_write.puts JSON.generate(payload)
+    rescue Errno::EPIPE, IOError
+    end
+
+    def symbolize_segment(s)
+      {
+        text:      s['text'],
+        fg:        s['fg'],
+        bg:        s['bg'],
+        bold:      s['bold'],
+        italic:    s['italic'],
+        underline: s['underline'],
+        inverse:   s['inverse'],
+      }
+    end
+  end
+end