gum 0.2.1 → 0.3.0

data/lib/gum.rb

@@ -1,14 +1,174 @@
-require 'gum/version'
+# frozen_string_literal: true
+# typed: true
+# rbs_inline: enabled
 
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/compact'
-require 'active_support/core_ext/object/try'
-require 'active_support/inflector'
-
-require 'gum/filter'
-require 'gum/filters'
-require 'gum/search'
+require_relative "gum/version"
+require_relative "gum/command"
 
 module Gum
+  autoload :Upstream, "gum/upstream"
+  autoload :Choose, "gum/commands/choose"
+  autoload :Confirm, "gum/commands/confirm"
+  autoload :FilePicker, "gum/commands/file"
+  autoload :Filter, "gum/commands/filter"
+  autoload :Format, "gum/commands/format"
+  autoload :Input, "gum/commands/input"
+  autoload :Join, "gum/commands/join"
+  autoload :Log, "gum/commands/log"
+  autoload :Pager, "gum/commands/pager"
+  autoload :Spin, "gum/commands/spin"
+  autoload :Style, "gum/commands/style"
+  autoload :Table, "gum/commands/table"
+  autoload :Write, "gum/commands/write"
+
+  GEM_NAME = "gum"
+  DEFAULT_DIR = File.expand_path(File.join(__dir__, "..", "exe"))
+
+  class Error < StandardError; end
+  class ExecutableNotFoundException < Error; end
+  class UnsupportedPlatformException < Error; end
+  class DirectoryNotFoundException < Error; end
+
+  class << self
+    def execute(*args)
+      system(executable, *args.map(&:to_s))
+    end
+
+    def platform
+      [:cpu, :os].map { |m| Gem::Platform.local.public_send(m) }.join("-")
+    end
+
+    def version
+      "gum v#{VERSION} (upstream v#{Upstream::VERSION}) [#{platform}]"
+    end
+
+    def executable(exe_path: DEFAULT_DIR)
+      gum_install_dir = ENV.fetch("GUM_INSTALL_DIR", nil)
+
+      if gum_install_dir
+        raise DirectoryNotFoundException, <<~MESSAGE unless File.directory?(gum_install_dir)
+          GUM_INSTALL_DIR is set to #{gum_install_dir}, but that directory does not exist.
+        MESSAGE
+
+        warn "NOTE: using GUM_INSTALL_DIR to find gum executable: #{gum_install_dir}"
+        exe_file = File.expand_path(File.join(gum_install_dir, "gum"))
+      else
+        if Gum::Upstream::NATIVE_PLATFORMS.keys.none? { |p| Gem::Platform.match_gem?(Gem::Platform.new(p), GEM_NAME) }
+          raise UnsupportedPlatformException, <<~MESSAGE
+            gum does not support the #{platform} platform.
+            Please install gum following instructions at https://github.com/charmbracelet/gum#installation
+          MESSAGE
+        end
+
+        exe_file = Dir.glob(File.expand_path(File.join(exe_path, "**", "gum"))).find do |f|
+          Gem::Platform.match_gem?(Gem::Platform.new(File.basename(File.dirname(f))), GEM_NAME)
+        end
+      end
+
+      if exe_file.nil? || !File.exist?(exe_file)
+        raise ExecutableNotFoundException, <<~MESSAGE
+          Cannot find the gum executable for #{platform} in #{exe_path}
+
+          If you're using bundler, please make sure you're on the latest bundler version:
+
+              gem install bundler
+              bundle update --bundler
+
+          Then make sure your lock file includes this platform by running:
+
+              bundle lock --add-platform #{platform}
+              bundle install
+
+          See `bundle lock --help` output for details.
+
+          If you're still seeing this message after taking those steps, try running
+          `bundle config` and ensure `force_ruby_platform` isn't set to `true`.
+        MESSAGE
+      end
+
+      exe_file
+    end
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # High-level Ruby API
+    # ─────────────────────────────────────────────────────────────────────────
+
+    # Prompt for single-line input
+    # @see Gum::Input#call
+    def input(**)
+      Input.call(**)
+    end
+
+    # Prompt for multi-line text input
+    # @see Gum::Write#call
+    def write(**)
+      Write.call(**)
+    end
+
+    # Choose from a list of options
+    # @see Gum::Choose#call
+    def choose(...)
+      Choose.call(...)
+    end
+
+    # Filter items with fuzzy matching
+    # @see Gum::Filter#call
+    def filter(...)
+      Filter.call(...)
+    end
+
+    # Prompt for confirmation
+    # @see Gum::Confirm#call
+    def confirm(prompt = "Are you sure?", **)
+      Confirm.call(prompt, **)
+    end
+
+    # Pick a file from the filesystem
+    # @see Gum::FilePicker#call
+    def file(path = nil, **)
+      FilePicker.call(path, **)
+    end
+
+    # Display content in a scrollable pager
+    # @see Gum::Pager#call
+    def pager(content, **)
+      Pager.call(content, **)
+    end
+
+    # Display a spinner while running a command or block
+    # @see Gum::Spin#call
+    def spin(title = "Loading...", **, &)
+      Spin.call(title, **, &)
+    end
+
+    # Apply styling to text
+    # @see Gum::Style#call
+    def style(*text, **)
+      Style.call(*text, **)
+    end
+
+    # Join text blocks together
+    # @see Gum::Join#call
+    def join(*texts, **)
+      Join.call(*texts, **)
+    end
+
+    # Format text (markdown, code, template, emoji)
+    # @see Gum::Format#call
+    def format(*text, **)
+      Format.call(*text, **)
+    end
+
+    # Display and select from tabular data
+    # @see Gum::Table#call
+    def table(data, **)
+      Table.call(data, **)
+    end
+
+    # Log a message
+    # @see Gum::Log#call
+    def log(message, **)
+      Log.call(message, **)
+    end
+  end
 end

