smol 1.0.0

data/lib/smol/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Smol
+  class Config
+    include Coercion
+
+    def initialize
+      @settings = {}
+      @values = {}
+    end
+
+    def setting(key, default:, type: :string, desc: nil)
+      @settings[key] = { default: default, type: type, desc: desc }
+    end
+
+    def [](key)
+      return @values[key] if @values.key?(key)
+
+      setting = @settings[key]
+      raise ArgumentError, "unknown config key: #{key}" unless setting
+
+      env_key = key.to_s.upcase
+      raw = ENV.fetch(env_key, setting[:default].to_s)
+
+      @values[key] = coerce_value(raw, setting[:type])
+    end
+
+    def set(key, value)
+      raise ArgumentError, "unknown config key: #{key}" unless @settings.key?(key)
+
+      @values[key] = coerce_value(value.to_s, @settings[key][:type])
+    end
+
+    def settings
+      @settings.dup
+    end
+
+    def to_h
+      @settings.keys.each_with_object({}) { |k, h| h[k] = self[k] }
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+
+      @settings.each_key { |k| yield k, self[k], @settings[k] }
+    end
+  end
+end

data/lib/smol/config_display.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Smol
+  module ConfigDisplay
+    include Output
+    using Colors
+
+    private
+
+    def show_config
+      out.puts "config:".bold
+      @app.config.each do |key, value, setting|
+        line = "  #{key}: #{value}"
+        line += " - #{setting[:desc]}" if setting[:desc]
+        out.puts line.dim
+      end
+    end
+
+    def set_config(key, value)
+      if key.nil? || value.nil?
+        warning "usage: config:set <key> <value>"
+        return
+      end
+
+      @app.config.set(key.to_sym, value)
+      success "#{key} = #{@app.config[key.to_sym]}"
+    rescue ArgumentError => e
+      failure e.message
+    end
+  end
+end

data/lib/smol/input.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Smol
+  module Input
+    using Colors
+    extend self
+
+    def confirm(question, default: nil)
+      hint = case default
+             when true then "[Y/n]"
+             when false then "[y/N]"
+             else "[y/n]"
+             end
+
+      Smol.output.print "#{question} #{hint} ".yellow
+      response = Smol.input.gets&.strip&.downcase
+
+      case response
+      when "", nil
+        default
+      when "y", "yes"
+        true
+      when "n", "no"
+        false
+      else
+        default
+      end
+    end
+
+    def ask(question, default: nil)
+      prompt = default ? "#{question} [#{default}]" : question
+      Smol.output.print "#{prompt}: ".yellow
+      response = Smol.input.gets&.strip
+
+      if response.nil? || response.empty?
+        default
+      else
+        response
+      end
+    end
+
+    def choose(question, choices, default: nil)
+      Smol.output.puts question.yellow
+      choices.each_with_index do |choice, i|
+        marker = (i + 1) == default ? "*" : " "
+        Smol.output.puts "#{marker} #{i + 1}) #{choice}"
+      end
+
+      Smol.output.print "choice: ".yellow
+      response = Smol.input.gets&.strip
+
+      if response.nil? || response.empty?
+        default ? choices[default - 1] : nil
+      else
+        idx = response.to_i - 1
+        idx >= 0 && idx < choices.size ? choices[idx] : nil
+      end
+    end
+  end
+end

