chamomile-petals 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b58fb0aca2d20714534fbcead2c327b4f86525e603d1cfe8d337c516d015e71b
+  data.tar.gz: 9f771b13bcbc31849040cb2da89701698b0e7f0359431633850128956a03b718
+SHA512:
+  metadata.gz: 59e1f8a164b9e7746bc28587d42cced08b29343e539b5418cbc79d46cacb3b9e3fdb9eee485f473aeafedbad2b7d99d2ef5363c77b2da73bf3385aebc9827e6e
+  data.tar.gz: c648d68002cfa44c7f5f3dfccb9fd0b5fce1c0eaa2d78f8c1d20be3634734950b864688af9a22243c14ec9177bf0b8ee006b0847898897efffec419da296f1e3

data/lib/petals/command_palette.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Petals
+  # A fuzzy-search command palette overlay.
+  # Renders as a centered modal over existing content.
+  #
+  # Usage:
+  #   @palette = Petals::CommandPalette.new(
+  #     items: [
+  #       { label: "Run migrations", action: :run_migrate, key: "db:migrate" },
+  #       { label: "Start server", action: :server_start, key: "server" },
+  #     ]
+  #   )
+  #   # In update:
+  #   when KeyMsg
+  #     if @palette.visible?
+  #       result = @palette.handle_key(msg)
+  #       return result[:action] if result
+  #     end
+  class CommandPalette
+    Item = Data.define(:label, :action, :key)
+
+    attr_reader :query, :cursor
+
+    def initialize(items:, placeholder: "Type to filter...")
+      @all_items   = items.map { |i| Item.new(**i) }
+      @placeholder = placeholder
+      @query       = ""
+      @cursor      = 0
+      @visible     = false
+    end
+
+    def show
+      @visible = true
+      @query   = ""
+      @cursor  = 0
+    end
+
+    def hide
+      @visible = false
+    end
+
+    def visible? = @visible
+
+    def handle_key(msg)
+      return nil unless @visible
+
+      case msg.key
+      when :escape
+        hide
+        nil
+      when :enter
+        selected = filtered_items[@cursor]
+        hide
+        selected
+      when :up, "k"
+        @cursor = [@cursor - 1, 0].max
+        nil
+      when :down, "j"
+        max = filtered_items.size - 1
+        @cursor = (@cursor + 1).clamp(0, [max, 0].max)
+        nil
+      when :backspace
+        @query = @query[0..-2] || ""
+        @cursor = 0
+        nil
+      else
+        if msg.key.is_a?(String) && msg.key.length == 1
+          @query += msg.key
+          @cursor = 0
+        end
+        nil
+      end
+    end
+
+    def render(width:, height:)
+      return "" unless @visible
+
+      items = filtered_items
+      modal_width  = [width - 8, 60].min
+      modal_height = [items.size + 4, height - 4, 16].min
+
+      lines = []
+      query_display = @query.empty? ? "\e[38;5;240m#{@placeholder}\e[0m" : @query
+      lines << "  > #{query_display}"
+      lines << ("\u2500" * (modal_width - 2))
+
+      visible_items = items.first(modal_height - 4)
+      visible_items.each_with_index do |item, i|
+        prefix = i == @cursor ? "\u25b6 " : "  "
+        line   = "#{prefix}#{item.label}"
+        lines << (i == @cursor ? "\e[7m#{line}\e[0m" : line)
+      end
+
+      lines << ("\u2500" * (modal_width - 2))
+      lines << "\e[38;5;240m  \u2191\u2193 navigate  Enter select  Esc cancel\e[0m"
+
+      box_lines = lines.map { |l| "\u2502 #{l.ljust(modal_width - 4)} \u2502" }
+      top    = "┌#{"\u2500" * (modal_width - 2)}┐"
+      bottom = "└#{"\u2500" * (modal_width - 2)}┘"
+
+      ([top] + box_lines + [bottom]).join("\n")
+    end
+
+    def filtered_items
+      return @all_items if @query.empty?
+
+      q = @query.downcase
+      @all_items.select do |item|
+        item.label.downcase.include?(q) || item.key.to_s.downcase.include?(q)
+      end
+    end
+  end
+end

