clack 0.1.0

data/lib/clack/environment.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Clack
+  # Environment detection utilities for cross-platform compatibility
+  # and CI/terminal environment awareness.
+  module Environment
+    class << self
+      # Check if running on Windows
+      # @return [Boolean]
+      def windows?
+        return @windows if defined?(@windows)
+
+        @windows = !!(RUBY_PLATFORM =~ /mswin|mingw|cygwin|bccwin/i)
+      end
+
+      # Check if running in a CI environment
+      # Common CI env vars: CI, CONTINUOUS_INTEGRATION, BUILD_NUMBER, GITHUB_ACTIONS, etc.
+      # @return [Boolean]
+      def ci?
+        return @ci if defined?(@ci)
+
+        @ci = ENV["CI"] == "true" ||
+          ENV["CONTINUOUS_INTEGRATION"] == "true" ||
+          ENV.key?("BUILD_NUMBER") ||
+          ENV.key?("GITHUB_ACTIONS") ||
+          ENV.key?("GITLAB_CI") ||
+          ENV.key?("CIRCLECI") ||
+          ENV.key?("TRAVIS") ||
+          ENV.key?("JENKINS_URL") ||
+          ENV.key?("TEAMCITY_VERSION") ||
+          ENV.key?("BUILDKITE")
+      end
+
+      # Check if stdout is a TTY (interactive terminal)
+      # @param output [IO] Output stream to check (default: $stdout)
+      # @return [Boolean]
+      def tty?(output = $stdout)
+        output.respond_to?(:tty?) && output.tty?
+      rescue IOError
+        false
+      end
+
+      # Check if running in Windows Terminal (modern)
+      # @return [Boolean]
+      def windows_terminal?
+        windows? && ENV.key?("WT_SESSION")
+      end
+
+      # Check if running in a dumb terminal (no ANSI support)
+      # @return [Boolean]
+      def dumb_terminal?
+        ENV["TERM"] == "dumb"
+      end
+
+      # Check if ANSI colors are supported
+      # @param output [IO] Output stream to check
+      # @return [Boolean]
+      def colors_supported?(output = $stdout)
+        return false if ENV["NO_COLOR"]
+        return true if ENV["FORCE_COLOR"]
+        return false unless tty?(output)
+        return false if dumb_terminal?
+
+        # Windows: Modern Windows Terminal, ConEmu, ANSICON, or Windows 10 1511+
+        # all support ANSI. We optimistically assume modern systems support it.
+        true
+      end
+
+      # Get terminal columns (width)
+      # @param output [IO] Output stream (default: $stdout)
+      # @param default [Integer] Default if detection fails
+      # @return [Integer]
+      def columns(output = $stdout, default: 80)
+        return default unless tty?(output)
+
+        if output.respond_to?(:winsize)
+          _, cols = output.winsize
+          (cols > 0) ? cols : default
+        else
+          default
+        end
+      rescue IOError, SystemCallError
+        default
+      end
+
+      # Get terminal rows (height)
+      # @param output [IO] Output stream (default: $stdout)
+      # @param default [Integer] Default if detection fails
+      # @return [Integer]
+      def rows(output = $stdout, default: 24)
+        return default unless tty?(output)
+
+        if output.respond_to?(:winsize)
+          rows, = output.winsize
+          (rows > 0) ? rows : default
+        else
+          default
+        end
+      rescue IOError, SystemCallError
+        default
+      end
+
+      # Get terminal dimensions as [rows, columns]
+      # @param output [IO] Output stream
+      # @return [Array<Integer>] [rows, columns]
+      def dimensions(output = $stdout)
+        [rows(output), columns(output)]
+      end
+
+      # Check if raw mode is supported for input
+      # @param input [IO] Input stream (default: $stdin)
+      # @return [Boolean]
+      def raw_mode_supported?(input = $stdin)
+        return false unless input.respond_to?(:raw)
+
+        # On Windows without proper console, raw mode may fail
+        if windows? && !windows_terminal?
+          begin
+            IO.console&.respond_to?(:raw)
+          rescue
+            false
+          end
+        else
+          true
+        end
+      end
+
+      # Reset cached environment checks (useful for testing)
+      def reset!
+        remove_instance_variable(:@windows) if defined?(@windows)
+        remove_instance_variable(:@ci) if defined?(@ci)
+      end
+    end
+  end
+end