data/sig/gum/command.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/gum/command.rb with RBS::Inline
+
+module Gum
+  module Command
+    def self?.run: (*untyped, ?input: untyped, ?interactive: untyped) -> untyped
+
+    def self?.run_non_interactive: (*untyped args, input: untyped) -> untyped
+
+    def self?.run_interactive: (*untyped args) -> untyped
+
+    def self?.run_interactive_with_input: (*untyped args, input: untyped) -> untyped
+
+    def self?.run_display_only: (*untyped args, input: untyped) -> untyped
+
+    def self?.run_with_status: (*untyped args, ?input: untyped) -> untyped
+
+    def self?.build_args: (untyped command, *untyped positional, **untyped options) -> untyped
+
+    def self?.add_style_args: (untyped args, untyped flag, untyped style_hash) -> untyped
+
+    def self?.flag_supports_negation?: (untyped command, untyped flag) -> untyped
+  end
+end

data/sig/gum/commands/choose.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/gum/commands/choose.rb with RBS::Inline
+
+module Gum
+  # Choose an option from a list of choices
+  #
+  # @example Single selection with array
+  #   color = Gum.choose(%w[red green blue])
+  #
+  # @example Single selection with splat
+  #   color = Gum.choose("red", "green", "blue")
+  #
+  # @example Multiple selection
+  #   colors = Gum.choose(%w[red green blue], limit: 2)
+  #
+  # @example Unlimited selection
+  #   colors = Gum.choose(%w[red green blue], no_limit: true)
+  #
+  # @example With header and custom height
+  #   choice = Gum.choose(options, header: "Pick one:", height: 10)
+  class Choose
+    # Choose from a list of options
+    #
+    # @rbs *items: Array[String] | String -- list of choices to display (array or splat)
+    # @rbs limit: Integer? -- maximum number of items that can be selected (1 = single select)
+    # @rbs no_limit: bool -- allow unlimited selections (use tab/ctrl+space to select)
+    # @rbs ordered: bool? -- maintain selection order
+    # @rbs height: Integer? -- height of the list
+    # @rbs cursor: String? -- cursor character (default: ">")
+    # @rbs header: String? -- header text displayed above choices
+    # @rbs cursor_prefix: String? -- prefix for the cursor line
+    # @rbs selected_prefix: String? -- prefix for selected items (default: "✓")
+    # @rbs unselected_prefix: String? -- prefix for unselected items (default: "○")
+    # @rbs selected: Array[String]? -- items to pre-select
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor_style: Hash[Symbol, untyped]? -- cursor style options
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style
+    # @rbs item_style: Hash[Symbol, untyped]? -- item text style
+    # @rbs selected_style: Hash[Symbol, untyped]? -- selected item style
+    # @rbs return: String | Array[String] | nil -- selected item(s), or nil if cancelled
+    def self.call: (*Array[String] | String items, ?limit: Integer?, ?no_limit: bool, ?ordered: bool?, ?height: Integer?, ?cursor: String?, ?header: String?, ?cursor_prefix: String?, ?selected_prefix: String?, ?unselected_prefix: String?, ?selected: Array[String]?, ?timeout: Integer?, ?cursor_style: Hash[Symbol, untyped]?, ?header_style: Hash[Symbol, untyped]?, ?item_style: Hash[Symbol, untyped]?, ?selected_style: Hash[Symbol, untyped]?) -> (String | Array[String] | nil)
+  end
+end

