clack 0.1.0

data/lib/clack/prompts/autocomplete_multiselect.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Clack
+  module Prompts
+    # Type-to-filter autocomplete with multiple selection.
+    #
+    # Combines text input filtering with checkbox-style selection.
+    # Type to filter, Space to toggle, Enter to confirm.
+    #
+    # Shortcuts:
+    # - Space: toggle current option
+    # - 'a': toggle all options
+    # - 'i': invert selection
+    #
+    # @example Basic usage
+    #   colors = Clack.autocomplete_multiselect(
+    #     message: "Pick colors",
+    #     options: %w[red orange yellow green blue]
+    #   )
+    #
+    # @example With options
+    #   tags = Clack.autocomplete_multiselect(
+    #     message: "Select tags",
+    #     options: all_tags,
+    #     placeholder: "Type to filter...",
+    #     required: true,
+    #     initial_values: ["important"]
+    #   )
+    #
+    class AutocompleteMultiselect < Core::Prompt
+      include Core::OptionsHelper
+      include Core::TextInputHelper
+
+      # @param message [String] the prompt message
+      # @param options [Array<Hash, String>] list of options to filter
+      # @param max_items [Integer] max visible options (default: 5)
+      # @param placeholder [String, nil] placeholder text when empty
+      # @param required [Boolean] require at least one selection (default: true)
+      # @param initial_values [Array, nil] values to pre-select
+      # @param opts [Hash] additional options passed to {Core::Prompt}
+      def initialize(message:, options:, max_items: 5, placeholder: nil, required: true, initial_values: nil, **opts)
+        super(message:, **opts)
+        @all_options = normalize_options(options)
+        @max_items = max_items
+        @placeholder = placeholder
+        @required = required
+        @search_text = ""
+        @cursor = 0
+        @selected_index = 0
+        @scroll_offset = 0
+        @selected_values = Set.new(initial_values || [])
+        update_filtered
+      end
+
+      protected
+
+      def handle_key(key)
+        return if terminal_state?
+
+        @state = :active if @state == :error
+        action = Core::Settings.action?(key)
+
+        case action
+        when :cancel
+          @state = :cancel
+        when :enter
+          submit_selection
+        when :up
+          move_selection(-1)
+        when :down
+          move_selection(1)
+        when :space
+          toggle_current
+        else
+          handle_char(key)
+        end
+      end
+
+      def handle_char(key)
+        # Shortcut keys only work when search field is empty
+        # to avoid interfering with typing filter text
+        if @search_text.empty?
+          case key&.downcase
+          when "a"
+            toggle_all
+            return
+          when "i"
+            invert_selection
+            return
+          end
+        end
+        handle_text_input(key)
+      end
+
+      def toggle_current
+        return if @filtered.empty?
+
+        current_value = @filtered[@selected_index][:value]
+        if @selected_values.include?(current_value)
+          @selected_values.delete(current_value)
+        else
+          @selected_values.add(current_value)
+        end
+      end
+
+      def toggle_all
+        if @selected_values.size == @all_options.size
+          @selected_values.clear
+        else
+          @all_options.each { |opt| @selected_values.add(opt[:value]) }
+        end
+      end
+
+      def invert_selection
+        @all_options.each do |opt|
+          if @selected_values.include?(opt[:value])
+            @selected_values.delete(opt[:value])
+          else
+            @selected_values.add(opt[:value])
+          end
+        end
+      end
+
+      def submit_selection
+        if @required && @selected_values.empty?
+          @error_message = "Please select at least one option"
+          @state = :error
+          return
+        end
+
+        @value = @selected_values.to_a
+        submit
+      end
+
+      def build_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+        lines << "#{active_bar}  #{Colors.dim("Search:")} #{search_input_display}#{match_count}\n"
+
+        visible_options.each_with_index do |opt, idx|
+          actual_idx = @scroll_offset + idx
+          lines << "#{active_bar}  #{option_display(opt, actual_idx == @selected_index)}\n"
+        end
+
+        lines << "#{active_bar}  #{Colors.yellow("No matches found")}\n" if @filtered.empty? && !@search_text.empty?
+
+        lines << "#{active_bar}  #{instructions}\n"
+        lines << "#{bar_end}\n"
+
+        if @state == :error
+          lines[-2] = "#{Colors.yellow(Symbols::S_BAR)}  #{Colors.yellow(@error_message)}\n"
+          lines[-1] = "#{Colors.yellow(Symbols::S_BAR_END)}\n"
+        end
+
+        lines.join
+      end
+
+      def build_final_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+
+        display = if @state == :cancel
+          Colors.strikethrough(Colors.dim("cancelled"))
+        else
+          Colors.dim("#{@selected_values.size} items selected")
+        end
+        lines << "#{bar}  #{display}\n"
+
+        lines.join
+      end
+
+      private
+
+      # Override TextInputHelper methods to use @search_text instead of @value
+      def search_input_display
+        return placeholder_display if @search_text.empty?
+
+        search_value_with_cursor
+      end
+
+      def search_value_with_cursor
+        chars = @search_text.grapheme_clusters
+        return "#{@search_text}#{cursor_block}" if @cursor >= chars.length
+
+        before = chars[0...@cursor].join
+        current = Colors.inverse(chars[@cursor])
+        after = chars[(@cursor + 1)..].join
+        "#{before}#{current}#{after}"
+      end
+
+      # Override to work with @search_text instead of @value
+      def handle_text_input(key)
+        return false unless Core::Settings.printable?(key)
+
+        chars = @search_text.grapheme_clusters
+
+        if Core::Settings.backspace?(key)
+          return false if @cursor.zero?
+
+          chars.delete_at(@cursor - 1)
+          @search_text = chars.join
+          @cursor -= 1
+        else
+          chars.insert(@cursor, key)
+          @search_text = chars.join
+          @cursor += 1
+        end
+
+        @selected_index = 0
+        @scroll_offset = 0
+        update_filtered
+        true
+      end
+
+      def match_count
+        return "" if @filtered.size == @all_options.size
+
+        Colors.dim(" (#{@filtered.size} match#{"es" unless @filtered.size == 1})")
+      end
+
+      def instructions
+        Colors.dim([
+          "up/down: navigate",
+          "space: select",
+          "a: all",
+          "i: invert",
+          "enter: confirm"
+        ].join(" | "))
+      end
+
+      def update_filtered
+        query = @search_text.downcase
+        @filtered = @all_options.select do |opt|
+          opt[:label].downcase.include?(query) ||
+            opt[:value].to_s.downcase.include?(query) ||
+            opt[:hint]&.downcase&.include?(query)
+        end
+      end
+
+      def visible_options
+        return @filtered if @filtered.length <= @max_items
+
+        @filtered[@scroll_offset, @max_items]
+      end
+
+      def move_selection(delta)
+        return if @filtered.empty?
+
+        @selected_index = (@selected_index + delta) % @filtered.length
+        update_scroll
+      end
+
+      def update_scroll
+        return unless @filtered.length > @max_items
+
+        if @selected_index < @scroll_offset
+          @scroll_offset = @selected_index
+        elsif @selected_index >= @scroll_offset + @max_items
+          @scroll_offset = @selected_index - @max_items + 1
+        end
+      end
+
+      def option_display(opt, active)
+        is_selected = @selected_values.include?(opt[:value])
+        checkbox = if is_selected
+          Colors.green(Symbols::S_CHECKBOX_SELECTED)
+        else
+          Colors.dim(Symbols::S_CHECKBOX_INACTIVE)
+        end
+
+        label = active ? opt[:label] : Colors.dim(opt[:label])
+        hint = (opt[:hint] && active) ? Colors.dim(" (#{opt[:hint]})") : ""
+
+        "#{checkbox} #{label}#{hint}"
+      end
+    end
+  end
+end