data/lib/clack/group.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Clack
+  # Collects results from multiple prompts and handles cancellation gracefully.
+  #
+  # @example Basic usage
+  #   result = Clack.group do |g|
+  #     g.prompt(:name) { Clack.text(message: "Your name?") }
+  #     g.prompt(:age) { Clack.text(message: "Your age?") }
+  #   end
+  #   # => { name: "Alice", age: "30" } or Clack::CANCEL
+  #
+  # @example With previous results
+  #   result = Clack.group do |g|
+  #     g.prompt(:name) { Clack.text(message: "Your name?") }
+  #     g.prompt(:greeting) { |r| Clack.text(message: "Hello #{r[:name]}!") }
+  #   end
+  #
+  class Group
+    # @return [Hash] The collected results
+    attr_reader :results
+
+    def initialize(on_cancel: nil)
+      @results = {}
+      @prompts = []
+      @on_cancel = on_cancel
+    end
+
+    # Define a prompt in the group.
+    #
+    # @param name [Symbol, String] The key for this result
+    # @yield [results] Block that returns a prompt result
+    # @yieldparam results [Hash] Previous results collected so far
+    # @return [void]
+    def prompt(name, &block)
+      raise ArgumentError, "Block required for prompt :#{name}" unless block_given?
+
+      @prompts << {name: name.to_sym, block: block}
+    end
+
+    # Run all prompts and collect results.
+    #
+    # @return [Hash, Clack::CANCEL] Results hash or CANCEL if user cancelled
+    def run
+      @prompts.each do |prompt_def|
+        name = prompt_def[:name]
+        block = prompt_def[:block]
+
+        # Pass previous results to the block if it accepts an argument
+        result = if block.arity.zero?
+          block.call
+        else
+          block.call(@results.dup.freeze)
+        end
+
+        if Clack.cancel?(result)
+          @results[name] = :cancelled
+          @on_cancel&.call(@results.dup.freeze)
+          return CANCEL
+        end
+
+        @results[name] = result
+      end
+
+      @results
+    end
+  end
+
+  class << self
+    # Run a group of prompts and collect their results.
+    #
+    # If any prompt is cancelled, the entire group returns Clack::CANCEL.
+    # The on_cancel callback receives partial results collected so far.
+    #
+    # @param on_cancel [Proc, nil] Callback when a prompt is cancelled
+    # @yield [group] Block to define prompts
+    # @yieldparam group [Clack::Group] The group builder
+    # @return [Hash, Clack::CANCEL] Results hash or CANCEL
+    #
+    # @example
+    #   result = Clack.group do |g|
+    #     g.prompt(:name) { Clack.text(message: "Name?") }
+    #     g.prompt(:confirm) { Clack.confirm(message: "Continue?") }
+    #   end
+    #
+    #   if Clack.cancel?(result)
+    #     Clack.cancel("Cancelled")
+    #   else
+    #     puts "Name: #{result[:name]}"
+    #   end
+    #
+    def group(on_cancel: nil, &block)
+      raise ArgumentError, "Block required for Clack.group" unless block_given?
+
+      group = Group.new(on_cancel: on_cancel)
+      block.call(group)
+      group.run
+    end
+  end
+end

data/lib/clack/log.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Clack
+  module Log
+    class << self
+      def message(msg = "", symbol: nil, output: $stdout)
+        symbol ||= Colors.gray(Symbols::S_BAR)
+        lines = msg.to_s.lines
+
+        if lines.empty?
+          output.puts symbol
+        else
+          lines.each_with_index do |line, idx|
+            prefix = idx.zero? ? symbol : Colors.gray(Symbols::S_BAR)
+            output.puts "#{prefix}  #{line.chomp}"
+          end
+        end
+      end
+
+      def info(msg, output: $stdout)
+        message(msg, symbol: Colors.blue(Symbols::S_INFO), output:)
+      end
+
+      def success(msg, output: $stdout)
+        message(msg, symbol: Colors.green(Symbols::S_SUCCESS), output:)
+      end
+
+      def step(msg, output: $stdout)
+        message(msg, symbol: Colors.green(Symbols::S_STEP_SUBMIT), output:)
+      end
+
+      def warn(msg, output: $stdout)
+        message(msg, symbol: Colors.yellow(Symbols::S_WARN), output:)
+      end
+      alias_method :warning, :warn
+
+      def error(msg, output: $stdout)
+        message(msg, symbol: Colors.red(Symbols::S_ERROR), output:)
+      end
+    end
+  end
+end

