riffer-rig 0.2.0 → 0.3.0

data/sig/generated/riffer/rig/repl.rbs

@@ -0,0 +1,76 @@
+# Generated from lib/riffer/rig/repl.rb with RBS::Inline
+
+class Riffer::Rig::REPL
+  EXIT_COMMANDS: Array[String]
+
+  SKILL_COMMAND: Regexp
+
+  @pending_tool_calls: Array[Riffer::StreamEvents::ToolCallDone]
+
+  @output: untyped
+
+  @input: untyped
+
+  @theme: Riffer::Rig::UI::Theme
+
+  @cursor: Riffer::Rig::UI::Cursor
+
+  @smoother: Riffer::Rig::UI::Smoother
+
+  @animator: Riffer::Rig::UI::Animator
+
+  @renderer: Riffer::Rig::UI::Renderer
+
+  @agent: Riffer::Agent
+
+  # @rbs ?agent: Riffer::Agent
+  # @rbs ?renderer: Riffer::Rig::UI::Renderer
+  # @rbs input: untyped
+  # @rbs output: untyped
+  # @rbs ?theme: Riffer::Rig::UI::Theme
+  # @rbs ?animator: Riffer::Rig::UI::Animator
+  # @rbs ?smoother: Riffer::Rig::UI::Smoother
+  # @rbs ?cursor: Riffer::Rig::UI::Cursor
+  # @rbs return: void
+  def initialize: (agent: untyped, renderer: untyped, ?input: untyped, ?output: untyped, ?theme: untyped, ?animator: untyped, ?smoother: untyped, ?cursor: untyped) -> void
+
+  # @rbs return: Symbol
+  def run: () -> Symbol
+
+  private
+
+  # @rbs prompt: String
+  # @rbs return: void
+  def run_turn: (String prompt) -> void
+
+  # @rbs name: String
+  # @rbs args: String
+  # @rbs return: void
+  def run_skill_command: (String name, String args) -> void
+
+  # @rbs name: String
+  # @rbs return: String?
+  def activate_skill: (String name) -> String?
+
+  # @rbs name: String
+  # @rbs body: String
+  # @rbs return: String
+  def skill_block: (String name, String body) -> String
+
+  # Tool call lines print below their round's stats line to reflect the actual
+  # timeline (usage is reported when the model stream closes, after the calls
+  # were decided). ToolCallDone events are therefore held until the stats line
+  # or the next event forces them out. Callers must have the spinner stopped —
+  # the flush renders between their existing stop/start pair.
+  #
+  # @rbs return: void
+  def flush_pending_tool_calls: () -> void
+
+  # 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.
+  #
+  # @rbs message: Riffer::Messages::Base
+  # @rbs return: void
+  def render_tool_result: (Riffer::Messages::Base message) -> void
+end

data/sig/generated/riffer/rig/settings/pricing.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/riffer/rig/settings/pricing.rb with RBS::Inline
+
+# USD per million tokens, parsed from a model's entry in the settings file.
+class Riffer::Rig::Settings::Pricing
+  # @dynamic input, output, cache_write, cache_read
+  attr_reader input: Float
+
+  # @dynamic input, output, cache_write, cache_read
+  attr_reader output: Float
+
+  # @dynamic input, output, cache_write, cache_read
+  attr_reader cache_write: Float
+
+  # @dynamic input, output, cache_write, cache_read
+  attr_reader cache_read: Float
+
+  # @rbs input: Float
+  # @rbs output: Float
+  # @rbs cache_write: Float
+  # @rbs cache_read: Float
+  # @rbs return: void
+  def initialize: (input: Float, output: Float, cache_write: Float, cache_read: Float) -> void
+end

data/sig/generated/riffer/rig/settings.rbs

