riffer-rig 0.6.0 → 0.7.0

data/lib/riffer/rig/{ui → terminal}/renderer.rb

@@ -2,31 +2,34 @@
 
 require 'json'
 
-class Riffer::Rig::UI::Renderer
+class Riffer::Rig::Terminal::Renderer
   RESULT_PREVIEW_LIMIT = 200 #: Integer
 
   # @rbs @io: IO
-  # @rbs @theme: Riffer::Rig::UI::Theme
-  # @rbs @tally: Riffer::Rig::TokenTally?
-  # @rbs @smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
-  # @rbs @deferred_usage: Riffer::Providers::TokenUsage?
+  # @rbs @theme: Riffer::Rig::Terminal::Theme
+  # @rbs @smoother: Riffer::Rig::Terminal::Smoother | PassThroughSmoother
+  # @rbs @cursor: Riffer::Rig::Terminal::Cursor
   # @rbs @prose_gap_pending: bool
 
   # @rbs io: IO
-  # @rbs theme: Riffer::Rig::UI::Theme
-  # @rbs tally: Riffer::Rig::TokenTally?
-  # @rbs smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
+  # @rbs theme: Riffer::Rig::Terminal::Theme
+  # @rbs smoother: Riffer::Rig::Terminal::Smoother | PassThroughSmoother
+  # @rbs cursor: Riffer::Rig::Terminal::Cursor
   # @rbs return: void
-  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io), tally: nil, smoother: nil)
+  def initialize(
+    io: $stdout,
+    theme: Riffer::Rig::Terminal::Theme.for(io),
+    smoother: PassThroughSmoother.new(io),
+    cursor: Riffer::Rig::Terminal::Cursor.new(io: io, theme: theme)
+  )
     @io = io
     @theme = theme
-    @tally = tally
     @smoother = smoother
-    @deferred_usage = nil
+    @cursor = cursor
     @prose_gap_pending = false
   end
 
-  # @rbs event: Riffer::StreamEvents::Base
+  # @rbs event: Riffer::StreamEvents::TextDelta | Riffer::StreamEvents::ToolCallDone | Riffer::StreamEvents::Interrupt
   # @rbs return: void
   def render(event)
     case event
@@ -34,19 +37,45 @@ class Riffer::Rig::UI::Renderer
       render_prose(event.content)
     when Riffer::StreamEvents::ToolCallDone
       render_tool_activity(2) { @theme.cyan("⚙ #{event.name}(#{format_arguments(event.arguments)})") }
-    when Riffer::StreamEvents::SkillActivation
-      render_block(0) { @theme.magenta("✦ skill: #{event.name}") }
     when Riffer::StreamEvents::Interrupt
       render_block(0) { @theme.dim("[interrupted: #{event.reason}]") }
-    when Riffer::StreamEvents::TokenUsageDone
-      # Usage arrives per model call but tool results arrive via the session
-      # callback after each call's stream ends, so rendering inline would print
-      # the stats above the results they belong with.
-      current = @deferred_usage
-      @deferred_usage = current ? current + event.token_usage : event.token_usage
     end
   end
 
+  # @rbs name: String
+  # @rbs return: void
+  def skill(name)
+    render_block(0) { @theme.magenta("✦ skill: #{name}") }
+  end
+
+  # @rbs text: String
+  # @rbs return: void
+  def notice(text)
+    render_block(0) { @theme.grey(text) }
+  end
+
+  # @rbs text: String
+  # @rbs return: void
+  def error(text)
+    render_block(0) { @theme.red(text) }
+  end
+
+  # @rbs message: String
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(message, level)
+    level == :error ? error(message) : notice(message)
+  end
+
+  # @rbs usage: Riffer::Providers::TokenUsage?
+  # @rbs session: Riffer::Providers::TokenUsage?
+  # @rbs return: void
+  def usage(usage, session)
+    return unless usage && session
+
+    render_block(0) { @theme.dim(usage_line(usage, session)) }
+  end
+
   # @rbs return: void
   def prompt
     # Closes any tool group the previous turn left open, so the next turn's
@@ -57,15 +86,42 @@ class Riffer::Rig::UI::Renderer
     @io.flush
   end
 
+  # @rbs question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
   # @rbs return: void