data/lib/petals/cursor.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Petals
+  CursorBlinkMsg = Data.define(:id, :tag)
+
+  # Virtual text cursor with blink modes (blink, static, hide).
+  class Cursor
+    MODE_BLINK  = :blink
+    MODE_STATIC = :static
+    MODE_HIDE   = :hide
+
+    BLINK_SPEED = 0.53
+
+    @next_id = 0
+    @id_mutex = Mutex.new
+    @id_pid = Process.pid
+
+    def self.next_id
+      @id_mutex.synchronize do
+        if Process.pid != @id_pid
+          @id_pid = Process.pid
+          @next_id = 0
+          @id_mutex = Mutex.new
+        end
+        @next_id += 1
+        "#{@id_pid}-cur-#{@next_id}"
+      end
+    end
+
+    attr_reader :id, :mode, :blink_speed
+    attr_accessor :char, :blinked
+
+    def initialize(mode: MODE_BLINK, blink_speed: BLINK_SPEED)
+      @id = self.class.next_id
+      @mode = mode
+      @blink_speed = blink_speed
+      @char = " "
+      @blinked = false
+      @focused = false
+      @tag = 0
+    end
+
+    def focus
+      @focused = true
+      @blinked = false
+      @mode == MODE_BLINK ? blink_cmd : nil
+    end
+
+    def blur
+      @focused = false
+      @blinked = true
+      @tag += 1
+      nil
+    end
+
+    def focused?
+      @focused
+    end
+
+    def mode=(new_mode)
+      @mode = new_mode
+      @tag += 1
+      @blinked = new_mode == MODE_HIDE || !@focused
+      @mode == MODE_BLINK && @focused ? blink_cmd : nil
+    end
+
+    def blink_cmd
+      captured_id = @id
+      captured_tag = @tag
+      speed = @blink_speed
+      -> {
+        sleep(speed)
+        CursorBlinkMsg.new(id: captured_id, tag: captured_tag)
+      }
+    end
+
+    def update(msg)
+      return unless msg.is_a?(CursorBlinkMsg)
+      return unless @mode == MODE_BLINK && @focused
+      return unless msg.id == @id && msg.tag == @tag
+
+      @blinked = !@blinked
+      @tag += 1
+      blink_cmd
+    end
+
+    def view
+      return @char if @mode == MODE_HIDE
+      return @char if @blinked
+
+      "\e[7m#{@char}\e[0m"
+    end
+  end
+end

data/lib/petals/file_picker/key_map.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Petals
+  class FilePicker
+    DEFAULT_KEY_MAP = KeyBinding.normalize({
+                                             up: [[:up, []], ["k", []]],
+                                             down: [[:down, []], ["j", []]],
+                                             open: [[:right, []], ["l", []], [:enter, []]],
+                                             back: [[:left, []], ["h", []], [:backspace, []]],
+                                             toggle_hidden: [[".", []]],
+                                             page_up: [[:page_up, []], ["b", [:ctrl]]],
+                                             page_down: [[:page_down, []], ["f", [:ctrl]]],
+                                             goto_top: [["g", []], [:home, []]],
+                                             goto_bottom: [["G", [:shift]], [:end_key, []]],
+                                           })
+  end
+end

