chamomile 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7fdcff186debc52d374ae2cfe20a1808100371609fbb39bdb1c21ad04e9c10bc
+  data.tar.gz: 0c48a5deba22e6be5696aa1f400f206efeb36d897b1c863a936656829ea9d7c2
+SHA512:
+  metadata.gz: db8d83c52ab888cd7f73025c00720211b175b1d2a0c89e8783a7e46b6609c6c2f7188a2e4a842130d996a3ae67a0896ee99e25b56f1d438333a54ef6b19a7261
+  data.tar.gz: 2486ca573415e2470e4e6248597a2110fe456f7c9e5ac6b30ea389f71d6480ff9787353158bd283a45ee722b3c6d5567e5259e3082ca7de9c7a0f8b8ad8621ea

data/lib/chamomile/commands.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "open3"
+
+module Chamomile
+  # Internal command types intercepted by Program (not delivered to model)
+  WindowTitleCmd       = Data.define(:title)
+  CursorPositionCmd    = Data.define(:row, :col)
+  CursorShapeCmd       = Data.define(:shape)
+  CursorVisibilityCmd  = Data.define(:visible)
+  ExecCmd              = Data.define(:command, :args, :callback)
+  PrintlnCmd           = Data.define(:text)
+
+  # Internal compound/control command types
+  CancelCmd  = Data.define(:token)
+  StreamCmd  = Data.define(:token, :producer)
+
+  # Typed envelope for shell command results
+  ShellResult = Data.define(:envelope, :stdout, :stderr, :status, :success)
+
+  # Typed envelope for timer ticks
+  TimerTick = Data.define(:envelope, :time)
+
+  # Runtime mode-toggle messages (returned as Cmd from update, intercepted by Program)
+  EnterAltScreenMsg     = Data.define
+  ExitAltScreenMsg      = Data.define
+  EnableMouseCellMotionMsg  = Data.define
+  EnableMouseAllMotionMsg   = Data.define
+  DisableMouseMsg = Data.define
+  EnableBracketedPasteMsg   = Data.define
+  DisableBracketedPasteMsg  = Data.define
+  EnableReportFocusMsg  = Data.define
+  DisableReportFocusMsg = Data.define
+  ClearScreenMsg        = Data.define
+  RequestWindowSizeMsg  = Data.define
+
+  # A cancel token for cancellable commands.
+  class CancelToken
+    def initialize
+      @cancelled = Concurrent::AtomicBoolean.new(false)
+    end
+
+    def cancel!
+      @cancelled.make_true
+    end
+
+    def cancelled?
+      @cancelled.true?
+    end
+  end
+
+  # Helper methods for creating command lambdas (quit, batch, tick, etc.).
+  module Commands
+    def quit
+      -> { QuitMsg.new }
+    end
+
+    def none
+      nil
+    end
+
+    def batch(*cmds)
+      valid = cmds.flatten.compact
+      return nil if valid.empty?
+
+      -> { valid }
+    end
+
+    def sequence(*cmds)
+      valid = cmds.flatten.compact
+      return nil if valid.empty?
+
+      -> { [:sequence, *valid] }
+    end
+
+    def tick(duration, &block)
+      -> {
+        sleep(duration)
+        block ? block.call : TickMsg.new(time: Time.now)
+      }
+    end
+
+    def every(duration, &block)
+      -> {
+        now = Time.now
+        next_tick = (now + duration) - (now.to_f % duration)
+        sleep(next_tick - Time.now)
+        block ? block.call : TickMsg.new(time: Time.now)
+      }
+    end
+
+    def cmd(callable)
+      -> { callable.call }
+    end
+
+    # Posts a message directly to the event queue — no thread, no async.
+    def deliver(msg)
+      -> { msg }
+    end
+
+    # Transforms a command's result before it reaches update.
+    def map(cmd, &transform)
+      return nil if cmd.nil?
+
+      -> {
+        result = cmd.call
+        result ? transform.call(result) : nil
+      }
+    end
+
+    # Creates a cancel token and returns [token, command_wrapper].
+    # The block receives the token for cooperative cancellation checking.
+    def cancellable(&block)
+      token = CancelToken.new
+      wrapped = -> {
+        return nil if token.cancelled?
+
+        block.call(token)
+      }
+      [token, wrapped]
+    end
+
+    # Returns a command that cancels a running token.
+    def cancel(token)
+      -> { CancelCmd.new(token: token) }
+    end
+
+    # A streaming command that emits multiple messages over time.
+    # The block receives a `push` callable and a `token` for cancellation.
+    # Returns [cancel_token, command].
+    def stream(&block)
+      token = CancelToken.new
+      cmd = -> {
+        return nil if token.cancelled?
+
+        StreamCmd.new(token: token, producer: block)
+      }
+      [token, cmd]
+    end
+
+    # Run a shell command and return a ShellResult message with the given envelope name.
+    def shell(command, envelope:, dir: Dir.pwd, env: {})
+      -> {
+        stdout, stderr, status = Open3.capture3(env, command, chdir: dir)
+        ShellResult.new(
+          envelope: envelope,
+          stdout: stdout.force_encoding("UTF-8"),
+          stderr: stderr.force_encoding("UTF-8"),
+          status: status.exitstatus,
+          success: status.success?
+        )
+      }
+    end
+
+    # Fire a timer message with a typed envelope.
+    def timer(duration, envelope:)
+      -> {
+        sleep(duration)
+        TimerTick.new(envelope: envelope, time: Time.now)
+      }
+    end
+
+    def window_title(title)
+      -> { WindowTitleCmd.new(title: title) }
+    end
+
+    def cursor_position(row, col)
+      -> { CursorPositionCmd.new(row: row, col: col) }
+    end
+
+    def cursor_shape(shape)
+      -> { CursorShapeCmd.new(shape: shape) }
+    end
+
+    def show_cursor
+      -> { CursorVisibilityCmd.new(visible: true) }
+    end
+
+    def hide_cursor
+      -> { CursorVisibilityCmd.new(visible: false) }
+    end
+
+    def exec(command, *args, &callback)
+      -> { ExecCmd.new(command: command, args: args, callback: callback) }
+    end
+
+    # Print a line above the rendered TUI area
+    def println(text)
+      -> { PrintlnCmd.new(text: text) }
+    end
+
+    # Runtime mode toggles — return these as commands from update
+    def enter_alt_screen
+      -> { EnterAltScreenMsg.new }
+    end
+
+    def exit_alt_screen
+      -> { ExitAltScreenMsg.new }
+    end
+
+    def enable_mouse_cell_motion
+      -> { EnableMouseCellMotionMsg.new }
+    end
+
+    def enable_mouse_all_motion
+      -> { EnableMouseAllMotionMsg.new }
+    end
+
+    def disable_mouse
+      -> { DisableMouseMsg.new }
+    end
+
+    def enable_bracketed_paste
+      -> { EnableBracketedPasteMsg.new }
+    end
+
+    def disable_bracketed_paste
+      -> { DisableBracketedPasteMsg.new }
+    end
+
+    def enable_report_focus
+      -> { EnableReportFocusMsg.new }
+    end
+
+    def disable_report_focus
+      -> { DisableReportFocusMsg.new }
+    end
+
+    def clear_screen
+      -> { ClearScreenMsg.new }
+    end
+
+    def request_window_size
+      -> { RequestWindowSizeMsg.new }
+    end
+
+    module_function :quit, :none, :batch, :sequence, :tick, :every, :cmd,
+                    :deliver, :map, :cancellable, :cancel, :stream,
+                    :shell, :timer,
+                    :window_title, :cursor_position, :cursor_shape,
+                    :show_cursor, :hide_cursor, :exec, :println,
+                    :enter_alt_screen, :exit_alt_screen,
+                    :enable_mouse_cell_motion, :enable_mouse_all_motion, :disable_mouse,
+                    :enable_bracketed_paste, :disable_bracketed_paste,
+                    :enable_report_focus, :disable_report_focus,
+                    :clear_screen, :request_window_size
+  end
+end