-  def flush_usage
-    usage = @deferred_usage
-    @deferred_usage = nil
-    tally = @tally
-    return unless usage && tally
+  def question(question, options, secret)
+    drain
+    @io.puts
+    @io.puts(question) if question
+    options&.each_with_index { |option, index| @io.puts("  #{@theme.magenta("#{index + 1}.")} #{option}") }
+    @io.print("#{@theme.pink('›')} #{@theme.grey('(hidden) ') if secret}")
+    @io.flush
+  end
 
-    tally.add(usage)
-    render_block(0) { @theme.dim(usage_line(usage, tally)) }
+  # @rbs return: void
+  def newline
+    @io.puts
+    @io.flush
+  end
+
+  # @rbs return: void
+  def begin_turn
+    # A hidden cursor can't flicker against the animator's erase-and-redraw
+    # churn.
+    @cursor.hide
+    @smoother.start
+  end
+
+  # @rbs return: void
+  def end_turn
+    @smoother.finish
+    @cursor.show
+  end
+
+  # @rbs return: void
+  def drain
+    @smoother.drain
   end
 
   # @rbs message: Riffer::Messages::Base
@@ -80,13 +136,38 @@ class Riffer::Rig::UI::Renderer
     @io.flush
   end
 
+  class PassThroughSmoother
+    # @rbs @io: IO
+
+    # @rbs io: IO
+    # @rbs return: void
+    def initialize(io) = @io = io
+
+    # @rbs content: String
+    # @rbs return: self
+    def <<(content)
+      @io.print(content)
+      @io.flush
+      self
+    end
+
+    # @rbs return: nil
+    def start = nil
+
+    # @rbs return: nil
+    def drain = nil
+
+    # @rbs return: nil
+    def finish = nil
+  end
+
   private
 
   # @rbs indent: Integer
   # @rbs &block: () -> String
   # @rbs return: void
   def render_block(indent, &)
-    drain_smoother
+    drain
     @io.puts
     @prose_gap_pending = true
     @io.puts((' ' * indent) + yield)
@@ -102,7 +183,7 @@ class Riffer::Rig::UI::Renderer
       @prose_gap_pending = false
       @io.print("\n")
     end
-    smoother << content
+    @smoother << content
   end
 
   # @rbs indent: Integer
@@ -120,57 +201,25 @@ class Riffer::Rig::UI::Renderer
     # group; the group stays open so the prose after it pays the closing gap.
     return if @prose_gap_pending
 
-    drain_smoother
+    drain
     @io.puts
     @prose_gap_pending = true
   end
 
   # @rbs usage: Riffer::Providers::TokenUsage
-  # @rbs tally: Riffer::Rig::TokenTally
+  # @rbs session: Riffer::Providers::TokenUsage
   # @rbs return: String
-  def usage_line(usage, tally)
+  def usage_line(usage, session)
     parts = ["↑#{usage.input_tokens}", "↓#{usage.output_tokens}"]
     parts << "cache_write:#{usage.cache_write_tokens}" if usage.cache_write_tokens&.positive?
     parts << "cache_read:#{usage.cache_read_tokens}" if usage.cache_read_tokens&.positive?
-    parts << "session #{tally.total_tokens} tok"
-    cost = tally.estimated_cost
+    parts << "session #{session.total_tokens} tok"
+    cost = session.cost
     parts << format('~$%.4f', cost) if cost
 
     parts.join(' · ')
   end
 
-  # @rbs return: Riffer::Rig::UI::Smoother | PassThroughSmoother
-  def smoother
-    @smoother || PassThroughSmoother.new(@io)
-  end
-
-  class PassThroughSmoother
-    # @rbs @io: IO
-
-    # @rbs io: IO
-    # @rbs return: void
-    def initialize(io) = @io = io
-
-    # @rbs content: String
-    # @rbs return: self
-    def <<(content)
-      @io.print(content)
-      @io.flush
-      self
-    end
-
-    # @rbs return: nil
-    def drain = nil
-
-    # @rbs return: nil
-    def finish = nil
-  end
-
-  # @rbs return: void
-  def drain_smoother
-    smoother.drain
-  end
-
   # @rbs arguments: String
   # @rbs return: String
   def format_arguments(arguments)

data/lib/riffer/rig/{ui → terminal}/smoother.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::UI::Smoother
+class Riffer::Rig::Terminal::Smoother
   TICK_SECONDS = 1.0 / 60.0 #: Float
 
   # Releasing a fraction of the backlog, not a fixed rate, makes the reveal an
@@ -13,7 +13,7 @@ class Riffer::Rig::UI::Smoother
   MIN_CHARS_PER_TICK = Rational(1, 6) #: Rational
 
   # @rbs @io: IO
-  # @rbs @theme: Riffer::Rig::UI::Theme
+  # @rbs @theme: Riffer::Rig::Terminal::Theme
   # @rbs @clock: singleton(Kernel)
   # @rbs @backlog: String
   # @rbs @carry: Rational
@@ -23,10 +23,10 @@ class Riffer::Rig::UI::Smoother
   # @rbs @newline_pending: bool
 
   # @rbs io: IO
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs clock: singleton(Kernel)
   # @rbs return: void
-  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io), clock: Kernel)
+  def initialize(io: $stdout, theme: Riffer::Rig::Terminal::Theme.for(io), clock: Kernel)
     @io = io
     @theme = theme
     @clock = clock