@@ -0,0 +1,92 @@
+# Generated from lib/riffer/rig/settings.rb with RBS::Inline
+
+# Reads and writes the riffer-rig user settings file at
+# <tt>~/.riffer/settings.json</tt>.
+#
+# Example file:
+#
+#   {
+#     "model": "anthropic/claude-sonnet-4-6",
+#     "reasoning": "low",
+#     "models": {
+#       "anthropic/claude-sonnet-4-6": {
+#         "input": 3.0,
+#         "output": 15.0,
+#         "cache_write": 3.75,
+#         "cache_read": 0.3
+#       }
+#     }
+#   }
+#
+# All keys are optional. Missing pricing means cost display is suppressed.
+# <tt>"reasoning"</tt> is translated to the appropriate provider-specific
+# parameter on each API call; accepted values depend on the provider:
+#
+# - Anthropic: <tt>"low"</tt>, <tt>"medium"</tt>, <tt>"high"</tt>,
+#   <tt>"xhigh"</tt>, <tt>"max"</tt>
+# - OpenAI / OpenRouter: <tt>"low"</tt>, <tt>"medium"</tt>, <tt>"high"</tt>,
+#   <tt>"xhigh"</tt>
+#
+# Omitting the key (or supplying an unrecognised value) leaves the model's
+# default reasoning behaviour unchanged.
+module Riffer::Rig::Settings
+  PATH: String
+
+  DEFAULT_MODEL: ::String
+
+  REASONING_LEVELS_BY_PROVIDER: Hash[String, Array[String]]
+
+  # Returns the configured model string, or +DEFAULT_MODEL+ if not set.
+  #
+  # @rbs path: String
+  # @rbs return: String
+  def model: (?path: String) -> String
+
+  # Returns model options for the configured model and reasoning level, ready
+  # to pass directly to the Riffer agent's +model_options+.
+  #
+  # @rbs path: String
+  # @rbs return: Hash[Symbol, untyped]
+  def model_options: (?path: String) -> Hash[Symbol, untyped]
+
+  # Returns the provider prefix for +model_string+, e.g. <tt>"anthropic"</tt>
+  # for <tt>"anthropic/claude-sonnet-4-6"</tt>. Returns +nil+ if the model
+  # string contains no slash.
+  #
+  # @rbs model_string: String
+  # @rbs return: String?
+  def provider_for: (String model_string) -> String?
+
+  # Returns the pricing for +model+, or +nil+ if not configured.
+  #
+  # @rbs model: String
+  # @rbs path: String
+  # @rbs return: Pricing?
+  def pricing_for: (String model, ?path: String) -> Pricing?
+
+  private
+
+  # @rbs provider: String?
+  # @rbs return: Hash[Symbol, untyped]
+  def base_options: (String? provider) -> Hash[Symbol, untyped]
+
+  # @rbs path: String
+  # @rbs ?provider: String?
+  # @rbs return: String?
+  def reasoning_for: (?path: String, ?provider: untyped) -> String?
+
+  # Maps a reasoning level to the provider-specific model option hash expected
+  # by Riffer. Returns an empty hash when +level+ is +nil+.
+  #
+  # @rbs level: String?
+  # @rbs provider: String?
+  # @rbs return: Hash[Symbol, untyped]
+  def reasoning_options: (String? level, String? provider) -> Hash[Symbol, untyped]
+
+  # The parsed settings file, or an empty hash when the file is absent or
+  # malformed.
+  #
+  # @rbs path: String
+  # @rbs return: Hash[String, untyped]
+  def read: (String path) -> Hash[String, untyped]
+end

data/sig/generated/riffer/rig/token_tally.rbs

@@ -0,0 +1,61 @@
+# Generated from lib/riffer/rig/token_tally.rb with RBS::Inline
+
+# Accumulates token usage across multiple turns in a session and computes an
+# estimated cost based on a pricing object sourced from
+# +Riffer::Rig::Settings+.
+#
+# Instantiate once per REPL session, call +add+ after each turn, then read
+# +total_tokens+ and +estimated_cost+ for display.
+#
+#   pricing = Riffer::Rig::Settings.pricing_for('anthropic/claude-sonnet-4-6')
+#   tally = Riffer::Rig::TokenTally.new(pricing: pricing)
+#   tally.add(usage)
+#   tally.estimated_cost  # => 0.000042  (USD), or nil if pricing is nil
+class Riffer::Rig::TokenTally
+  @input_tokens: Integer
+
+  @output_tokens: Integer
+
+  @cache_write_tokens: Integer
+
+  @cache_read_tokens: Integer
+
+  @pricing: Riffer::Rig::Settings::Pricing?
+
+  # @dynamic input_tokens, output_tokens, cache_write_tokens, cache_read_tokens
+  attr_reader input_tokens: untyped
+
+  # @dynamic input_tokens, output_tokens, cache_write_tokens, cache_read_tokens
+  attr_reader output_tokens: untyped
+
+  # @dynamic input_tokens, output_tokens, cache_write_tokens, cache_read_tokens
+  attr_reader cache_write_tokens: untyped
+
+  # @dynamic input_tokens, output_tokens, cache_write_tokens, cache_read_tokens
+  attr_reader cache_read_tokens: untyped
+
+  # @rbs ?pricing: Riffer::Rig::Settings::Pricing?
+  # @rbs return: void
+  def initialize: (?pricing: untyped) -> void
+
+  # Accumulates token counts from a +Riffer::Providers::TokenUsage+ object.
+  #
+  # @rbs usage: Riffer::Providers::TokenUsage
+  # @rbs return: void
+  def add: (Riffer::Providers::TokenUsage usage) -> void
+
+  # Returns the total token count across all categories.
+  #
+  # @rbs return: Integer
+  def total_tokens: () -> Integer
+
+  # Returns +true+ if any tokens have been counted.
+  #
+  # @rbs return: bool
+  def any?: () -> bool
+
+  # Returns the estimated cost in USD, or +nil+ if no pricing was provided.
+  #
+  # @rbs return: Float?
+  def estimated_cost: () -> Float?
+end