data/lib/chamomile/escape_parser.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+module Chamomile
+  # State-machine parser for ANSI escape sequences, CSI params, SGR mouse, and bracketed paste.
+  class EscapeParser
+    # States
+    GROUND   = :ground
+    ESC_SEEN = :esc_seen
+    CSI_ENTRY = :csi_entry
+    SS3      = :ss3
+    PASTE    = :paste
+
+    # CSI modifier mapping (xterm-style: param 2=Shift, 3=Alt, 4=Shift+Alt, 5=Ctrl, etc.)
+    MODIFIER_MAP = {
+      2 => [:shift],
+      3 => [:alt],
+      4 => %i[shift alt],
+      5 => [:ctrl],
+      6 => %i[ctrl shift],
+      7 => %i[ctrl alt],
+      8 => %i[ctrl shift alt],
+    }.freeze
+
+    PASTE_START = "\e[200~"
+    PASTE_END   = "\e[201~"
+
+    # Maximum paste buffer size (1MB) to prevent memory exhaustion
+    MAX_PASTE_SIZE = 1_048_576
+
+    def initialize
+      @state = GROUND
+      @buf = +""
+      @paste_buf = +""
+    end
+
+    # Feed raw bytes into the parser, yielding parsed messages.
+    def feed(bytes, &block)
+      bytes.each_char { |ch| process_char(ch, &block) }
+    end
+
+    # Call when IO.select times out — flushes ambiguous ESC as :escape key.
+    def timeout!
+      return unless @state == ESC_SEEN
+
+      @state = GROUND
+      @buf.clear
+      yield KeyMsg.new(key: :escape, mod: [])
+    end
+
+    private
+
+    def process_char(ch, &)
+      case @state
+      when GROUND
+        ground_char(ch, &)
+      when ESC_SEEN
+        esc_seen_char(ch, &)
+      when CSI_ENTRY
+        csi_char(ch, &)
+      when SS3
+        ss3_char(ch, &)
+      when PASTE
+        paste_char(ch, &)
+      end
+    end
+
+    def ground_char(ch)
+      case ch
+      when "\x00"
+        # NUL byte — ignore
+      when "\e"
+        @state = ESC_SEEN
+        @buf = +"\e"
+      when "\r", "\n"
+        yield KeyMsg.new(key: :enter, mod: [])
+      when "\t"
+        yield KeyMsg.new(key: :tab, mod: [])
+      when "\x7f", "\x08"
+        yield KeyMsg.new(key: :backspace, mod: [])
+      when ->(c) { c.ord.between?(1, 26) }
+        letter = (ch.ord + 96).chr # \x01 -> 'a', \x02 -> 'b', etc.
+        yield KeyMsg.new(key: letter, mod: [:ctrl])
+      when ->(c) { c.ord >= 32 }
+        yield KeyMsg.new(key: ch, mod: [])
+      end
+    end
+
+    def esc_seen_char(ch)
+      case ch
+      when "["
+        @state = CSI_ENTRY
+        @buf << ch
+      when "O"
+        @state = SS3
+        @buf << ch
+      when "\e"
+        # Another ESC: flush previous ESC as :escape, start new ESC
+        yield KeyMsg.new(key: :escape, mod: [])
+        @buf = +"\e"
+        # Stay in ESC_SEEN
+      else
+        # Alt + char: ESC followed by a printable character
+        @state = GROUND
+        @buf.clear
+        if ["\x7f", "\x08"].include?(ch)
+          yield KeyMsg.new(key: :backspace, mod: [:alt])
+        elsif ch.ord >= 32
+          yield KeyMsg.new(key: ch, mod: [:alt])
+        elsif ["\r", "\n"].include?(ch)
+          yield KeyMsg.new(key: :enter, mod: [:alt])
+        elsif ch == "\t"
+          yield KeyMsg.new(key: :tab, mod: [:alt])
+        elsif ch.ord.between?(1, 26)
+          letter = (ch.ord + 96).chr
+          yield KeyMsg.new(key: letter, mod: %i[alt ctrl])
+        end
+      end
+    end
+
+    def csi_char(ch, &)
+      @buf << ch
+
+      case ch
+      when "0".."9", ";", ":"
+        # Still collecting parameters; stay in CSI_ENTRY
+        return
+      when "<"
+        # SGR mouse prefix — stay collecting
+        return if @buf == "\e[<"
+
+        # Already past the <, this is a parameter char
+        return
+      end
+
+      # We have a final character — dispatch
+      @state = GROUND
+      seq = @buf.dup
+      @buf.clear
+
+      dispatch_csi(seq, &)
+    end
+
+    def ss3_char(ch)
+      @buf << ch
+      @state = GROUND
+      seq = @buf.dup
+      @buf.clear
+
+      case ch
+      when "P" then yield KeyMsg.new(key: :f1, mod: [])
+      when "Q" then yield KeyMsg.new(key: :f2, mod: [])
+      when "R" then yield KeyMsg.new(key: :f3, mod: [])
+      when "S" then yield KeyMsg.new(key: :f4, mod: [])
+      when "A" then yield KeyMsg.new(key: :up, mod: [])
+      when "B" then yield KeyMsg.new(key: :down, mod: [])
+      when "C" then yield KeyMsg.new(key: :right, mod: [])
+      when "D" then yield KeyMsg.new(key: :left, mod: [])
+      when "H" then yield KeyMsg.new(key: :home, mod: [])
+      when "F" then yield KeyMsg.new(key: :end_key, mod: [])
+      else
+        yield KeyMsg.new(key: seq, mod: [:unknown])
+      end
+    end
+
+    def dispatch_csi(seq, &)
+      # Check for bracketed paste start/end
+      if seq == PASTE_START
+        @state = PASTE
+        @paste_buf.clear
+        return
+      end
+
+      if seq == PASTE_END
+        # Shouldn't happen in CSI (we'd be in PASTE state), but handle gracefully
+        yield PasteMsg.new(content: @paste_buf.dup)
+        @paste_buf.clear
+        return
+      end
+
+      # Focus/Blur: \e[I (focus) and \e[O (blur)
+      if seq == "\e[I"
+        yield FocusMsg.new
+        return
+      end
+      if seq == "\e[O"
+        yield BlurMsg.new
+        return
+      end
+
+      # SGR mouse: \e[<Cb;Cx;CyM or \e[<Cb;Cx;Cym
+      if seq.start_with?("\e[<") && (seq.end_with?("M") || seq.end_with?("m"))
+        dispatch_sgr_mouse(seq, &)
+        return
+      end
+
+      # Parse CSI parameters: \e[ params final
+      body = seq[2..] # strip "\e["
+      final = body[-1]
+      params_str = body[0..-2]
+
+      # Split params by ";"
+      params = params_str.split(";").map { |p| p.empty? ? 1 : p.to_i }
+
+      case final
+      when "A" then yield key_with_modifiers(:up, params)
+      when "B" then yield key_with_modifiers(:down, params)
+      when "C" then yield key_with_modifiers(:right, params)
+      when "D" then yield key_with_modifiers(:left, params)
+      when "H" then yield key_with_modifiers(:home, params)
+      when "F" then yield key_with_modifiers(:end_key, params)
+      when "Z" then yield KeyMsg.new(key: :tab, mod: [:shift]) # Shift+Tab
+      when "~"
+        dispatch_tilde(params, &)
+      else
+        yield KeyMsg.new(key: seq, mod: [:unknown])
+      end
+    end
+
+    def dispatch_tilde(params)
+      key_code = params[0]
+      mod = extract_modifiers(params[1]) if params.length > 1
+
+      key = case key_code
+            when 1  then :home
+            when 2  then :insert
+            when 3  then :delete
+            when 4  then :end_key
+            when 5  then :page_up
+            when 6  then :page_down
+            when 15 then :f5
+            when 17 then :f6
+            when 18 then :f7
+            when 19 then :f8
+            when 20 then :f9
+            when 21 then :f10
+            when 23 then :f11
+            when 24 then :f12
+            when 200
+              @state = PASTE
+              @paste_buf.clear
+              return
+            when 201
+              yield PasteMsg.new(content: @paste_buf.dup)
+              @paste_buf.clear
+              return
+            else
+              return yield KeyMsg.new(key: "\e[#{params.join(";")}~", mod: [:unknown])
+            end
+
+      yield KeyMsg.new(key: key, mod: mod || [])
+    end
+
+    def dispatch_sgr_mouse(seq)
+      # Format: \e[<Cb;Cx;CyM (press) or \e[<Cb;Cx;Cym (release)
+      pressed = seq.end_with?("M")
+      body = seq[3..-2] # strip "\e[<" and final char
+      parts = body.split(";")
+      return if parts.length < 3
+
+      cb = parts[0].to_i
+      cx = parts[1].to_i
+      cy = parts[2].to_i
+
+      # Extract modifiers from button code
+      mod = []
+      mod << :shift if cb.anybits?(4)
+      mod << :alt   if cb.anybits?(8)
+      mod << :ctrl  if cb.anybits?(16)
+
+      # Extract button and action
+      base = cb & 3
+      motion = cb.anybits?(32)
+      wheel = cb.anybits?(64)
+
+      if wheel
+        button = base.zero? ? MOUSE_WHEEL_UP : MOUSE_WHEEL_DOWN
+        action = MOUSE_PRESS
+      elsif motion
+        button = resolve_button(base)
+        action = MOUSE_MOTION
+      else
+        button = resolve_button(base)
+        action = pressed ? MOUSE_PRESS : MOUSE_RELEASE
+      end
+
+      yield MouseMsg.new(x: cx, y: cy, button: button, action: action, mod: mod)
+    end
+
+    def paste_char(ch)
+      @paste_buf << ch
+
+      # Check if paste buffer ends with the paste-end sequence
+      if @paste_buf.end_with?(PASTE_END)
+        content = @paste_buf[0..-(PASTE_END.length + 1)]
+        @paste_buf.clear
+        @state = GROUND
+        yield PasteMsg.new(content: content)
+      elsif @paste_buf.bytesize > MAX_PASTE_SIZE
+        # Prevent memory exhaustion — flush what we have and reset
+        content = @paste_buf.dup
+        @paste_buf.clear
+        @state = GROUND
+        yield PasteMsg.new(content: content)
+      end
+    end
+
+    def resolve_button(base)
+      case base
+      when 0 then MOUSE_LEFT
+      when 1 then MOUSE_MIDDLE
+      when 2 then MOUSE_RIGHT
+      else MOUSE_NONE
+      end
+    end
+
+    def key_with_modifiers(key, params)
+      if params.length >= 2
+        mod = extract_modifiers(params[1])
+        KeyMsg.new(key: key, mod: mod)
+      else
+        KeyMsg.new(key: key, mod: [])
+      end
+    end
+
+    def extract_modifiers(code)
+      MODIFIER_MAP[code] || []
+    end
+  end
+end