data/lib/petals/file_picker.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Petals
+  FilePickerReadDirMsg = Data.define(:id, :entries)
+
+  # Filesystem browser with async directory reading, navigation, and filtering.
+  class FilePicker
+    @next_id = 0
+    @id_mutex = Mutex.new
+    @id_pid = Process.pid
+
+    def self.next_id
+      @id_mutex.synchronize do
+        if Process.pid != @id_pid
+          @id_pid = Process.pid
+          @next_id = 0
+          @id_mutex = Mutex.new
+        end
+        @next_id += 1
+        "#{@id_pid}-fp-#{@next_id}"
+      end
+    end
+
+    attr_reader :id, :current_directory, :selected_path
+    attr_accessor :key_map, :allowed_types, :show_permissions, :show_size,
+                  :show_hidden, :dir_allowed, :file_allowed, :height, :cursor_char
+
+    def initialize(directory: Dir.pwd, key_map: DEFAULT_KEY_MAP, height: 10,
+                   allowed_types: [], show_permissions: false, show_size: false,
+                   show_hidden: false, dir_allowed: false, file_allowed: true,
+                   cursor_char: ">")
+      @id = self.class.next_id
+      @current_directory = File.expand_path(directory)
+      @key_map = key_map
+      @height = height
+      @allowed_types = allowed_types
+      @show_permissions = show_permissions
+      @show_size = show_size
+      @show_hidden = show_hidden
+      @dir_allowed = dir_allowed
+      @file_allowed = file_allowed
+      @cursor_char = cursor_char
+      @cursor = 0
+      @entries = []
+      @offset = 0
+      @selected_path = nil
+      @disabled_selected_path = nil
+      @dir_stack = []
+    end
+
+    def init_cmd
+      read_dir_cmd(@current_directory)
+    end
+
+    def update(msg)
+      case msg
+      when FilePickerReadDirMsg
+        return unless msg.id == @id
+
+        @entries = msg.entries
+        @cursor = @cursor.clamp(0, [entries_size - 1, 0].max)
+        clamp_offset
+        nil
+      when Chamomile::KeyMsg
+        handle_key(msg)
+      end
+    end
+
+    def view
+      return "  (empty)" if @entries.empty?
+
+      visible = visible_entries
+      lines = visible.each_with_index.map do |entry, i|
+        idx = @offset + i
+        prefix = idx == @cursor ? "#{@cursor_char} " : "  "
+        line = prefix + format_entry(entry)
+        if idx == @cursor
+          "\e[7m#{line}\e[0m"
+        else
+          line
+        end
+      end
+      lines.join("\n")
+    end
+
+    def highlighted_path
+      return nil if @entries.empty?
+
+      entry = @entries[@cursor]
+      return nil unless entry
+
+      File.join(@current_directory, entry[:name])
+    end
+
+    def did_select_file?(msg)
+      return [false, nil] unless msg.is_a?(Chamomile::KeyMsg)
+
+      if @selected_path
+        path = @selected_path
+        @selected_path = nil
+        [true, path]
+      else
+        [false, nil]
+      end
+    end
+
+    def did_select_disabled_file?(msg)
+      return [false, nil] unless msg.is_a?(Chamomile::KeyMsg)
+
+      if @disabled_selected_path
+        path = @disabled_selected_path
+        @disabled_selected_path = nil
+        [true, path]
+      else
+        [false, nil]
+      end
+    end
+
+    private
+
+    def handle_key(msg)
+      kb = KeyBinding
+
+      if kb.key_matches?(msg, @key_map, :up)
+        move_cursor(-1)
+      elsif kb.key_matches?(msg, @key_map, :down)
+        move_cursor(1)
+      elsif kb.key_matches?(msg, @key_map, :page_up)
+        move_cursor(-@height)
+      elsif kb.key_matches?(msg, @key_map, :page_down)
+        move_cursor(@height)
+      elsif kb.key_matches?(msg, @key_map, :goto_top)
+        move_cursor(-entries_size)
+      elsif kb.key_matches?(msg, @key_map, :goto_bottom)
+        move_cursor(entries_size)
+      elsif kb.key_matches?(msg, @key_map, :open)
+        open_entry
+      elsif kb.key_matches?(msg, @key_map, :back)
+        go_back
+      elsif kb.key_matches?(msg, @key_map, :toggle_hidden)
+        @show_hidden = !@show_hidden
+        read_dir_cmd(@current_directory)
+      end
+    end
+
+    def move_cursor(delta)
+      return if @entries.empty?
+
+      @cursor = (@cursor + delta).clamp(0, entries_size - 1)
+      clamp_offset
+      nil
+    end
+
+    def open_entry
+      return nil if @entries.empty?
+
+      entry = @entries[@cursor]
+      return nil unless entry
+
+      path = File.join(@current_directory, entry[:name])
+
+      if selectable?(entry)
+        @selected_path = path
+      elsif !entry[:directory] && @allowed_types.any?
+        @disabled_selected_path = path
+      end
+
+      if entry[:directory]
+        @dir_stack.push({ directory: @current_directory, cursor: @cursor, offset: @offset })
+        @current_directory = path
+        @cursor = 0
+        @offset = 0
+        return read_dir_cmd(path)
+      end
+
+      nil
+    end
+
+    def go_back
+      parent = File.dirname(@current_directory)
+      return nil if parent == @current_directory
+
+      if @dir_stack.any?
+        prev = @dir_stack.pop
+        @current_directory = prev[:directory]
+        @cursor = prev[:cursor]
+        @offset = prev[:offset]
+      else
+        @current_directory = parent
+        @cursor = 0
+        @offset = 0
+      end
+
+      read_dir_cmd(@current_directory)
+    end
+
+    def read_dir_cmd(dir)
+      captured_id = @id
+      show_hidden = @show_hidden
+      -> {
+        entries = begin
+          Dir.entries(dir)
+             .reject { |e| [".", ".."].include?(e) }
+             .reject { |e| !show_hidden && e.start_with?(".") }
+             .map { |e| build_entry(dir, e) }
+             .sort_by { |e| [e[:directory] ? 0 : 1, e[:name].downcase] }
+        rescue SystemCallError
+          []
+        end
+        FilePickerReadDirMsg.new(id: captured_id, entries: entries)
+      }
+    end
+
+    def build_entry(dir, name)
+      path = File.join(dir, name)
+      stat = begin
+        File.stat(path)
+      rescue SystemCallError
+        nil
+      end
+
+      {
+        name: name,
+        directory: stat&.directory? || false,
+        size: stat&.size || 0,
+        permissions: stat ? format("%o", stat.mode & 0o7777) : "0000",
+      }
+    end
+
+    def selectable?(entry)
+      if entry[:directory]
+        @dir_allowed
+      else
+        return false unless @file_allowed
+        return true if @allowed_types.empty?
+
+        ext = File.extname(entry[:name]).downcase
+        @allowed_types.any? { |t| t.downcase == ext || ".#{t.downcase}" == ext }
+      end
+    end
+
+    def format_entry(entry)
+      parts = []
+      parts << (entry[:directory] ? "#{entry[:name]}/" : entry[:name])
+      parts << human_size(entry[:size]) if @show_size && !entry[:directory]
+      parts << entry[:permissions] if @show_permissions
+      parts.join("  ")
+    end
+
+    def human_size(bytes)
+      return "0B" if bytes.zero?
+
+      units = %w[B KB MB GB TB]
+      exp = (Math.log(bytes) / Math.log(1024)).floor
+      exp = [exp, units.length - 1].min
+      size = bytes.to_f / (1024**exp)
+      exp.zero? ? "#{bytes}B" : format("%.1f%s", size, units[exp])
+    end
+
+    def entries_size
+      @entries.length
+    end
+
+    def visible_entries
+      @entries[@offset, @height] || []
+    end
+
+    def clamp_offset
+      return if @entries.empty?
+
+      @offset = @cursor if @cursor < @offset
+      @offset = @cursor - @height + 1 if @cursor >= @offset + @height
+      @offset = [0, @offset].max
+    end
+  end
+end