data/lib/riffer/rig/{ui → terminal}/theme.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::UI::Theme
+class Riffer::Rig::Terminal::Theme
   # @rbs @enabled: bool
 
   # @dynamic enabled
@@ -13,10 +13,10 @@ class Riffer::Rig::UI::Theme
   end
 
   # @rbs io: IO
-  # @rbs env: Riffer::Rig::Env
-  # @rbs return: Riffer::Rig::UI::Theme
-  def self.for(io, env: Riffer::Rig::Env.new)
-    new(enabled: io.tty? && !env.no_color)
+  # @rbs no_color: bool
+  # @rbs return: Riffer::Rig::Terminal::Theme
+  def self.for(io, no_color: false)
+    new(enabled: io.tty? && !no_color)
   end
 
   # @rbs text: String
@@ -30,31 +30,31 @@ class Riffer::Rig::UI::Theme
 
   # @rbs text: String
   # @rbs return: String
-  def pink(text) = paint(text, Riffer::Rig::UI::Palette::PINK)
+  def pink(text) = paint(text, Riffer::Rig::Terminal::Palette::PINK)
 
   # @rbs text: String
   # @rbs return: String
-  def magenta(text) = paint(text, Riffer::Rig::UI::Palette::MAGENTA)
+  def magenta(text) = paint(text, Riffer::Rig::Terminal::Palette::MAGENTA)
 
   # @rbs text: String
   # @rbs return: String
-  def purple(text) = paint(text, Riffer::Rig::UI::Palette::PURPLE)
+  def purple(text) = paint(text, Riffer::Rig::Terminal::Palette::PURPLE)
 
   # @rbs text: String
   # @rbs return: String
-  def blue(text) = paint(text, Riffer::Rig::UI::Palette::BLUE)
+  def blue(text) = paint(text, Riffer::Rig::Terminal::Palette::BLUE)
 
   # @rbs text: String
   # @rbs return: String
-  def cyan(text) = paint(text, Riffer::Rig::UI::Palette::CYAN)
+  def cyan(text) = paint(text, Riffer::Rig::Terminal::Palette::CYAN)
 
   # @rbs text: String
   # @rbs return: String
-  def grey(text) = paint(text, Riffer::Rig::UI::Palette::GREY)
+  def grey(text) = paint(text, Riffer::Rig::Terminal::Palette::GREY)
 
   # @rbs text: String
   # @rbs return: String
-  def red(text) = paint(text, Riffer::Rig::UI::Palette::RED)
+  def red(text) = paint(text, Riffer::Rig::Terminal::Palette::RED)
 
   # @rbs text: String
   # @rbs return: String