data/sig/gum/commands/confirm.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/gum/commands/confirm.rb with RBS::Inline
+
+module Gum
+  # Ask for user confirmation
+  #
+  # @example Basic confirmation
+  #   if Gum.confirm("Delete file?")
+  #     File.delete(path)
+  #   end
+  #
+  # @example With default value
+  #   proceed = Gum.confirm("Continue?", default: true)
+  #
+  # @example With custom button labels
+  #   Gum.confirm("Save changes?", affirmative: "Save", negative: "Discard")
+  class Confirm
+    # Prompt for yes/no confirmation
+    #
+    # @rbs prompt: String -- the confirmation prompt
+    # @rbs default: bool? -- default value (true = yes, false = no)
+    # @rbs affirmative: String? -- text for affirmative button (default: "Yes")
+    # @rbs negative: String? -- text for negative button (default: "No")
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style options
+    # @rbs selected_style: Hash[Symbol, untyped]? -- selected button style options
+    # @rbs unselected_style: Hash[Symbol, untyped]? -- unselected button style options
+    # @rbs return: bool -- true if confirmed, false if rejected
+    def self.call: (?String prompt, ?default: bool?, ?affirmative: String?, ?negative: String?, ?timeout: Integer?, ?prompt_style: Hash[Symbol, untyped]?, ?selected_style: Hash[Symbol, untyped]?, ?unselected_style: Hash[Symbol, untyped]?) -> bool
+  end
+end

data/sig/gum/commands/file.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/gum/commands/file.rb with RBS::Inline
+
+module Gum
+  # Pick a file from a folder
+  #
+  # @example Basic file picker
+  #   path = Gum.file
+  #
+  # @example Start from specific directory
+  #   path = Gum.file(directory: "~/Documents")
+  #
+  # @example Show hidden files
+  #   path = Gum.file(all: true)
+  #
+  # @example Only show directories
+  #   dir = Gum.file(directory_only: true)
+  class FilePicker
+    # Pick a file from the filesystem
+    #
+    # @rbs path: String? -- starting directory path
+    # @rbs cursor: String? -- cursor character
+    # @rbs all: bool? -- show hidden files and directories
+    # @rbs file: bool? -- allow file selection (default: true)
+    # @rbs directory: bool? -- allow directory selection (default: false)
+    # @rbs directory_only: bool -- only allow directory selection (convenience option)
+    # @rbs height: Integer? -- height of the file picker
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor_style: Hash[Symbol, untyped]? -- cursor style options
+    # @rbs symlink_style: Hash[Symbol, untyped]? -- symlink text style
+    # @rbs directory_style: Hash[Symbol, untyped]? -- directory text style
+    # @rbs file_style: Hash[Symbol, untyped]? -- file text style
+    # @rbs permissions_style: Hash[Symbol, untyped]? -- permissions text style
+    # @rbs selected_style: Hash[Symbol, untyped]? -- selected item style
+    # @rbs file_size_style: Hash[Symbol, untyped]? -- file size text style
+    # @rbs return: String? -- selected file path, or nil if cancelled
+    def self.call: (?String? path, ?cursor: String?, ?all: bool?, ?file: bool?, ?directory: bool?, ?directory_only: bool, ?height: Integer?, ?timeout: Integer?, ?cursor_style: Hash[Symbol, untyped]?, ?symlink_style: Hash[Symbol, untyped]?, ?directory_style: Hash[Symbol, untyped]?, ?file_style: Hash[Symbol, untyped]?, ?permissions_style: Hash[Symbol, untyped]?, ?selected_style: Hash[Symbol, untyped]?, ?file_size_style: Hash[Symbol, untyped]?) -> String?
+  end
+end