data/lib/petals/help.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Petals
+  # Auto-generated keybinding help view with short and full display modes.
+  class Help
+    ELLIPSIS = "\u2026"
+
+    attr_accessor :width, :short_separator, :full_separator, :ellipsis, :show_all
+
+    def initialize(width: 80)
+      @width = width
+      @short_separator = " \u2022 "
+      @full_separator = "    "
+      @ellipsis = ELLIPSIS
+      @show_all = false
+    end
+
+    def short_help_view(bindings)
+      filtered = enabled_bindings(bindings)
+      return "" if filtered.empty?
+
+      parts = filtered.map { |b| "#{b[:key]} #{b[:desc]}" }
+      result = parts.join(@short_separator)
+
+      return result if @width <= 0 || result.length <= @width
+
+      truncate(parts)
+    end
+
+    def full_help_view(groups)
+      filtered_groups = groups.map { |g| enabled_bindings(g) }.reject(&:empty?)
+      return "" if filtered_groups.empty?
+
+      max_rows = filtered_groups.map(&:length).max
+      lines = Array.new(max_rows, "")
+
+      max_rows.times do |row|
+        cols = filtered_groups.map do |group|
+          if row < group.length
+            b = group[row]
+            "#{b[:key]}  #{b[:desc]}"
+          else
+            ""
+          end
+        end
+        lines[row] = cols.join(@full_separator).rstrip
+      end
+
+      lines.join("\n")
+    end
+
+    def view(bindings_or_groups)
+      if @show_all
+        groups = bindings_or_groups.first.is_a?(Array) ? bindings_or_groups : [bindings_or_groups]
+        full_help_view(groups)
+      else
+        flat = bindings_or_groups.first.is_a?(Array) ? bindings_or_groups.flatten : bindings_or_groups
+        short_help_view(flat)
+      end
+    end
+
+    def update(_msg)
+      nil
+    end
+
+    private
+
+    def enabled_bindings(bindings)
+      bindings.select { |b| b.fetch(:enabled, true) }
+    end
+
+    def truncate(parts)
+      result = ""
+      parts.each_with_index do |part, i|
+        candidate = if i.zero?
+                      part
+                    else
+                      "#{result}#{@short_separator}#{part}"
+                    end
+        if candidate.length + @ellipsis.length + @short_separator.length > @width && i.positive?
+          return "#{result}#{@short_separator}#{@ellipsis}"
+        end
+
+        result = candidate
+      end
+      result
+    end
+  end
+end