data/sig/generated/riffer/rig/tools/bash.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/riffer/rig/tools/bash.rb with RBS::Inline
+
+class Riffer::Rig::Tools::Bash < Riffer::Tool
+  DEFAULT_TIMEOUT_MS: Integer
+
+  MAX_OUTPUT_BYTES: Integer
+
+  # @rbs context: Riffer::Agent::Context?
+  # @rbs command: String
+  # @rbs ?timeout_ms: Integer
+  # @rbs return: Riffer::Tools::Response
+  def call: (context: Riffer::Agent::Context?, command: String, ?timeout_ms: untyped) -> Riffer::Tools::Response
+
+  private
+
+  # @rbs command: String
+  # @rbs timeout_seconds: Float
+  # @rbs return: [String, Integer]
+  def run: (String command, Float timeout_seconds) -> [ String, Integer ]
+
+  # @rbs pid: Integer
+  # @rbs return: Integer
+  def kill_group: (Integer pid) -> Integer
+
+  # @rbs output: String
+  # @rbs return: String
+  def truncate: (String output) -> String
+end

data/sig/generated/riffer/rig/tools/edit.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/riffer/rig/tools/edit.rb with RBS::Inline
+
+class Riffer::Rig::Tools::Edit < Riffer::Tool
+  # @rbs context: Riffer::Agent::Context?
+  # @rbs path: String
+  # @rbs old_string: String
+  # @rbs new_string: String
+  # @rbs ?replace_all: bool
+  # @rbs return: Riffer::Tools::Response
+  def call: (context: Riffer::Agent::Context?, path: String, old_string: String, new_string: String, ?replace_all: untyped) -> Riffer::Tools::Response
+end

data/sig/generated/riffer/rig/tools/read.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/riffer/rig/tools/read.rb with RBS::Inline
+
+class Riffer::Rig::Tools::Read < Riffer::Tool
+  DEFAULT_LIMIT: Integer
+
+  # @rbs context: Riffer::Agent::Context?
+  # @rbs path: String
+  # @rbs ?offset: Integer?
+  # @rbs ?limit: Integer
+  # @rbs return: Riffer::Tools::Response
+  def call: (context: Riffer::Agent::Context?, path: String, ?offset: untyped, ?limit: untyped) -> Riffer::Tools::Response
+end

data/sig/generated/riffer/rig/tools/write.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/riffer/rig/tools/write.rb with RBS::Inline
+
+class Riffer::Rig::Tools::Write < Riffer::Tool
+  # @rbs context: Riffer::Agent::Context?
+  # @rbs path: String
+  # @rbs content: String
+  # @rbs return: Riffer::Tools::Response
+  def call: (context: Riffer::Agent::Context?, path: String, content: String) -> Riffer::Tools::Response
+end

data/sig/generated/riffer/rig/ui/animator.rbs