data/lib/clack/note.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Clack
+  module Note
+    class << self
+      def render(message = "", title: nil, output: $stdout)
+        lines = message.to_s.lines.map(&:chomp)
+        # Add empty lines at start and end like original
+        lines = ["", *lines, ""]
+        title_len = title&.length || 0
+        width = calculate_width(lines, title_len)
+
+        output.puts Colors.gray(Symbols::S_BAR)
+        output.puts build_top_border(title, title_len, width)
+
+        lines.each do |line|
+          padded = line.ljust(width)
+          output.puts "#{Colors.gray(Symbols::S_BAR)}  #{Colors.dim(padded)}#{Colors.gray(Symbols::S_BAR)}"
+        end
+
+        output.puts build_bottom_border(width)
+      end
+
+      private
+
+      def calculate_width(lines, title_len)
+        max_line = lines.map(&:length).max || 0
+        [max_line, title_len].max + 2
+      end
+
+      def build_top_border(title, title_len, width)
+        if title
+          # Format: ◇  title ───────╮
+          right_len = [width - title_len - 1, 1].max
+          right = "#{Symbols::S_BAR_H * right_len}#{Symbols::S_CORNER_TOP_RIGHT}"
+          "#{Colors.green(Symbols::S_STEP_SUBMIT)}  #{title} #{Colors.gray(right)}"
+        else
+          border = Symbols::S_BAR_H * (width + 2)
+          "#{Colors.gray(Symbols::S_CORNER_TOP_LEFT)}#{Colors.gray(border)}#{Colors.gray(Symbols::S_CORNER_TOP_RIGHT)}"
+        end
+      end
+
+      def build_bottom_border(width)
+        border = Symbols::S_BAR_H * (width + 2)
+        "#{Colors.gray(Symbols::S_CONNECT_LEFT)}#{Colors.gray(border)}#{Colors.gray(Symbols::S_CORNER_BOTTOM_RIGHT)}"
+      end
+    end
+  end
+end

data/lib/clack/prompts/autocomplete.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Clack
+  module Prompts
+    # Type-to-filter autocomplete prompt.
+    #
+    # Combines text input with a filtered option list. Type to filter,
+    # use arrow keys to navigate matches, Enter to select.
+    #
+    # Filtering searches across value, label, and hint fields.
+    #
+    # @example Basic usage
+    #   color = Clack.autocomplete(
+    #     message: "Pick a color",
+    #     options: %w[red orange yellow green blue indigo violet]
+    #   )
+    #
+    # @example With placeholder
+    #   city = Clack.autocomplete(
+    #     message: "Select city",
+    #     options: cities,
+    #     placeholder: "Type to search...",
+    #     max_items: 10
+    #   )
+    #
+    class Autocomplete < 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 opts [Hash] additional options passed to {Core::Prompt}
+      def initialize(message:, options:, max_items: 5, placeholder: nil, **opts)
+        super(message:, **opts)
+        @all_options = normalize_options(options)
+        @max_items = max_items
+        @placeholder = placeholder
+        @value = ""
+        @cursor = 0
+        @selected_index = 0
+        @scroll_offset = 0
+        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)
+        else
+          handle_text_input(key)
+        end
+      end
+
+      def handle_text_input(key)
+        return unless super
+
+        @selected_index = 0
+        @scroll_offset = 0
+        update_filtered
+      end
+
+      def submit_selection
+        if @filtered.empty?
+          @error_message = "No matching option"
+          @state = :error
+          return
+        end
+
+        @value = @filtered[@selected_index][:value]
+        submit
+      end
+
+      def build_frame
+        lines = []
+        lines << "#{bar}\n"
+        lines << "#{symbol_for_state}  #{@message}\n"
+        lines << "#{active_bar}  #{input_display}\n"
+
+        visible_options.each_with_index do |opt, idx|
+          actual_idx = @scroll_offset + idx
+          lines << "#{bar}  #{option_display(opt, actual_idx == @selected_index)}\n"
+        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"
+
+        display_value = @filtered[@selected_index]&.[](:label) || @value
+        display = (@state == :cancel) ? Colors.strikethrough(Colors.dim(display_value)) : Colors.dim(display_value)
+        lines << "#{bar}  #{display}\n"
+
+        lines.join
+      end
+
+      private
+
+      def update_filtered
+        query = @value.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)
+        hint = (opt[:hint] && active) ? Colors.dim(" (#{opt[:hint]})") : ""
+        if active
+          "#{Colors.green(Symbols::S_RADIO_ACTIVE)} #{opt[:label]}#{hint}"
+        else
+          "#{Colors.dim(Symbols::S_RADIO_INACTIVE)} #{Colors.dim(opt[:label])}"
+        end
+      end
+    end
+  end
+end