data/lib/clack/prompts/confirm.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Clack
+  module Prompts
+    # Yes/No confirmation prompt.
+    #
+    # Displays a toggle between two options. Navigate with arrow keys, j/k,
+    # or press y/n to select directly.
+    #
+    # @example Basic usage
+    #   proceed = Clack.confirm(message: "Continue?")
+    #
+    # @example With custom labels
+    #   deploy = Clack.confirm(
+    #     message: "Deploy to production?",
+    #     active: "Yes, ship it!",
+    #     inactive: "No, abort",
+    #     initial_value: false
+    #   )
+    #
+    class Confirm < Core::Prompt
+      # @param message [String] the prompt message
+      # @param active [String] label for the "yes" option (default: "Yes")
+      # @param inactive [String] label for the "no" option (default: "No")
+      # @param initial_value [Boolean] initial selection (default: true)
+      # @param opts [Hash] additional options passed to {Core::Prompt}
+      def initialize(message:, active: "Yes", inactive: "No", initial_value: true, **opts)
+        super(message:, **opts)
+        @active_label = active
+        @inactive_label = inactive
+        @value = initial_value
+      end
+
+      protected
+
+      def handle_key(key)
+        return if terminal_state?
+
+        action = Core::Settings.action?(key)
+
+        case action
+        when :cancel
+          @state = :cancel
+        when :enter
+          submit
+        when :left, :up
+          @value = true
+        when :right, :down
+          @value = false
+        else
+          handle_char(key)
+        end
+      end
+
+      def handle_char(key)
+        case key&.downcase
+        when "y"
+          @value = true
+        when "n"
+          @value = false
+        end
+      end
+
+      def build_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+        lines << "#{bar}  #{options_display}\n"
+        lines << "#{Colors.gray(Symbols::S_BAR_END)}\n"
+        lines.join
+      end
+
+      def build_final_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+
+        selected = @value ? @active_label : @inactive_label
+        display = (@state == :cancel) ? Colors.strikethrough(Colors.dim(selected)) : Colors.dim(selected)
+        lines << "#{bar}  #{display}\n"
+
+        lines.join
+      end
+
+      private
+
+      def options_display
+        if @value
+          active = "#{Colors.green(Symbols::S_RADIO_ACTIVE)} #{@active_label}"
+          inactive = "#{Colors.dim(Symbols::S_RADIO_INACTIVE)} #{Colors.dim(@inactive_label)}"
+        else
+          active = "#{Colors.dim(Symbols::S_RADIO_INACTIVE)} #{Colors.dim(@active_label)}"
+          inactive = "#{Colors.green(Symbols::S_RADIO_ACTIVE)} #{@inactive_label}"
+        end
+
+        "#{active} #{Colors.dim("/")} #{inactive}"
+      end
+    end
+  end
+end