data/sig/gum/commands/filter.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/gum/commands/filter.rb with RBS::Inline
+
+module Gum
+  # Filter items from a list with fuzzy matching
+  #
+  # @example Single selection filter with array
+  #   file = Gum.filter(Dir.glob("*"))
+  #
+  # @example Single selection filter with splat
+  #   file = Gum.filter("file1.rb", "file2.rb", "file3.rb")
+  #
+  # @example Multiple selection filter
+  #   files = Gum.filter(Dir.glob("*"), limit: 5)
+  #
+  # @example With placeholder and height
+  #   selection = Gum.filter(items, placeholder: "Search...", height: 20)
+  class Filter
+    # Filter a list with fuzzy matching
+    #
+    # @rbs *items: Array[String] | String -- list of items to filter (array or splat)
+    # @rbs limit: Integer? -- maximum number of items that can be selected
+    # @rbs no_limit: bool -- allow unlimited selections (use tab/ctrl+space to select)
+    # @rbs height: Integer? -- height of the list
+    # @rbs width: Integer? -- width of the filter input
+    # @rbs placeholder: String? -- placeholder text for the filter input
+    # @rbs prompt: String? -- prompt string shown before input
+    # @rbs value: String? -- initial filter value
+    # @rbs header: String? -- header text displayed above the list
+    # @rbs indicator: String? -- character for selected item indicator
+    # @rbs selected_prefix: String? -- prefix for selected items
+    # @rbs unselected_prefix: String? -- prefix for unselected items
+    # @rbs match_prefix: String? -- prefix for matched text
+    # @rbs fuzzy: bool? -- enable fuzzy matching (default: true)
+    # @rbs sort: bool? -- sort results by match score (default: true)
+    # @rbs strict: bool? -- require exact match
+    # @rbs reverse: bool? -- reverse the order of results
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style
+    # @rbs text_style: Hash[Symbol, untyped]? -- text style for items
+    # @rbs cursor_text_style: Hash[Symbol, untyped]? -- style for cursor line text
+    # @rbs match_style: Hash[Symbol, untyped]? -- style for matched characters
+    # @rbs placeholder_style: Hash[Symbol, untyped]? -- placeholder text style
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style
+    # @rbs indicator_style: Hash[Symbol, untyped]? -- indicator character style
+    # @rbs return: String | Array[String] | nil -- selected item(s), or nil if cancelled
+    def self.call: (*Array[String] | String items, ?limit: Integer?, ?no_limit: bool, ?height: Integer?, ?width: Integer?, ?placeholder: String?, ?prompt: String?, ?value: String?, ?header: String?, ?indicator: String?, ?selected_prefix: String?, ?unselected_prefix: String?, ?match_prefix: String?, ?fuzzy: bool?, ?sort: bool?, ?strict: bool?, ?reverse: bool?, ?timeout: Integer?, ?header_style: Hash[Symbol, untyped]?, ?text_style: Hash[Symbol, untyped]?, ?cursor_text_style: Hash[Symbol, untyped]?, ?match_style: Hash[Symbol, untyped]?, ?placeholder_style: Hash[Symbol, untyped]?, ?prompt_style: Hash[Symbol, untyped]?, ?indicator_style: Hash[Symbol, untyped]?) -> (String | Array[String] | nil)
+  end
+end

data/sig/gum/commands/format.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/gum/commands/format.rb with RBS::Inline
+
+module Gum
+  # Format text with markdown, code highlighting, templates, or emojis
+  #
+  # @example Markdown formatting
+  #   Gum.format("# Hello\n- Item 1\n- Item 2")
+  #
+  # @example Code highlighting
+  #   Gum.format(code, type: :code, language: "ruby")
+  #
+  # @example Template formatting
+  #   Gum.format('{{ Bold "Hello" }} {{ Color "99" "0" " World " }}', type: :template)
+  #
+  # @example Emoji formatting
+  #   Gum.format("I :heart: Ruby :gem:", type: :emoji)
+  class Format
+    TYPES: Array[Symbol]
+
+    # Format and render text
+    #
+    # @rbs *text: String -- text content to format (multiple strings joined with newlines)
+    # @rbs type: Symbol | String | nil -- format type (:markdown, :code, :template, :emoji)
+    # @rbs language: String? -- programming language for code highlighting
+    # @rbs theme: String? -- syntax highlighting theme
+    # @rbs return: String? -- formatted text output
+    def self.call: (*String text, ?type: Symbol | String | nil, ?language: String?, ?theme: String?) -> String?
+
+    # @rbs text: String -- markdown text to format
+    # @rbs return: String? -- rendered markdown output
+    def self.markdown: (String text) -> String?
+
+    # @rbs text: String -- source code to highlight
+    # @rbs language: String? -- programming language for highlighting
+    # @rbs theme: String? -- syntax highlighting theme
+    # @rbs return: String? -- syntax-highlighted code output
+    def self.code: (String text, ?language: String?, ?theme: String?) -> String?
+
+    # @rbs text: String -- template string with Termenv helpers
+    # @rbs return: String? -- rendered template output
+    def self.template: (String text) -> String?
+
+    # @rbs text: String -- text with :emoji_name: codes
+    # @rbs return: String? -- text with emojis rendered
+    def self.emoji: (String text) -> String?
+  end
+end