@@ -0,0 +1,76 @@
+# Generated from lib/riffer/rig/ui/animator.rb with RBS::Inline
+
+# Animated output is gated behind an interactive, colour-enabled TTY, so piped
+# or tested runs stay silent and escape-free.
+class Riffer::Rig::UI::Animator
+  REVEAL_FRAME_SECONDS: Float
+
+  SPINNER_FRAME_SECONDS: Float
+
+  EQ_LEVELS: Array[String]
+
+  EQ_BARS: Integer
+
+  NEUTRAL_LABEL: String
+
+  REASONING_PHRASES: Array[String]
+
+  REASONING_TICK_RANGE: Range[Integer]
+
+  @stop: bool
+
+  @phrase: String?
+
+  @mode: Symbol
+
+  @thread: Thread?
+
+  @theme: Riffer::Rig::UI::Theme
+
+  @io: untyped
+
+  # @rbs io: untyped
+  # @rbs ?theme: Riffer::Rig::UI::Theme
+  # @rbs return: void
+  def initialize: (?io: untyped, ?theme: untyped) -> void
+
+  # When not on a TTY, prints the final frame once instead of animating.
+  #
+  # @rbs frames: Array[Array[String]]
+  # @rbs return: void
+  def reveal: (Array[Array[String]] frames) -> void
+
+  # @rbs ?mode: Symbol
+  # @rbs return: void
+  def start: (?untyped mode) -> void
+
+  # @rbs return: void
+  def stop: () -> void
+
+  # @rbs tick: Integer
+  # @rbs ?label: String
+  # @rbs return: String
+  def equalizer: (Integer tick, ?untyped label) -> String
+
+  private
+
+  # @rbs return: void
+  def animate: () -> void
+
+  # Re-rolls both phrase and duration whenever the reasoning tick expires.
+  #
+  # @rbs roll_at: Float
+  # @rbs return: Float
+  def roll_phrase: (Float roll_at) -> Float
+
+  # Range rand returns nil for an empty range; this one is a non-empty constant.
+  #
+  # @rbs return: Integer
+  def roll_rand: () -> Integer
+
+  # @rbs return: String
+  def label: () -> String
+
+  # @rbs return: bool
+  def enabled?: () -> bool
+end

data/sig/generated/riffer/rig/ui/banner.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/riffer/rig/ui/banner.rb with RBS::Inline
+
+module Riffer::Rig::UI::Banner
+  WORDMARK: Array[String]
+
+  ROW_COLOURS: Array[Array[Integer]]
+
+  INFO_LABEL_WIDTH: Integer
+
+  INDENT: String
+
+  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs model: String
+  # @rbs cwd: String
+  # @rbs context: String
+  # @rbs skills: String
+  # @rbs version: String
+  # @rbs return: String
+  def call: (Riffer::Rig::UI::Theme theme, model: String, cwd: String, context: String, skills: String, version: String) -> String
+
+  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs model: String
+  # @rbs cwd: String
+  # @rbs context: String
+  # @rbs skills: String
+  # @rbs version: String
+  # @rbs return: Array[String]
+  def lines: (Riffer::Rig::UI::Theme theme, model: String, cwd: String, context: String, skills: String, version: String) -> Array[String]
+
+  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs return: Array[String]
+  def art: (Riffer::Rig::UI::Theme theme) -> Array[String]
+
+  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs model: String
+  # @rbs cwd: String
+  # @rbs context: String
+  # @rbs skills: String
+  # @rbs version: String
+  # @rbs return: Array[String]
+  def info: (Riffer::Rig::UI::Theme theme, model: String, cwd: String, context: String, skills: String, version: String) -> Array[String]
+end

data/sig/generated/riffer/rig/ui/cursor.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/riffer/rig/ui/cursor.rb with RBS::Inline
+
+# Hides the terminal cursor while a turn is in flight: a hidden cursor can't
+# flicker against the animator's erase-and-redraw churn.
+class Riffer::Rig::UI::Cursor
+  HIDE: String
+
+  SHOW: String
+
+  @io: untyped
+
+  @theme: Riffer::Rig::UI::Theme
+
+  # @rbs io: untyped
+  # @rbs ?theme: Riffer::Rig::UI::Theme
+  # @rbs return: void
+  def initialize: (?io: untyped, ?theme: untyped) -> void
+
+  # @rbs return: void
+  def hide: () -> void
+
+  # @rbs return: void
+  def show: () -> void
+
+  private
+
+  # @rbs sequence: String
+  # @rbs return: void
+  def write: (String sequence) -> void
+
+  # @rbs return: bool
+  def enabled?: () -> bool
+end

data/sig/generated/riffer/rig/ui/palette.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/riffer/rig/ui/palette.rb with RBS::Inline
+
+module Riffer::Rig::UI::Palette
+  PINK: Array[Integer]
+
+  MAGENTA: Array[Integer]
+
+  PURPLE: Array[Integer]
+
+  BLUE: Array[Integer]
+
+  CYAN: Array[Integer]
+
+  GREY: Array[Integer]
+
+  RED: Array[Integer]
+end

data/sig/generated/riffer/rig/ui/renderer.rbs