data/lib/riffer/rig/terminal.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Terminal
+  EXIT_COMMANDS = %w[/exit /quit].freeze #: Array[String]
+
+  SLASH_COMMAND = %r{\A/(\S+)\s*(.*)\z}m #: Regexp
+
+  SKILL_COMMAND_PREFIX = 'skill:'
+
+  EXIT_HINT = 'Press Ctrl-C again to exit.'
+
+  FAREWELL = 'see you on the next riff.'
+
+  # @rbs @input: IO
+  # @rbs @host: Riffer::Rig::Hosts::_Host
+  # @rbs @renderer: Riffer::Rig::Terminal::Renderer
+  # @rbs @animator: Riffer::Rig::Terminal::Animator
+  # @rbs @theme: Riffer::Rig::Terminal::Theme
+  # @rbs @version: String
+
+  # @rbs input: IO
+  # @rbs output: IO
+  # @rbs version: String
+  # @rbs no_color: bool
+  # @rbs return: Riffer::Rig::Terminal
+  def self.for(input:, output:, version:, no_color: false)
+    theme = Theme.for(output, no_color: no_color)
+    smoother = Smoother.new(io: output, theme: theme)
+    renderer = Renderer.new(io: output, theme: theme, smoother: smoother, cursor: Cursor.new(io: output, theme: theme))
+    animator = Animator.new(io: output, theme: theme)
+    host = Riffer::Rig::Terminal::Host.new(input: input, renderer: renderer, animator: animator)
+    new(input: input, host: host, renderer: renderer, animator: animator, theme: theme, version: version)
+  end
+
+  # @rbs input: IO
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs renderer: Riffer::Rig::Terminal::Renderer
+  # @rbs animator: Riffer::Rig::Terminal::Animator
+  # @rbs theme: Riffer::Rig::Terminal::Theme
+  # @rbs version: String
+  # @rbs return: void
+  def initialize(input:, host:, renderer:, animator:, theme:, version:)
+    @input = input
+    @host = host
+    @renderer = renderer
+    @animator = animator
+    @theme = theme
+    @version = version
+  end
+
+  # @rbs &build: (Riffer::Rig::Hosts::_Host) -> Riffer::Rig::Runtime
+  # @rbs return: Integer
+  def run(&build)
+    runtime = load(build)
+    return 1 unless runtime
+
+    begin
+      runtime.on_message { |message| render_tool_result(message) }
+      reveal_banner(runtime)
+      repl(runtime)
+      @renderer.notice(FAREWELL)
+      0
+    ensure
+      runtime.close
+    end
+  end
+
+  private
+
+  # @rbs build: ^(Riffer::Rig::Hosts::_Host) -> Riffer::Rig::Runtime
+  # @rbs return: Riffer::Rig::Runtime?
+  def load(build)
+    build.call(@host)
+  rescue Riffer::Rig::Loader::ConfigurationError => e
+    @renderer.error(e.message)
+    nil
+  rescue Interrupt
+    @renderer.newline
+    nil
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs return: void
+  def reveal_banner(runtime)
+    skills = runtime.commands.count { |command| command.name.start_with?(SKILL_COMMAND_PREFIX) }
+    lines = Banner.lines(
+      @theme,
+      model: runtime.model,
+      cwd: runtime.cwd,
+      skills: skills.zero? ? 'none' : skills.to_s,
+      version: @version
+    )
+    @animator.reveal([lines])
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs return: void
+  def repl(runtime)
+    armed = false
+    loop do
+      case (line = read_line)
+      when nil then break
+      when :interrupt
+        break if armed
+
+        armed = true
+        @renderer.notice(EXIT_HINT)
+      else
+        armed = false
+        text = line.strip
+        break if EXIT_COMMANDS.include?(text)
+
+        dispatch(runtime, text) unless text.empty?
+      end
+    end
+  end
+
+  # @rbs return: String | :interrupt | nil
+  def read_line
+    @renderer.prompt
+    @input.gets
+  rescue Interrupt
+    :interrupt
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs text: String
+  # @rbs return: void
+  def dispatch(runtime, text)
+    command = SLASH_COMMAND.match(text)
+    turn(runtime) do |emit|
+      if command
+        runtime.run_command(command[1].to_s, command[2].to_s, &emit)
+      else
+        runtime.prompt(text, &emit)
+      end
+    end
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs &block: (^(::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event) -> void) -> void
+  # @rbs return: void
+  def turn(runtime)
+    # Runtime#cancel takes a Mutex, which Ruby refuses inside a trap handler,
+    # so the handler hands the cancel to a thread.
+    previous = Signal.trap('INT') { Thread.new { runtime.cancel } }
+    begin
+      @renderer.begin_turn
+      start_animator
+      yield(->(event) { render(runtime, event) })
+    rescue StandardError => e
+      @animator.stop
+      @renderer.error("Error: #{e.message}")
+    ensure
+      Signal.trap('INT', previous)
+      @animator.stop
+      @renderer.end_turn
+    end
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs event: ::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event
+  # @rbs return: void
+  def render(runtime, event)
+    case event
+    when Riffer::StreamEvents::ReasoningDelta
+      start_animator(:reasoning)
+    when Riffer::StreamEvents::ReasoningDone, Riffer::StreamEvents::TokenUsageDone
+      # Tool execution and the next model call emit no events, so the spinner
+      # comes straight back on to cover the silent stretch.
+      start_animator
+    when Riffer::StreamEvents::TextDelta, Riffer::StreamEvents::ToolCallDone, Riffer::StreamEvents::Interrupt
+      @animator.stop
+      @renderer.render(event)
+    when Riffer::StreamEvents::SkillActivation, Riffer::Rig::Events::SkillActivated
+      @animator.stop
+      @renderer.skill(event.name)
+      start_animator
+    when Riffer::Rig::Events::CommandOutput
+      @animator.stop
+      @renderer.notice(event.text)
+    when Riffer::Rig::Events::TurnEnd
+      @animator.stop
+      @renderer.usage(event.usage, runtime.tally)
+    end
+  end
+
+  # @rbs message: Riffer::Messages::Base
+  # @rbs return: void
+  def render_tool_result(message)
+    return unless message.is_a?(Riffer::Messages::Tool)
+
+    @animator.stop
+    @renderer.render_tool_result(message)
+    start_animator
+  end
+
+  # @rbs mode: Symbol
+  # @rbs return: void
+  def start_animator(mode = :neutral)
+    # The smoother's backlog may still be trickling out from streamed prose,
+    # and spinner frames drawn mid-drain would carve `\r…\e[K` through a
+    # half-printed sentence.
+    @renderer.drain
+    @animator.start(mode)
+  end
+end