data/sig/gum/commands/input.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/gum/commands/input.rb with RBS::Inline
+
+module Gum
+  # Prompt for single-line input
+  #
+  # @example Basic input
+  #   name = Gum.input(placeholder: "Enter your name")
+  #
+  # @example Password input
+  #   password = Gum.input(password: true)
+  #
+  # @example With default value and custom prompt
+  #   email = Gum.input(value: "user@", prompt: "> ", placeholder: "email")
+  class Input
+    # Prompt for single-line input
+    #
+    # @rbs placeholder: String? -- placeholder text shown when input is empty
+    # @rbs prompt: String? -- prompt string shown before input
+    # @rbs value: String? -- initial value for the input
+    # @rbs char_limit: Integer? -- maximum number of characters allowed
+    # @rbs width: Integer? -- width of the input field
+    # @rbs password: bool -- mask input characters for password entry
+    # @rbs header: String? -- header text displayed above the input
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs cursor: Hash[Symbol, untyped]? -- cursor style options (foreground, background)
+    # @rbs prompt_style: Hash[Symbol, untyped]? -- prompt text style options
+    # @rbs placeholder_style: Hash[Symbol, untyped]? -- placeholder text style options
+    # @rbs header_style: Hash[Symbol, untyped]? -- header text style options
+    # @rbs return: String? -- the entered text, or nil if cancelled
+    def self.call: (?placeholder: String?, ?prompt: String?, ?value: String?, ?char_limit: Integer?, ?width: Integer?, ?password: bool, ?header: String?, ?timeout: Integer?, ?cursor: Hash[Symbol, untyped]?, ?prompt_style: Hash[Symbol, untyped]?, ?placeholder_style: Hash[Symbol, untyped]?, ?header_style: Hash[Symbol, untyped]?) -> String?
+  end
+end

data/sig/gum/commands/join.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/gum/commands/join.rb with RBS::Inline
+
+module Gum
+  # Join text blocks horizontally or vertically
+  #
+  # @example Horizontal join (default)
+  #   combined = Gum.join(box1, box2)
+  #
+  # @example Vertical join
+  #   stacked = Gum.join(box1, box2, vertical: true)
+  #
+  # @example With alignment
+  #   aligned = Gum.join(box1, box2, vertical: true, align: :center)
+  class Join
+    # Join text blocks together
+    #
+    # @rbs *texts: String -- text blocks to join (usually styled with Gum.style)
+    # @rbs vertical: bool -- stack blocks vertically (default: false, horizontal)
+    # @rbs horizontal: bool -- place blocks side by side (default)
+    # @rbs align: Symbol | String | nil -- alignment (:left, :center, :right for vertical; :top, :middle, :bottom for horizontal)
+    # @rbs return: String? -- combined text output
+    def self.call: (*String texts, ?vertical: bool, ?horizontal: bool, ?align: Symbol | String | nil) -> String?
+  end
+end

