riffer-rig 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 761f180d04e8bab840732d6649617fd6f7196406f0bc54c3f849d253dacefe9a
-  data.tar.gz: 1f352b9cc7e0f663e13580216262ddc5db9af8ffafefd0b5e0bfd9d062ad19e4
+  metadata.gz: f87fb650798f95679ff56654620a0fcb3cc383d8ce650849d9e33382a7837a6f
+  data.tar.gz: e8784d13f472d45c5ffb7f1d269c5ab8ff7d0b41a62cfae446ceaee2345413b9
 SHA512:
-  metadata.gz: dc46ed7d22bff69600f6c51c03f77c3b70f7c82aca55487c2cb0d4f95c7818c3f37bd80f5b16112168e43354b3914ea910101c33a598ba3b29f05b036d045585
-  data.tar.gz: 32f112b0df082dc73833effe226bf8e940d201bac032a5c3630fb53ec29b9ed38162fd881f49933a2fc9158158ceb42634508150be91ef83602fc72626743972
+  metadata.gz: '09252fc5c265fdc91be5fc8753b3407560c3be9f94af9616b2d3ae9e8e3c28f100374bb1014d7b8038bd51abc5f86875e6116fc874733ba58dda87254b15e3cc'
+  data.tar.gz: 7f1cc7dae6f6ccf69cf370296458d1eef837111f01041adae31a59e48df6719903c1c43630cf0248ba4b7ba140d420f663a585dcb13f5c945d5f105eaa2b8fc9

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.2.0](https://github.com/bottrall/riffer-rig/compare/v0.1.2...v0.2.0) (2026-09-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove the Riffy mascot entirely ([#151](https://github.com/bottrall/riffer-rig/issues/151))
+
+### Features
+
+* remove the Riffy mascot entirely ([#151](https://github.com/bottrall/riffer-rig/issues/151)) ([af17f99](https://github.com/bottrall/riffer-rig/commit/af17f9907e8d43a01f966e1a0979f868a8d50466))
+* **ui:** keep the thinking indicator alive during reasoning ([#156](https://github.com/bottrall/riffer-rig/issues/156)) ([4ff67cc](https://github.com/bottrall/riffer-rig/commit/4ff67cc6a2e133324b98dbdf40f63c500ee00a4c))
+* **ui:** smooth streamed text output at 60fps ([#153](https://github.com/bottrall/riffer-rig/issues/153)) ([42dc781](https://github.com/bottrall/riffer-rig/commit/42dc781b3fc4a942e0eaca755b9e0b4180659506))
+
+
+### Bug Fixes
+
+* **ui:** drop 'code' subtitle from banner ([#157](https://github.com/bottrall/riffer-rig/issues/157)) ([dfd2e73](https://github.com/bottrall/riffer-rig/commit/dfd2e73d6b71f10adbf1dfa2ae659aad85ed547e))
+
 ## [0.1.2](https://github.com/bottrall/riffer-rig/compare/v0.1.1...v0.1.2) (2026-09-07)
 
 

data/lib/riffer/rig/cli.rb

@@ -30,8 +30,9 @@ module Riffer::Rig::CLI
     reveal_banner(theme, animator, model)
 
     tally    = Riffer::Rig::TokenTally.new(pricing: Riffer::Rig::Settings.pricing_for(model))
-    renderer = Riffer::Rig::UI::Renderer.new(io: output, theme:, tally:)
-    Riffer::Rig::REPL.new(agent:, renderer:, animator:, theme:, input:, output:).run
+    smoother = Riffer::Rig::UI::Smoother.new(io: output, theme:)
+    renderer = Riffer::Rig::UI::Renderer.new(io: output, theme:, tally:, smoother:)
+    Riffer::Rig::REPL.new(agent:, renderer:, animator:, theme:, smoother:, input:, output:).run
     0
   end
 
@@ -81,11 +82,7 @@ module Riffer::Rig::CLI
     loaded  = [Riffer::Rig::CodingAgent::GLOBAL_AGENTS_FILE, File.join(Dir.pwd, 'AGENTS.md')].select { |path| File.file?(path) }
     context = loaded.empty? ? 'none' : loaded.join(', ')
 
-    glints = Riffer::Rig::UI::Riffy::GLINT_COLS + [nil]
-    frames = glints.map do |glint_col|
-      Riffer::Rig::UI::Banner.lines(theme, model: model, cwd: Dir.pwd, context: context, skills: count_skills, version: Riffer::Rig::VERSION, glint_col: glint_col)
-    end
-    animator.reveal(frames)
+    animator.reveal([Riffer::Rig::UI::Banner.lines(theme, model: model, cwd: Dir.pwd, context: context, skills: count_skills, version: Riffer::Rig::VERSION)])
   end
 
   def count_skills

data/lib/riffer/rig/repl.rb

@@ -4,14 +4,15 @@ class Riffer::Rig::REPL
   EXIT_COMMANDS = ['/exit', '/quit'].freeze
   SKILL_COMMAND = %r{\A/skill:([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+(.*))?\z}m
 
-  def initialize(agent:, renderer:, input: $stdin, output: $stdout, theme: Riffer::Rig::UI::Theme.for(output), animator: Riffer::Rig::UI::Animator.new(io: output, theme:))
+  def initialize(agent:, renderer:, input: $stdin, output: $stdout, theme: Riffer::Rig::UI::Theme.for(output), animator: Riffer::Rig::UI::Animator.new(io: output, theme:), smoother: Riffer::Rig::UI::Smoother.new(io: output, theme:))
     @agent = agent
     @renderer = renderer
     @animator = animator
+    @smoother = smoother
     @theme = theme
     @input = input
     @output = output
-    @agent.session.on_message { |message| @renderer.render_tool_result(message) }
+    @agent.session.on_message { |message| render_tool_result(message) }
   end
 
   def run
@@ -39,16 +40,38 @@ class Riffer::Rig::REPL
   private
 
   def run_turn(prompt)
-    @animator.start_thinking
+    @animator.start
+    @smoother.start
     @agent.stream(prompt).each do |event|
-      @animator.stop_thinking
+      case event
+      when Riffer::StreamEvents::ReasoningDelta
+        @animator.start(:reasoning)
+      when Riffer::StreamEvents::ReasoningDone
+        @animator.start
+      when Riffer::StreamEvents::ToolCallDelta, Riffer::StreamEvents::FinishReasonDone
+        # Round bookkeeping: nothing renders, so the indicator just carries on
+        # (or stays parked while the smoother finishes typing earlier text).
+        next
+      when Riffer::StreamEvents::ToolCallDone, Riffer::StreamEvents::SkillActivation, Riffer::StreamEvents::TokenUsageDone
+        # The spinner shares its line with what's about to print, and tool
+        # execution plus the next model invocation emit no events — stop it for
+        # the render, then bring it straight back to cover the silent stretch.
+        @animator.stop
+        @renderer.render(event)
+        @animator.start
+        next
+      else
+        @animator.stop
+      end
       @renderer.render(event)
     end
+    @smoother.finish
     @output.puts
   rescue StandardError => e
     @output.puts("\nError: #{e.message}")
   ensure
-    @animator.stop_thinking
+    @smoother.finish
+    @animator.stop
   end
 
   def run_skill_command(name, args)
@@ -83,4 +106,15 @@ class Riffer::Rig::REPL
   def skill_block(name, body)
     "<skill name=\"#{name}\">\n#{body}\n</skill>"
   end
+
+  # Tool results can land mid-animation (tool execution emits no stream events,
+  # so the indicator is up); stop it around the line so its next frame doesn't
+  # erase what we printed.
+  def render_tool_result(message)
+    return unless message.is_a?(Riffer::Messages::Tool)
+
+    @animator.stop
+    @renderer.render_tool_result(message)
+    @animator.start
+  end
 end

data/lib/riffer/rig/ui/animator.rb

@@ -5,11 +5,24 @@
 class Riffer::Rig::UI::Animator
   REVEAL_FRAME_SECONDS = 0.05
   SPINNER_FRAME_SECONDS = 0.12
+  EQ_LEVELS = '▁▂▃▄▅▆▇█'.chars.freeze
+  EQ_BARS = 7
+  NEUTRAL_LABEL = 'riffing…'
+  REASONING_PHRASES = [
+    'contemplating…', 'pondering…', 'mulling it over…', 'reasoning…',
+    'connecting the dots…', 'herding thoughts…', 'consulting the muse…',
+    'doing some deep listening…', 'warming up…', 'tuning up…',
+    'in the woodshed…', 'vamping…', 'finding the key…', 'counting it off…',
+    'jamming internally…'
+  ].freeze
+  REASONING_TICK_RANGE = (1..5)
 
   def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io))
     @io = io
     @theme = theme
     @thread = nil
+    @mode = :neutral
+    @phrase = nil
   end
 
   # When not on a TTY, prints the final frame once instead of animating.
@@ -28,22 +41,20 @@ class Riffer::Rig::UI::Animator
     end
   end
 
-  def start_thinking
+  def start(mode = :neutral)
     return unless enabled?
 
-    @stop = false
-    @thread = Thread.new do
-      tick = 0
-      until @stop
-        @io.print("\r  #{Riffer::Rig::UI::Riffy.equalizer(@theme, tick)}\e[K")
-        @io.flush
-        sleep(SPINNER_FRAME_SECONDS)
-        tick += 1
-      end
+    if @thread
+      @mode = mode
+      return
     end
+
+    @mode = mode
+    @stop = false
+    @thread = Thread.new { animate }
   end
 
-  def stop_thinking
+  def stop
     return unless @thread
 
     @stop = true
@@ -53,8 +64,42 @@ class Riffer::Rig::UI::Animator
     @io.flush
   end
 
+  def equalizer(tick, label = NEUTRAL_LABEL)
+    bars = Array.new(EQ_BARS) do |i|
+      height = (Math.sin((tick + i) * 0.6).abs * (EQ_LEVELS.length - 1)).round
+      bar = EQ_LEVELS[height]
+      i.even? ? @theme.cyan(bar) : @theme.magenta(bar)
+    end
+    "#{bars.join} #{@theme.grey(label)}"
+  end
+
   private
 
+  def animate
+    tick = 0
+    roll_at = 0.0 # force an immediate phrase roll when entering reasoning mode
+    until @stop
+      roll_at = roll_phrase(roll_at)
+      @io.print("\r  #{equalizer(tick, label)}\e[K")
+      @io.flush
+      sleep(SPINNER_FRAME_SECONDS)
+      tick += 1
+    end
+  end
+
+  # Re-rolls both phrase and duration whenever the reasoning tick expires.
+  def roll_phrase(roll_at)
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    return roll_at unless @mode == :reasoning && now >= roll_at
+
+    @phrase = REASONING_PHRASES.sample
+    now + rand(REASONING_TICK_RANGE)
+  end
+
+  def label
+    @mode == :reasoning ? @phrase : NEUTRAL_LABEL
+  end
+
   def enabled?
     @theme.enabled && @io.respond_to?(:tty?) && @io.tty?
   end

data/lib/riffer/rig/ui/banner.rb

@@ -23,27 +23,19 @@ module Riffer::Rig::UI::Banner
 
   INFO_LABEL_WIDTH = 8
   INDENT = '  '
-  BEAR_GAP = '  '
 
-  def call(theme, model:, cwd:, context:, skills:, version:, glint_col: nil)
-    lines(theme, model: model, cwd: cwd, context: context, skills: skills, version: version, glint_col: glint_col).join("\n")
+  def call(theme, model:, cwd:, context:, skills:, version:)
+    lines(theme, model: model, cwd: cwd, context: context, skills: skills, version: version).join("\n")
   end
 
-  def lines(theme, model:, cwd:, context:, skills:, version:, glint_col: nil)
-    [''] + art(theme, glint_col: glint_col) + [''] +
+  def lines(theme, model:, cwd:, context:, skills:, version:)
+    [''] + art(theme) + [''] +
       info(theme, model: model, cwd: cwd, context: context, skills: skills, version: version) + ['']
   end
 
-  def art(theme, glint_col: nil)
-    bear = Riffer::Rig::UI::Riffy.render(theme, glint_col: glint_col)
-    right = WORDMARK.each_index.map { |i| theme.paint(WORDMARK[i], ROW_COLOURS[i]) }
-    right += ['', "#{theme.grey('· code ·')}   #{theme.cyan("♪ let's riff ♪")}"]
-
-    pad = (bear.length - right.length) / 2
-    bear.each_index.map do |i|
-      side = right[i - pad] if (pad...(pad + right.length)).cover?(i)
-      "#{INDENT}#{bear[i]}#{BEAR_GAP}#{side}".rstrip
-    end
+  def art(theme)
+    art = WORDMARK.each_index.map { |i| "#{INDENT}#{theme.paint(WORDMARK[i], ROW_COLOURS[i])}" }
+    art + ["#{INDENT}#{theme.cyan("♪ let's riff ♪")}"]
   end
 
   def info(theme, model:, cwd:, context:, skills:, version:)

data/lib/riffer/rig/ui/renderer.rb

@@ -5,23 +5,28 @@ require 'json'
 class Riffer::Rig::UI::Renderer
   RESULT_PREVIEW_LIMIT = 200
 
-  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io), tally: nil)
+  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io), tally: nil, smoother: nil)
     @io = io
     @theme = theme
     @tally = tally
+    @smoother = smoother
   end
 
   def render(event)
     case event
     when Riffer::StreamEvents::TextDelta
-      @io.print(event.content)
+      smoother << event.content
     when Riffer::StreamEvents::ToolCallDone
+      drain_smoother
       @io.puts("\n#{@theme.cyan("⚙ #{event.name}(#{format_arguments(event.arguments)})")}")
     when Riffer::StreamEvents::SkillActivation
+      drain_smoother
       @io.puts("\n#{@theme.magenta("✦ skill: #{event.name}")}")
     when Riffer::StreamEvents::Interrupt
+      drain_smoother
       @io.puts(@theme.dim("[interrupted: #{event.reason}]"))
     when Riffer::StreamEvents::TokenUsageDone
+      drain_smoother
       render_token_usage(event.token_usage)
     end
   end
@@ -35,6 +40,30 @@ class Riffer::Rig::UI::Renderer
 
   private
 
+  def smoother
+    @smoother || PassThroughSmoother.new(@io)
+  end
+
+  # Stand-in when no smoother is injected, so a bare Renderer still prints
+  # synchronously.
+  class PassThroughSmoother
+    def initialize(io) = @io = io
+
+    def <<(content)
+      @io.print(content)
+      @io.flush
+      self
+    end
+
+    def drain = nil
+
+    def finish = nil
+  end
+
+  def drain_smoother
+    smoother.drain
+  end
+
   def render_token_usage(usage)
     return unless @tally
 

data/lib/riffer/rig/ui/smoother.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Paces streamed text onto a 60fps cadence so API bursts read as continuous
+# typing. On a non-TTY output it is transparent: writes pass through
+# synchronously and no thread ever runs.
+class Riffer::Rig::UI::Smoother
+  TICK_SECONDS = 1.0 / 60.0
+
+  # A frame removes only a sixtieth of the remaining backlog — an exponential
+  # decay whose tail keeps text flowing for a second or more, so the reveal
+  # never visibly stops between chunks. The carry accrues sub-character
+  # releases so the effective rate can settle at the provider's throughput;
+  # the floor is fractional (10 chars/s) so it can't over-drain a backlog
+  # that's trickling in slower than 60 chars/s.
+  BACKLOG_FRACTION_PER_TICK = Rational(1, 60)
+  MIN_CHARS_PER_TICK = Rational(1, 6)
+
+  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io), clock: Kernel)
+    @io = io
+    @theme = theme
+    @clock = clock
+    @backlog = +''
+    @carry = Rational(0)
+    @mutex = Mutex.new
+    @thread = nil
+    @stop = false
+  end
+
+  def start
+    return unless enabled?
+    return if @thread
+
+    @stop = false
+    @thread = Thread.new do
+      until @stop
+        tick
+        @clock.sleep(TICK_SECONDS)
+      end
+    end
+  end
+
+  def <<(content)
+    if enabled?
+      @mutex.synchronize { @backlog << content }
+    else
+      @io.print(content)
+      @io.flush
+    end
+    self
+  end
+
+  # The write sits inside the mutex so a concurrent tick can't reorder a drain.
+  def tick
+    @mutex.synchronize do
+      return if @backlog.empty?
+
+      @carry += [@backlog.length * BACKLOG_FRACTION_PER_TICK, MIN_CHARS_PER_TICK].max
+      count = @carry.floor
+      return if count.zero?
+
+      @carry -= count
+      @io.print(@backlog.slice!(0, count))
+      @io.flush
+    end
+  end
+
+  # Called before non-delta output so printed order matches stream order.
+  def drain
+    @mutex.synchronize do
+      return if @backlog.empty?
+
+      @io.print(@backlog.slice!(0, @backlog.length))
+      @io.flush
+    end
+  end
+
+  # Idempotent: the REPL's ensure path runs it even after a happy-path finish.
+  def finish
+    if @thread
+      @stop = true
+      @thread.join
+      @thread = nil
+    end
+    drain
+  end
+
+  private
+
+  def enabled?
+    @theme.enabled && @io.respond_to?(:tty?) && @io.tty?
+  end
+end

data/lib/riffer/rig/version.rb

@@ -2,6 +2,6 @@
 
 module Riffer
   module Rig
-    VERSION = '0.1.2'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer-rig
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Jake Bottrall
@@ -105,9 +105,8 @@ files:
 - lib/riffer/rig/ui/animator.rb
 - lib/riffer/rig/ui/banner.rb
 - lib/riffer/rig/ui/palette.rb
-- lib/riffer/rig/ui/pixels.rb
 - lib/riffer/rig/ui/renderer.rb
-- lib/riffer/rig/ui/riffy.rb
+- lib/riffer/rig/ui/smoother.rb
 - lib/riffer/rig/ui/theme.rb
 - lib/riffer/rig/version.rb
 homepage: https://github.com/bottrall/riffer-rig

data/lib/riffer/rig/ui/pixels.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-# Each character cell stacks two vertical pixels via half-block glyphs (▀ top,
-# ▄ bottom): the foreground colours the top pixel and the background the bottom,
-# doubling vertical resolution. A disabled theme falls back to plain block
-# glyphs so piped/non-colour output stays escape-free.
-module Riffer::Rig::UI::Pixels
-  extend self
-
-  RESET = "\e[0m"
-
-  def render(sprite, palette, theme)
-    sprite.each_slice(2).map do |top, bottom|
-      render_row(top, bottom || [], palette, theme)
-    end
-  end
-
-  private
-
-  def render_row(top, bottom, palette, theme)
-    width = [top.length, bottom.length].max
-    (0...width).map { |x| cell(palette[top[x]], palette[bottom[x]], theme) }.join
-  end
-
-  def cell(top_rgb, bottom_rgb, theme)
-    return ' ' if top_rgb.nil? && bottom_rgb.nil?
-
-    unless theme.enabled
-      return '█' if top_rgb && bottom_rgb
-      return '▀' if top_rgb
-
-      return '▄'
-    end
-
-    if top_rgb && bottom_rgb
-      "#{fg(top_rgb)}#{bg(bottom_rgb)}▀#{RESET}"
-    elsif top_rgb
-      "#{fg(top_rgb)}▀#{RESET}"
-    else
-      "#{fg(bottom_rgb)}▄#{RESET}"
-    end
-  end
-
-  def fg(rgb) = "\e[38;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m"
-
-  def bg(rgb) = "\e[48;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m"
-end

data/lib/riffer/rig/ui/riffy.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-# riffer-rig's mascot sprite, authored as a character grid (see LEGEND).
-module Riffer::Rig::UI::Riffy
-  extend self
-
-  LEGEND = {
-    '.' => nil,
-    'D' => :outline,  # deep purple outline / shadow / nose
-    'B' => :body,     # purple fur
-    'M' => :shade,    # mid purple (inner ear, jaw shadow, leg lines)
-    'L' => :light,    # light lilac (snout, paw pads)
-    'K' => :shades,   # near-black sunglasses
-    'W' => :glint     # lens glint (intro only)
-  }.freeze
-
-  PALETTE = {
-    outline: [74, 46, 122],
-    body: [157, 92, 232],
-    shade: [120, 66, 190],
-    light: [212, 180, 250],
-    shades: [12, 10, 20],
-    glint: [240, 240, 255]
-  }.freeze
-
-  GRID = [
-    '...DDDD......DDDD...',
-    '..DBBBBD....DBBBBD..',
-    '..DBMMBD....DBMMBD..',
-    '..DBMMBD....DBMMBD..',
-    '..DBBDDDDDDDDDDBBD..',
-    '...DBBBBBBBBBBBBD...',
-    '...DKKKKKKKKKKKKD...',
-    '...DKKKKKBBKKKKKD...',
-    '...DBKKKBBBBKKKBD...',
-    '...DBBBBBDDBBBBBD...',
-    '...DBBBBLLLLBBBBD...',
-    '...DBBBMLLLLMBBBD...',
-    '....DBBBBBBBBBBD....',
-    '....DDMMMMMMMMDD....',
-    '.....DBBBBBBBBD.....',
-    '....DBBBBBBBBBBD....',
-    '...DBBBBBBBBBBBBD...',
-    '..DBBBBBBBBBBBBBBD..',
-    '.DBBBBBBBBBBBBBBBBD.',
-    '.DBBBBDBBDDBBDBBBBD.',
-    '.DLLLDDLLDDLLDDLLLD.'
-  ].freeze
-
-  WIDTH = GRID.first.length
-  HEIGHT = (GRID.length + 1) / 2
-
-  LENS_ROWS = [6, 7, 8].freeze
-  GLINT_COLS = [4, 5, 6, 7, 8, 11, 12, 13, 14, 15].freeze
-
-  EQ_LEVELS = '▁▂▃▄▅▆▇█'.chars.freeze
-  EQ_BARS = 7
-
-  def render(theme, glint_col: nil)
-    sprite = GRID.map { |row| row.chars.map { |char| LEGEND.fetch(char) } }
-    apply_glint(sprite, glint_col) if glint_col
-    Riffer::Rig::UI::Pixels.render(sprite, PALETTE, theme)
-  end
-
-  def equalizer(theme, tick)
-    bars = Array.new(EQ_BARS) do |i|
-      height = (Math.sin((tick + i) * 0.6).abs * (EQ_LEVELS.length - 1)).round
-      bar = EQ_LEVELS[height]
-      i.even? ? theme.cyan(bar) : theme.magenta(bar)
-    end
-    "#{bars.join} #{theme.grey('riffing…')}"
-  end
-
-  private
-
-  def apply_glint(sprite, column)
-    LENS_ROWS.each do |row|
-      sprite[row][column] = :glint if sprite[row][column] == :shades
-    end
-  end
-end