data/lib/clack/prompts/group_multiselect.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Clack
+  module Prompts
+    class GroupMultiselect < Core::Prompt
+      def initialize(
+        message:,
+        options:,
+        initial_values: [],
+        required: true,
+        selectable_groups: false,
+        group_spacing: 0,
+        cursor_at: nil,
+        **opts
+      )
+        super(message:, **opts)
+        @groups = normalize_groups(options)
+        @flat_items = build_flat_items
+        @selected = Set.new(initial_values)
+        @required = required
+        @selectable_groups = selectable_groups
+        @group_spacing = group_spacing
+        @cursor = find_initial_cursor(cursor_at)
+        update_value
+      end
+
+      protected
+
+      def handle_key(key)
+        return if terminal_state?
+
+        @state = :active if @state == :error
+        action = Core::Settings.action?(key)
+
+        case action
+        when :cancel
+          @state = :cancel
+        when :enter
+          submit
+        when :up
+          move_cursor(-1)
+        when :down
+          move_cursor(1)
+        when :space
+          toggle_current
+        end
+      end
+
+      def submit
+        if @required && @selected.empty?
+          @error_message = "Please select at least one option."
+          @state = :error
+          return
+        end
+        super
+      end
+
+      def build_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+
+        prev_was_group = false
+        @flat_items.each_with_index do |item, idx|
+          is_group = item[:type] == :group
+          is_last_in_group = item[:last_in_group]
+
+          # Add group spacing before groups (except first)
+          if is_group && prev_was_group == false && idx.positive? && @group_spacing.positive?
+            @group_spacing.times { lines << "#{active_bar}\n" }
+          end
+
+          lines << if is_group
+            group_display(item, idx == @cursor)
+          else
+            option_display(item, idx == @cursor, is_last_in_group)
+          end
+
+          prev_was_group = is_group
+        end
+
+        lines << "#{bar_end}\n"
+
+        lines[-1] = "#{Colors.yellow(Symbols::S_BAR_END)}  #{Colors.yellow(@error_message)}\n" if @state == :error
+
+        lines.join
+      end
+
+      def build_final_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+
+        labels = selected_options.map { |o| o[:label] }
+        display_text = labels.join(", ")
+        display = (@state == :cancel) ? Colors.strikethrough(Colors.dim(display_text)) : Colors.dim(display_text)
+        lines << "#{bar}  #{display}\n"
+
+        lines.join
+      end
+
+      private
+
+      def normalize_groups(options)
+        options.map { |group| normalize_group(group) }
+      end
+
+      def normalize_group(group)
+        {
+          label: group[:label] || group[:group],
+          options: group[:options].map { |opt| normalize_option(opt) }
+        }
+      end
+
+      def normalize_option(opt)
+        case opt
+        when Hash
+          {value: opt[:value], label: opt[:label] || opt[:value].to_s, disabled: opt[:disabled] || false}
+        else
+          {value: opt, label: opt.to_s, disabled: false}
+        end
+      end
+
+      def build_flat_items
+        @groups.flat_map { |group| flatten_group(group) }
+      end
+
+      def flatten_group(group)
+        group_item = {type: :group, label: group[:label], options: group[:options]}
+        option_items = group[:options].each_with_index.map do |opt, idx|
+          {
+            type: :option,
+            value: opt[:value],
+            label: opt[:label],
+            disabled: opt[:disabled],
+            group: group,
+            last_in_group: idx == group[:options].length - 1
+          }
+        end
+        [group_item] + option_items
+      end
+
+      def selected_options
+        @flat_items.select { |item| item[:type] == :option && @selected.include?(item[:value]) }
+      end
+
+      def find_initial_cursor(cursor_at)
+        return 0 if @flat_items.empty?
+
+        if cursor_at
+          idx = @flat_items.find_index { |item| item[:value] == cursor_at }
+          return idx if idx
+        end
+
+        # Find first selectable item
+        @flat_items.each_with_index do |item, idx|
+          return idx if can_select?(item)
+        end
+        0
+      end
+
+      def can_select?(item)
+        return false if item[:disabled]
+        return @selectable_groups if item[:type] == :group
+
+        true
+      end
+
+      def move_cursor(delta)
+        new_cursor = @cursor
+        attempts = @flat_items.length
+
+        loop do
+          new_cursor = (new_cursor + delta) % @flat_items.length
+          attempts -= 1
+          break if can_select?(@flat_items[new_cursor]) || attempts <= 0
+        end
+
+        @cursor = new_cursor
+      end
+
+      def toggle_current
+        item = @flat_items[@cursor]
+        return unless can_select?(item)
+
+        if item[:type] == :group
+          toggle_group(item)
+        else
+          toggle_option(item)
+        end
+        update_value
+      end
+
+      def toggle_group(group_item)
+        group_values = group_item[:options].reject { |o| o[:disabled] }.map { |o| o[:value] }
+        all_selected = group_values.all? { |v| @selected.include?(v) }
+
+        if all_selected
+          group_values.each { |v| @selected.delete(v) }
+        else
+          group_values.each { |v| @selected.add(v) }
+        end
+      end
+
+      def toggle_option(item)
+        if @selected.include?(item[:value])
+          @selected.delete(item[:value])
+        else
+          @selected.add(item[:value])
+        end
+      end
+
+      def update_value
+        @value = @selected.to_a
+      end
+
+      def group_display(item, active)
+        if @selectable_groups
+          all_selected = item[:options].reject { |o| o[:disabled] }.all? { |o| @selected.include?(o[:value]) }
+          checkbox = all_selected ? Colors.green(Symbols::S_CHECKBOX_SELECTED) : Colors.dim(Symbols::S_CHECKBOX_INACTIVE)
+          label = active ? item[:label] : Colors.dim(item[:label])
+          "#{active_bar}  #{checkbox} #{label}\n"
+        else
+          "#{active_bar}  #{Colors.dim(item[:label])}\n"
+        end
+      end
+
+      def option_display(item, active, is_last)
+        selected = @selected.include?(item[:value])
+        prefix = if @selectable_groups
+          "#{is_last ? Symbols::S_BAR_END : Symbols::S_BAR} "
+        else
+          "  "
+        end
+
+        if item[:disabled]
+          "#{active_bar}  #{Colors.dim(prefix)}#{Colors.dim(Symbols::S_CHECKBOX_INACTIVE)} #{Colors.strikethrough(Colors.dim(item[:label]))}\n"
+        elsif active && selected
+          "#{active_bar}  #{Colors.dim(prefix)}#{Colors.green(Symbols::S_CHECKBOX_SELECTED)} #{item[:label]}\n"
+        elsif active
+          "#{active_bar}  #{Colors.dim(prefix)}#{Colors.cyan(Symbols::S_CHECKBOX_ACTIVE)} #{item[:label]}\n"
+        elsif selected
+          "#{active_bar}  #{Colors.dim(prefix)}#{Colors.green(Symbols::S_CHECKBOX_SELECTED)} #{Colors.dim(item[:label])}\n"
+        else
+          "#{active_bar}  #{Colors.dim(prefix)}#{Colors.dim(Symbols::S_CHECKBOX_INACTIVE)} #{Colors.dim(item[:label])}\n"
+        end
+      end
+    end
+  end
+end