data/lib/riffer/rig/tools/bash.rb

@@ -5,7 +5,7 @@ require 'open3'
 class Riffer::Rig::Tools::Bash < Riffer::Tool
   identifier 'bash'
   description 'Run a shell command in the working directory and return its combined stdout/stderr and exit status. ' \
-              'Use this for listing, searching (rg/grep/find), running tests, git, etc.'
+              'Use this for exploring and running things: ls, rg or grep, find, tests, git, package managers.'
 
   timeout 600
 
@@ -29,7 +29,8 @@ class Riffer::Rig::Tools::Bash < Riffer::Tool
   # @rbs return: Riffer::Tools::Response
   def call(context:, command:, timeout_ms: DEFAULT_TIMEOUT_MS)
     cancel_flag = context&.[](:cancel_flag) #: Riffer::Rig::Runtime::CancelFlag?
-    output, status = run(command, timeout_ms / 1000.0, cancel_flag)
+    cwd = context&.[](:cwd) #: String
+    output, status = run(command, cwd, timeout_ms / 1000.0, cancel_flag)
     output = truncate(output.rstrip)
 
     return error("Command exited with status #{status}\n#{output}", type: :command_failed) unless status.zero?
@@ -40,11 +41,12 @@ class Riffer::Rig::Tools::Bash < Riffer::Tool
   private
 
   # @rbs command: String
+  # @rbs cwd: String
   # @rbs timeout_seconds: Float
   # @rbs cancel_flag: Riffer::Rig::Runtime::CancelFlag?
   # @rbs return: [String, Integer]
-  def run(command, timeout_seconds, cancel_flag)
-    stdin, stdout_and_stderr, wait_thread = Open3.popen2e(command, chdir: Dir.pwd, pgroup: true)
+  def run(command, cwd, timeout_seconds, cancel_flag)
+    stdin, stdout_and_stderr, wait_thread = Open3.popen2e(command, chdir: cwd, pgroup: true)
     stdin.close
 
     ending = await(wait_thread, monotonic_now + timeout_seconds, cancel_flag)

data/lib/riffer/rig/tools/edit.rb

@@ -3,7 +3,8 @@
 class Riffer::Rig::Tools::Edit < Riffer::Tool
   identifier 'edit'
   description 'Replace an exact string in a file. By default old_string must occur exactly once; ' \
-              'set replace_all to replace every occurrence.'
+              'set replace_all to replace every occurrence. ' \
+              'Prefer this over write for existing files; pass enough surrounding text to make old_string unique.'
 
   params do
     required :path, String, description: 'Path to the file (absolute, or relative to the working directory)'