@@ -0,0 +1,68 @@
+# Generated from lib/riffer/rig/ui/renderer.rb with RBS::Inline
+
+class Riffer::Rig::UI::Renderer
+  RESULT_PREVIEW_LIMIT: Integer
+
+  @io: untyped
+
+  @theme: Riffer::Rig::UI::Theme
+
+  @tally: Riffer::Rig::TokenTally?
+
+  @smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
+
+  # @rbs io: untyped
+  # @rbs ?theme: Riffer::Rig::UI::Theme
+  # @rbs ?tally: Riffer::Rig::TokenTally?
+  # @rbs ?smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
+  # @rbs return: void
+  def initialize: (?io: untyped, ?theme: untyped, ?tally: untyped, ?smoother: untyped) -> void
+
+  # @rbs event: Riffer::StreamEvents::Base
+  # @rbs return: void
+  def render: (Riffer::StreamEvents::Base event) -> void
+
+  # @rbs message: Riffer::Messages::Base
+  # @rbs return: void
+  def render_tool_result: (Riffer::Messages::Base message) -> void
+
+  private
+
+  # @rbs return: Riffer::Rig::UI::Smoother | PassThroughSmoother
+  def smoother: () -> (Riffer::Rig::UI::Smoother | PassThroughSmoother)
+
+  # Stand-in when no smoother is injected, so a bare Riffer::Rig::UI::Renderer still prints
+  # synchronously.
+  class PassThroughSmoother
+    @io: untyped
+
+    # @rbs io: untyped
+    # @rbs return: void
+    def initialize: (untyped io) -> void
+
+    # @rbs content: String
+    # @rbs return: self
+    def <<: (String content) -> self
+
+    # @rbs return: nil
+    def drain: () -> nil
+
+    # @rbs return: nil
+    def finish: () -> nil
+  end
+
+  # @rbs return: void
+  def drain_smoother: () -> void
+
+  # @rbs usage: Riffer::Providers::TokenUsage
+  # @rbs return: void
+  def render_token_usage: (Riffer::Providers::TokenUsage usage) -> void
+
+  # @rbs arguments: String
+  # @rbs return: String
+  def format_arguments: (String arguments) -> String
+
+  # @rbs content: String
+  # @rbs return: String
+  def preview: (String content) -> String
+end

data/sig/generated/riffer/rig/ui/smoother.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/riffer/rig/ui/smoother.rb with RBS::Inline
+
+# 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: Float
+
+  # 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
+
+  MIN_CHARS_PER_TICK: Rational
+
+  @stop: bool
+
+  @thread: Thread?
+
+  @mutex: Mutex
+
+  @carry: Rational
+
+  @backlog: String
+
+  @clock: singleton(Kernel)
+
+  @theme: Riffer::Rig::UI::Theme
+
+  @io: untyped
+
+  # @rbs io: untyped
+  # @rbs ?theme: Riffer::Rig::UI::Theme
+  # @rbs clock: singleton(Kernel)
+  # @rbs return: void
+  def initialize: (?io: untyped, ?theme: untyped, ?clock: singleton(Kernel)) -> void
+
+  # @rbs return: void
+  def start: () -> void
+
+  # @rbs content: String
+  # @rbs return: self
+  def <<: (String content) -> self
+
+  # The write sits inside the mutex so a concurrent tick can't reorder a drain.
+  #
+  # @rbs return: void
+  def tick: () -> void
+
+  # Called before non-delta output so printed order matches stream order.
+  #
+  # @rbs return: void
+  def drain: () -> void
+
+  # Idempotent: the REPL's ensure path runs it even after a happy-path finish.
+  #
+  # @rbs return: void
+  def finish: () -> void
+
+  private
+
+  # @rbs return: bool
+  def enabled?: () -> bool
+end

data/sig/generated/riffer/rig/ui/theme.rbs

@@ -0,0 +1,60 @@
+# Generated from lib/riffer/rig/ui/theme.rb with RBS::Inline
+
+# +enabled+ gates every escape so the same code path emits plain, escape-free
+# text when piped or tested.
+class Riffer::Rig::UI::Theme
+  @enabled: bool
+
+  # @rbs return: bool
+  # @dynamic enabled
+  attr_reader enabled: bool
+
+  # @rbs enabled: bool
+  # @rbs return: void
+  def initialize: (enabled: bool) -> void
+
+  # @rbs io: untyped
+  # @rbs return: Riffer::Rig::UI::Theme
+  def self.for: (untyped io) -> Riffer::Rig::UI::Theme
+
+  # @rbs text: String
+  # @rbs rgb: Array[Integer]
+  # @rbs return: String
+  def paint: (String text, Array[Integer] rgb) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def pink: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def magenta: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def purple: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def blue: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def cyan: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def grey: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def red: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def dim: (String text) -> String
+
+  # @rbs text: String
+  # @rbs return: String
+  def bold: (String text) -> String
+end

data/sig/generated/riffer/rig/version.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/riffer/rig/version.rb with RBS::Inline
+
+module Riffer
+  module Rig
+    VERSION: ::String
+  end
+end