data/lib/smol/output.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Smol
+  module Output
+    using Colors
+    extend self
+
+    def out
+      Smol.output
+    end
+
+    def banner(text)
+      out.puts text.red
+    end
+
+    def header(text)
+      out.puts text.bold
+    end
+
+    def desc(text)
+      out.puts text.dim
+    end
+
+    def nl
+      out.puts
+    end
+
+    def info(text)
+      out.puts text
+    end
+
+    def success(text)
+      out.puts text.green.bold
+    end
+
+    def failure(text)
+      out.puts text.red.bold
+    end
+
+    def warning(text)
+      out.puts text.yellow
+    end
+
+    def hint(text)
+      out.puts text.dim
+    end
+
+    def label(text)
+      out.puts text.yellow
+    end
+
+    def verbose(text)
+      return unless Smol.verbose?
+
+      out.puts text.dim
+    end
+
+    def debug(text)
+      return unless Smol.debug?
+
+      out.puts "[debug] #{text}".dim
+    end
+
+    def check_result(name, result)
+      status = result.passed? ? "pass".green.bold : "fail".red.bold
+      out.puts "#{status}: #{name}"
+      out.puts "      #{result.message}"
+    end
+
+    def table(rows, headers: nil, indent: 0)
+      return if rows.empty?
+
+      all_rows = headers ? [headers] + rows : rows
+      col_widths = table_column_widths(all_rows)
+      prefix = " " * indent
+
+      if headers
+        header_line = table_format_row(headers, col_widths)
+        out.puts "#{prefix}#{header_line}".bold
+        out.puts "#{prefix}#{"-" * header_line.length}"
+      end
+
+      rows.each do |row|
+        out.puts "#{prefix}#{table_format_row(row, col_widths)}"
+      end
+    end
+
+    private
+
+    def table_column_widths(rows)
+      return [] if rows.empty?
+
+      num_cols = rows.map(&:size).max
+      (0...num_cols).map do |i|
+        rows.map { |row| row[i].to_s.length }.max
+      end
+    end
+
+    def table_format_row(row, widths)
+      row.each_with_index.map do |cell, i|
+        cell.to_s.ljust(widths[i] || 0)
+      end.join("  ")
+    end
+  end
+end