@@ -22,7 +23,7 @@ class Riffer::Rig::Tools::Edit < Riffer::Tool
   # @rbs replace_all: bool
   # @rbs return: Riffer::Tools::Response
   def call(context:, path:, old_string:, new_string:, replace_all: false)
-    resolved = File.expand_path(path, Dir.pwd)
+    resolved = File.expand_path(path, context&.[](:cwd))
     return error("File not found: #{path}", type: :not_found) unless File.file?(resolved)
 
     content = File.read(resolved)

data/lib/riffer/rig/tools/read.rb

@@ -3,7 +3,8 @@
 class Riffer::Rig::Tools::Read < Riffer::Tool
   identifier 'read'
   description 'Read a file from the filesystem. Returns its contents with line numbers. ' \
-              'Use offset/limit to read a slice of a large file.'
+              'Use offset/limit to read a slice of a large file. ' \
+              'Read a file before editing it, and read rather than guess what a file contains.'
 
   DEFAULT_LIMIT = 2000 #: Integer
 
@@ -19,7 +20,7 @@ class Riffer::Rig::Tools::Read < Riffer::Tool
   # @rbs limit: Integer
   # @rbs return: Riffer::Tools::Response
   def call(context:, path:, offset: nil, limit: DEFAULT_LIMIT)
-    resolved = File.expand_path(path, Dir.pwd)
+    resolved = File.expand_path(path, context&.[](:cwd))
     return error("File not found: #{path}", type: :not_found) unless File.file?(resolved)
     return error('offset must be >= 1', type: :invalid_argument) if offset && offset < 1
 

data/lib/riffer/rig/tools/write.rb

@@ -4,7 +4,8 @@ require 'fileutils'
 
 class Riffer::Rig::Tools::Write < Riffer::Tool
   identifier 'write'
-  description 'Write content to a file, creating it (and any parent directories) or overwriting it.'
+  description 'Write content to a file, creating it (and any parent directories) or overwriting it. ' \
+              'Use this for new files or full rewrites; prefer edit for changes to an existing file.'
 
   params do
     required :path, String, description: 'Path to the file (absolute, or relative to the working directory)'
@@ -16,7 +17,7 @@ class Riffer::Rig::Tools::Write < Riffer::Tool
   # @rbs content: String
   # @rbs return: Riffer::Tools::Response
   def call(context:, path:, content:)
-    resolved = File.expand_path(path, Dir.pwd)
+    resolved = File.expand_path(path, context&.[](:cwd))
     FileUtils.mkdir_p(File.dirname(resolved))
     File.write(resolved, content)
 

data/lib/riffer/rig/version.rb

@@ -2,6 +2,6 @@
 
 module Riffer
   module Rig
-    VERSION = '0.6.0'
+    VERSION = '0.7.0'
   end
 end

data/lib/riffer/rig.rb

@@ -6,7 +6,7 @@ require_relative 'rig/version'
 
 loader = Zeitwerk::Loader.for_gem_extension(Riffer)
 loader.ignore("#{__dir__}/rig/version.rb")
-loader.inflector.inflect('cli' => 'CLI', 'repl' => 'REPL', 'ui' => 'UI')
+loader.inflector.inflect('cli' => 'CLI')
 loader.setup
 
 module Riffer::Rig
@@ -18,19 +18,19 @@ module Riffer::Rig
   # @rbs &block: (::Riffer::Rig::Registrar) -> void
   # @rbs return: Riffer::Rig::Extension
   def self.extension(name, requires: nil, &)
-    ext = Extension.new(name, requires: requires, &)
-    if ext.requires && !ext.requires.satisfied_by?(Gem::Version.new(Riffer::Rig::VERSION))
-      raise Riffer::ArgumentError,
-            "extension #{name} requires riffer-rig #{ext.requires}, found #{Riffer::Rig::VERSION}"
-    end
-
     # Keyed by name so reloading a file replaces its block rather than
     # duplicating it.
-    @extensions[name] = ext
+    @extensions[name] = Extension.new(name, requires: requires, &)
   end
 
   # @rbs return: Hash[String, Riffer::Rig::Extension]
   def self.extensions
     @extensions.dup
   end
+
+  # @rbs name: Symbol?
+  # @rbs return: Riffer::Rig::Extension | Array[Riffer::Rig::Extension]
+  def self.bundled(name = nil)
+    name ? Bundled::BY_NAME.fetch(name) : Bundled::BY_NAME.values
+  end
 end