data/lib/petals/key_binding.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Petals
+  # Utilities for matching KeyMsg against normalized key maps.
+  module KeyBinding
+    # Normalize a key map so mod arrays are sorted and frozen.
+    # Call once at definition time to avoid per-keystroke allocations.
+    #
+    #   normalize({ action => [[key, mods], ...] })
+    #   # => { action => [[key, sorted_frozen_mods], ...] }
+    def self.normalize(key_map)
+      key_map.transform_values do |bindings|
+        bindings.map { |key, mods| [key, (mods || []).sort.freeze] }.freeze
+      end.freeze
+    end
+
+    # Check if a KeyMsg matches any binding for a named action.
+    # Expects a normalized key map (from .normalize) for best performance.
+    def self.key_matches?(msg, key_map, action)
+      return false unless msg.is_a?(Chamomile::KeyMsg)
+
+      bindings = key_map[action]
+      return false unless bindings
+
+      sorted_mod = msg.mod.sort
+      bindings.any? do |key, mods|
+        msg.key == key && sorted_mod == (mods || [])
+      end
+    end
+  end
+end

data/lib/petals/list/key_map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Petals
+  class List
+    DEFAULT_KEY_MAP = KeyBinding.normalize({
+                                             cursor_up: [[:up, []], ["k", []]],
+                                             cursor_down: [[:down, []], ["j", []]],
+                                             next_page: [[:page_down, []], ["n", [:ctrl]]],
+                                             prev_page: [[:page_up, []], ["p", [:ctrl]]],
+                                             goto_start: [["g", []], [:home, []]],
+                                             goto_end: [["G", [:shift]], [:end_key, []]],
+                                             filter: [["/", []]],
+                                             clear_filter: [[:escape, []]],
+                                             accept_filter: [[:enter, []]],
+                                             show_full_help: [["?", []]],
+                                           })
+  end
+end