data/lib/chamomile/input_reader.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Chamomile
+  # Background thread that reads stdin and feeds bytes through EscapeParser.
+  class InputReader
+    def initialize(queue, input: $stdin)
+      @queue   = queue
+      @input   = input
+      @thread  = nil
+      @running = false
+      @parser  = EscapeParser.new
+    end
+
+    def start
+      return @thread if @running
+
+      @running = true
+      @thread = Thread.new { read_loop }
+      @thread.abort_on_exception = false
+      @thread
+    end
+
+    def stop
+      @running = false
+      return unless @thread
+
+      @thread.join(1)
+      @thread = nil
+    end
+
+    def running?
+      @running
+    end
+
+    private
+
+    def read_loop
+      while @running
+        begin
+          if @input.wait_readable(0.05)
+            bytes = @input.read_nonblock(256)
+            next if bytes.nil? || bytes.empty?
+
+            @parser.feed(bytes) { |msg| @queue.push(msg) }
+          else
+            @parser.timeout! { |msg| @queue.push(msg) }
+          end
+        rescue IO::WaitReadable
+          # Transient — retry on next iteration
+        rescue EOFError, Errno::EIO
+          @queue.push(QuitMsg.new)
+          break
+        rescue StandardError => e
+          Chamomile.log("InputReader error: #{e.class}: #{e.message}", level: :warn)
+        end
+      end
+    end
+  end
+end