data/sig/gum/commands/log.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/gum/commands/log.rb with RBS::Inline
+
+module Gum
+  # Log messages with different levels and formatting
+  #
+  # @example Basic logging
+  #   Gum.log("Application started", level: :info)
+  #
+  # @example Structured logging with key-value pairs
+  #   Gum.log("User created", level: :info, user_id: 123, email: "user@example.com")
+  #
+  # @example With timestamp
+  #   Gum.log("Error occurred", level: :error, time: :rfc822)
+  class Log
+    LEVELS: Array[Symbol]
+
+    TIME_FORMATS: Array[Symbol]
+
+    # Log a message
+    #
+    # @rbs message: String -- log message text
+    # @rbs level: Symbol | String | nil -- log level (:debug, :info, :warn, :error, :fatal, :none)
+    # @rbs time: Symbol | String | nil -- time format (:rfc822, :rfc3339, :kitchen, etc.) or custom Go time format
+    # @rbs structured: bool? -- output structured log format (key=value pairs)
+    # @rbs formatter: Symbol | String | nil -- log formatter (:text, :json, :logfmt)
+    # @rbs prefix: String? -- log message prefix
+    # @rbs **fields: untyped -- additional key-value fields for structured logging
+    # @rbs return: String? -- formatted log output
+    def self.call: (String message, ?level: Symbol | String | nil, ?time: Symbol | String | nil, ?structured: bool?, ?formatter: Symbol | String | nil, ?prefix: String?, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted debug log output
+    def self.debug: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted info log output
+    def self.info: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted warn log output
+    def self.warn: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted error log output
+    def self.error: (String message, **untyped fields) -> String?
+
+    # @rbs message: String -- log message text
+    # @rbs **fields: untyped -- additional key-value fields
+    # @rbs return: String? -- formatted fatal log output
+    def self.fatal: (String message, **untyped fields) -> String?
+  end
+end

data/sig/gum/commands/pager.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/gum/commands/pager.rb with RBS::Inline
+
+module Gum
+  # Scroll through content in a pager
+  #
+  # @example View file content
+  #   Gum.pager(File.read("README.md"))
+  #
+  # @example With line numbers
+  #   Gum.pager(content, show_line_numbers: true)
+  #
+  # @example Soft wrap long lines
+  #   Gum.pager(content, soft_wrap: true)
+  class Pager
+    # Display content in a scrollable pager
+    #
+    # @rbs content: String -- content to display in the pager
+    # @rbs show_line_numbers: bool? -- display line numbers
+    # @rbs soft_wrap: bool? -- wrap long lines instead of horizontal scrolling
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs help_style: Hash[Symbol, untyped]? -- help text style
+    # @rbs line_number_style: Hash[Symbol, untyped]? -- line number style
+    # @rbs match_style: Hash[Symbol, untyped]? -- search match style
+    # @rbs match_highlight_style: Hash[Symbol, untyped]? -- current search match highlight style
+    # @rbs return: void
+    def self.call: (String content, ?show_line_numbers: bool?, ?soft_wrap: bool?, ?timeout: Integer?, ?help_style: Hash[Symbol, untyped]?, ?line_number_style: Hash[Symbol, untyped]?, ?match_style: Hash[Symbol, untyped]?, ?match_highlight_style: Hash[Symbol, untyped]?) -> void
+  end
+end

data/sig/gum/commands/spin.rbs

@@ -0,0 +1,55 @@
+# Generated from lib/gum/commands/spin.rb with RBS::Inline
+
+module Gum
+  # Display a spinner while running a command or block
+  #
+  # @example With shell command
+  #   Gum.spin("Installing...", command: "npm install")
+  #
+  # @example With Ruby block
+  #   result = Gum.spin("Processing...") do
+  #     # long running operation
+  #     expensive_computation
+  #   end
+  #
+  # @example Custom spinner type
+  #   Gum.spin("Loading...", spinner: :dot, command: "sleep 5")
+  class Spin
+    SPINNERS: Array[Symbol]
+
+    # Display a spinner while running a command or block
+    #
+    # @rbs title: String -- spinner title text (default: "Loading...")
+    # @rbs command: String? -- shell command to execute
+    # @rbs spinner: Symbol | String | nil -- spinner type (see SPINNERS constant)
+    # @rbs show_output: bool? -- show command stdout after completion
+    # @rbs show_error: bool? -- show command stderr after completion
+    # @rbs align: Symbol? -- alignment of spinner and title (:left, :right)
+    # @rbs timeout: Integer? -- timeout in seconds (0 = no timeout)
+    # @rbs spinner_style: Hash[Symbol, untyped]? -- spinner animation style
+    # @rbs title_style: Hash[Symbol, untyped]? -- title text style
+    # @rbs &block: ^() -> untyped | nil -- Ruby block to execute (alternative to command)
+    # @rbs return: String | untyped | nil -- command output or block result, nil if cancelled
+    def self.call: (?String title, ?command: String?, ?spinner: Symbol | String | nil, ?show_output: bool?, ?show_error: bool?, ?align: Symbol?, ?timeout: Integer?, ?spinner_style: Hash[Symbol, untyped]?, ?title_style: Hash[Symbol, untyped]?) ?{ (?) -> untyped } -> (String | untyped | nil)
+
+    # @rbs title: String -- spinner title text
+    # @rbs command: String -- shell command to execute
+    # @rbs spinner: Symbol | String | nil -- spinner type
+    # @rbs show_output: bool? -- show command stdout
+    # @rbs show_error: bool? -- show command stderr
+    # @rbs align: Symbol? -- alignment of spinner
+    # @rbs timeout: Integer? -- timeout in seconds
+    # @rbs spinner_style: Hash[Symbol, untyped]? -- spinner animation style
+    # @rbs title_style: Hash[Symbol, untyped]? -- title text style
+    # @rbs return: bool? -- true if command succeeded, false/nil otherwise
+    def self.run_with_command: (String title, command: String, spinner: Symbol | String | nil, show_output: bool?, show_error: bool?, align: Symbol?, timeout: Integer?, spinner_style: Hash[Symbol, untyped]?, title_style: Hash[Symbol, untyped]?) -> bool?
+
+    # @rbs title: String -- spinner title text
+    # @rbs spinner: Symbol | String | nil -- spinner type
+    # @rbs spinner_style: Hash[Symbol, untyped]? -- spinner animation style
+    # @rbs title_style: Hash[Symbol, untyped]? -- title text style
+    # @rbs &block: ^() -> untyped -- Ruby block to execute
+    # @rbs return: untyped -- block result
+    def self.run_with_block: (String title, spinner: Symbol | String | nil, spinner_style: Hash[Symbol, untyped]?, title_style: Hash[Symbol, untyped]?) ?{ (?) -> untyped } -> untyped
+  end
+end

data/sig/gum/commands/style.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/gum/commands/style.rb with RBS::Inline
+
+module Gum
+  # Apply styling to text
+  #
+  # @example Basic styling
+  #   styled = Gum.style("Hello", foreground: "212", bold: true)
+  #
+  # @example With border
+  #   box = Gum.style("Content", border: :double, padding: "1 2")
+  #
+  # @example Multiple lines
+  #   styled = Gum.style("Line 1", "Line 2", align: :center, width: 50)
+  class Style
+    BORDERS: Array[Symbol]
+
+    ALIGNMENTS: Array[Symbol]
+
+    # Apply styling to text
+    #
+    # @rbs *text: String -- text content to style (multiple strings become separate lines)
+    # @rbs foreground: String | Integer | nil -- text color (ANSI code, hex, or color name)
+    # @rbs background: String | Integer | nil -- background color (ANSI code, hex, or color name)
+    # @rbs border: Symbol | String | nil -- border style (:none, :hidden, :rounded, :double, :thick, :normal)
+    # @rbs border_foreground: String | Integer | nil -- border color
+    # @rbs border_background: String | Integer | nil -- border background color
+    # @rbs align: Symbol | String | nil -- text alignment (:left, :center, :right)
+    # @rbs height: Integer? -- fixed height in lines
+    # @rbs width: Integer? -- fixed width in characters
+    # @rbs margin: String | Array[Integer] | nil -- margin around the box ("1" or "1 2" or [1, 2, 1, 2])
+    # @rbs padding: String | Array[Integer] | nil -- padding inside the box ("1" or "1 2" or [1, 2, 1, 2])
+    # @rbs bold: bool? -- bold text
+    # @rbs italic: bool? -- italic text
+    # @rbs strikethrough: bool? -- strikethrough text
+    # @rbs underline: bool? -- underlined text
+    # @rbs faint: bool? -- faint/dim text
+    # @rbs return: String? -- styled text output
+    def self.call: (*String text, ?foreground: String | Integer | nil, ?background: String | Integer | nil, ?border: Symbol | String | nil, ?border_foreground: String | Integer | nil, ?border_background: String | Integer | nil, ?align: Symbol | String | nil, ?height: Integer?, ?width: Integer?, ?margin: String | Array[Integer] | nil, ?padding: String | Array[Integer] | nil, ?bold: bool?, ?italic: bool?, ?strikethrough: bool?, ?underline: bool?, ?faint: bool?) -> String?
+
+    # @rbs value: String | Integer | Array[Integer] | nil -- spacing value to format
+    # @rbs return: String? -- formatted spacing string
+    def self.format_spacing: (String | Integer | Array[Integer] | nil value) -> String?
+  end
+end