data/lib/smol/repl.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module Smol
+  class REPL
+    include Output
+    include ConfigDisplay
+    using Colors
+
+    def initialize(app, prompt:, history: true, history_file: nil, parent: nil)
+      @app = app
+      @prompt = prompt
+      @history = history
+      @history_file = history_file || File.expand_path("~/.smol_#{prompt}_history")
+      @parent = parent
+    end
+
+    def run
+      setup_readline if @history
+      load_history if @history
+
+      show_boot_message
+
+      loop do
+        input = read_input
+        break if input.nil?
+
+        input = input.strip
+        next if input.empty?
+
+        args = input.split(/\s+/)
+
+        case args.first
+        when "exit", "quit", "q"
+          break
+        when "back"
+          break if @parent
+          warning "not in a sub-app"
+        when "help", "h", "?"
+          help
+        when "config", "c"
+          show_config
+        when "config:set"
+          set_config(args[1], args[2])
+        else
+          # Check if entering a mounted sub-app
+          mount = @app.find_mount(args.first)
+          if mount && args.size == 1
+            enter_subapp(mount, args.first)
+          else
+            dispatch(args)
+          end
+        end
+
+        nl
+      end
+
+      save_history if @history
+      hint "goodbye"
+    end
+
+    private
+
+    def show_boot_message
+      case @app.boot
+      when :help
+        show_boot_help
+      when :minimal
+        show_boot_minimal
+      when :none
+        # nothing
+      else
+        show_boot_help
+      end
+    end
+
+    def show_boot_help
+      banner @app.banner
+      nl
+      info @prompt.bold + " - interactive mode"
+      nl
+      help
+      nl
+      show_config
+      nl
+    end
+
+    def show_boot_minimal
+      banner @app.banner
+      nl
+      info @prompt.bold + " - interactive mode"
+      hint "type 'help' for commands, 'exit' to quit"
+      nl
+      show_config
+      nl
+    end
+
+    def enter_subapp(app_class, name)
+      sub_repl = REPL.new(
+        app_class,
+        prompt: "#{@prompt}:#{name}",
+        history: false,
+        parent: self
+      )
+      sub_repl.run
+    end
+
+    def dispatch(args)
+      cmd_name, *cmd_args = args
+      klass = @app.find_command(cmd_name)
+
+      if klass.nil?
+        warning "unknown command: #{cmd_name}"
+        hint "type 'help' for available commands"
+        return
+      end
+
+      positional, opts = klass.parse_options(cmd_args)
+
+      if klass.args.size > positional.size
+        warning "usage: #{klass.usage}"
+        return
+      end
+
+      klass.new.call(*positional, **opts)
+    end
+
+    def help
+      out.puts "commands:".bold
+
+      grouped = @app.commands.group_by(&:group)
+      ungrouped = grouped.delete(nil) || []
+
+      ungrouped.each do |cmd|
+        print_command(cmd)
+      end
+
+      grouped.keys.sort.each do |group_name|
+        nl
+        out.puts "  #{group_name}:".bold
+        grouped[group_name].each do |cmd|
+          print_command(cmd, indent: 2)
+        end
+      end
+
+      if @app.mounts.any?
+        nl
+        out.puts "  sub-apps:".bold
+        @app.mounts.each do |name, app_class|
+          out.puts "    #{name.ljust(28)}enter #{app_class.banner.empty? ? name : app_class.banner}"
+        end
+      end
+
+      nl
+      out.puts "  config, c".ljust(32) + "show current config"
+      out.puts "  config:set <key> <value>".ljust(32) + "set a config value"
+      out.puts "  help, h, ?".ljust(32) + "show this help"
+      out.puts "  back".ljust(32) + "return to parent app" if @parent
+      out.puts "  exit, quit, q".ljust(32) + "exit"
+    end
+
+    def print_command(cmd, indent: 0)
+      prefix = "  " * (indent + 1)
+      out.puts "#{prefix}#{cmd.usage.ljust(30 - indent * 2)}#{cmd.desc}"
+      out.puts "#{prefix}  aliases: #{cmd.aliases.join(', ')}".dim if cmd.aliases.any?
+    end
+
+    def setup_readline
+      Readline.completion_proc = proc do |input|
+        commands = @app.commands.flat_map { |c| [c.command_name.to_s] + c.aliases.map(&:to_s) }
+        builtins = %w[help h ? config c config:set exit quit q]
+        (commands + builtins).grep(/^#{Regexp.escape(input)}/)
+      end
+    end
+
+    def load_history
+      return unless File.exist?(@history_file)
+
+      File.readlines(@history_file).each do |line|
+        Readline::HISTORY << line.chomp
+      end
+    rescue StandardError
+      # ignore history load errors
+    end
+
+    def save_history
+      File.open(@history_file, "w") do |f|
+        Readline::HISTORY.to_a.last(1000).each do |line|
+          f.puts line
+        end
+      end
+    rescue StandardError
+      # ignore history save errors
+    end
+
+    def read_input
+      if @history
+        prompt_str = "#{@prompt}> "
+        line = Readline.readline(prompt_str, true)
+        Readline::HISTORY.pop if line&.strip&.empty?
+        line
+      else
+        Smol.output.print "#{@prompt}> ".yellow
+        Smol.input.gets
+      end
+    end
+  end
+end

data/lib/smol/version.rb

@@ -0,0 +1,3 @@
+module Smol
+  VERSION = "1.0.0"
+end

data/lib/smol.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "logger"
+require "readline"
+
+require "smol/version"
+require "smol/colors"
+require "smol/coercion"
+require "smol/app_lookup"
+require "smol/check_result"
+require "smol/output"
+require "smol/input"
+require "smol/config"
+require "smol/config_display"
+require "smol/check"
+require "smol/command"
+require "smol/app"
+require "smol/repl"
+require "smol/cli"
+
+module Smol
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :output, :input, :logger, :verbose, :quiet
+
+    def output
+      @output ||= $stdout
+    end
+
+    def input
+      @input ||= $stdin
+    end
+
+    def logger
+      @logger ||= Logger.new($stderr, level: Logger::WARN)
+    end
+
+    def verbose?
+      @verbose || ENV["VERBOSE"] == "1" || ENV["VERBOSE"] == "true"
+    end
+
+    def quiet?
+      @quiet || ENV["QUIET"] == "1" || ENV["QUIET"] == "true"
+    end
+
+    def debug?
+      @debug || ENV["DEBUG"] == "1" || ENV["DEBUG"] == "true"
+    end
+
+    def debug=(value)
+      @debug = value
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: smol
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Josh Brody
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: readline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Build CLI tools with commands, checks, and configuration. Supports both
+  single-command execution and interactive REPL mode.
+email:
+- gems@josh.mn
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/smol.rb
+- lib/smol/app.rb
+- lib/smol/app_lookup.rb
+- lib/smol/check.rb
+- lib/smol/check_result.rb
+- lib/smol/cli.rb
+- lib/smol/coercion.rb
+- lib/smol/colors.rb
+- lib/smol/command.rb
+- lib/smol/config.rb
+- lib/smol/config_display.rb
+- lib/smol/input.rb
+- lib/smol/output.rb
+- lib/smol/repl.rb
+- lib/smol/version.rb
+homepage: https://github.com/joshmn/smol
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/joshmn/smol
+  source_code_uri: https://github.com/joshmn/smol
+  changelog_uri: https://github.com/joshmn/smol/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.1
+specification_version: 4
+summary: A small, zero-dependency CLI and REPL framework for Ruby
+test_files: []