riffer-rig 0.6.0 → 0.7.0

data/lib/riffer/rig/settings/document.rb

@@ -1,28 +1,39 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Settings::Document
-  # @rbs @model: String?
-  # @rbs @reasoning: String?
-  # @rbs @models: Hash[String, Riffer::Rig::Settings::Pricing]
-  # @rbs @providers: Hash[String, Hash[String, String]]
-
-  # @dynamic model, reasoning, models, providers
+  # @dynamic model, reasoning, models, providers, disabled
   attr_reader :model #: String?
   attr_reader :reasoning #: String?
   attr_reader :models #: Hash[String, Riffer::Rig::Settings::Pricing]
   attr_reader :providers #: Hash[String, Hash[String, String]]
+  attr_reader :disabled #: Array[String]
 
-  # @rbs source: untyped
+  # @rbs source: Hash[Symbol, untyped]
   # @rbs return: void
   def initialize(source)
-    @model = source['model'].is_a?(String) ? source['model'] : nil
-    @reasoning = source['reasoning'].is_a?(String) ? source['reasoning'] : nil
-    entries = source['models'].is_a?(Hash) ? source['models'] : {} #: Hash[String, untyped]
-    @models = entries.filter_map do |name, entry|
-      [name, Riffer::Rig::Settings::Pricing.from(entry)] if name.is_a?(String) && entry.is_a?(Hash)
-    end.to_h
-    blocks = source['providers'].is_a?(Hash) ? source['providers'] : {} #: Hash[String, untyped]
-    @providers = blocks.select { |_identifier, fields| fields.is_a?(Hash) }
-                       .transform_values { |fields| fields.select { |_name, value| value.is_a?(String) } }
+    @model = source[:model].is_a?(String) ? source[:model] : nil
+    @reasoning = source[:reasoning].is_a?(String) ? source[:reasoning] : nil
+    @models = hash_or_empty(source[:models]).filter_map do |name, entry|
+      [name.to_s, Riffer::Rig::Settings::Pricing.from(entry)] if entry.is_a?(Hash)
+    end.to_h.freeze
+    @providers = hash_or_empty(source[:providers]).filter_map do |identifier, fields|
+      if fields.is_a?(Hash)
+        [identifier.to_s, fields.select do |_name, value|
+          value.is_a?(String)
+        end.transform_keys(&:to_s)]
+      end
+    end.to_h.freeze
+    disabled = hash_or_empty(source[:extensions])[:disabled]
+    names = disabled.is_a?(Array) ? disabled.grep(String) : [] #: Array[String]
+    @disabled = names.freeze
+    freeze
+  end
+
+  private
+
+  # @rbs value: untyped
+  # @rbs return: Hash[Symbol, untyped]
+  def hash_or_empty(value)
+    value.is_a?(Hash) ? value : {}
   end
 end

data/lib/riffer/rig/settings/pricing.rb

@@ -4,17 +4,28 @@ class Riffer::Rig::Settings::Pricing
   # @dynamic input, output, cache_write, cache_read
   attr_reader :input, :output, :cache_write, :cache_read #: Float
 
-  # @rbs entry: Hash[String, untyped]
+  # @rbs entry: Hash[Symbol, untyped]
   # @rbs return: ::Riffer::Rig::Settings::Pricing
   def self.from(entry)
     new(
-      input: entry.fetch('input', 0).to_f,
-      output: entry.fetch('output', 0).to_f,
-      cache_write: entry.fetch('cache_write', 0).to_f,
-      cache_read: entry.fetch('cache_read', 0).to_f
+      input: entry.fetch(:input, 0).to_f,
+      output: entry.fetch(:output, 0).to_f,
+      cache_write: entry.fetch(:cache_write, 0).to_f,
+      cache_read: entry.fetch(:cache_read, 0).to_f
     )
   end
 
+  # @rbs table: Hash[String, ::Riffer::Rig::Settings::Pricing]
+  # @rbs registry: ::Riffer::Config::Pricing
+  # @rbs return: void
+  def self.register(table, registry)
+    table.each do |model, entry|
+      registry.set(
+        model, input: entry.input, output: entry.output, cache_read: entry.cache_read, cache_write: entry.cache_write
+      )
+    end
+  end
+
   # @rbs input: Float
   # @rbs output: Float
   # @rbs cache_write: Float

data/lib/riffer/rig/settings.rb

@@ -8,45 +8,85 @@ module Riffer::Rig::Settings
 
   PATH = File.expand_path('~/.riffer/settings.json') #: String
 
-  DEFAULT_MODEL = 'anthropic/claude-sonnet-4-6'
-
   REASONING_LEVELS_BY_PROVIDER = {
     'anthropic' => %w[low medium high xhigh max].freeze,
     'openai' => %w[low medium high xhigh].freeze,
     'openrouter' => %w[low medium high xhigh].freeze
   }.freeze #: Hash[String, Array[String]]
 
+  MODEL_STRING = %r{\A(?<provider>[^/\s]+)/\S+\z} #: Regexp
+
+  # Upstream candidate: riffer's Repository keeps extension registrations
+  # private and lists no identifiers, so the list names riffer's built-ins.
+  PROVIDERS = (Riffer::Providers::Repository::REPO.keys - [:mock]).freeze #: Array[Symbol]
+
   # @rbs path: String
-  # @rbs return: String
-  def model(path: PATH)
-    read(path).model || DEFAULT_MODEL
+  # @rbs return: Hash[Symbol, untyped]
+  def read(path)
+    return {} unless File.file?(path)
+
+    source = JSON.parse(File.read(path), symbolize_names: true)
+    source.is_a?(Hash) ? source : {}
+  rescue JSON::ParserError
+    {}
   end
 
-  # @rbs path: String
+  # MCP servers merge by name, whole, so a home server's headers never reach a
+  # project server's url.
+  # @rbs home: Hash[Symbol, untyped]
+  # @rbs project: Hash[Symbol, untyped]
   # @rbs return: Hash[Symbol, untyped]
-  def model_options(path: PATH)
-    provider = provider_for(model(path:))
-    base_options(provider).merge(reasoning_options(reasoning_for(path:, provider:), provider))
+  def merge(home, project)
+    merged = deep_merge(home, project)
+    home_mcp = home[:mcp]
+    project_mcp = project[:mcp]
+    if home_mcp.is_a?(Hash) && project_mcp.is_a?(Hash)
+      merged = merged.merge(mcp: Riffer::Rig::Mcp.merge(home_mcp, project_mcp))
+    end
+    disabled = [home, project].flat_map { |scope| Document.new(scope).disabled }.uniq
+    return merged if disabled.empty?
+
+    extensions = merged[:extensions].is_a?(Hash) ? merged[:extensions] : {} #: Hash[Symbol, untyped]
+    merged.merge(extensions: extensions.merge(disabled: disabled))
   end
 
-  # @rbs model_string: String
+  # @rbs model: String
+  # @rbs return: String?
+  def provider_for(model)
+    model[MODEL_STRING, :provider]
+  end
+
+  # @rbs model: String
   # @rbs return: String?
-  def provider_for(model_string)
-    model_string.split('/', 2).first if model_string.include?('/')
+  def rejection(model)
+    provider = provider_for(model)
+    return if provider && Riffer::Providers::Repository.find(provider)
+
+    "#{model} is not a provider/name model string; the provider is one of: #{PROVIDERS.join(', ')}"
+  end
+
+  # @rbs model: String
+  # @rbs reasoning: String?
+  # @rbs return: Hash[Symbol, untyped]
+  def model_options(model, reasoning)
+    provider = provider_for(model)
+    levels = (provider && REASONING_LEVELS_BY_PROVIDER[provider]) || []
+    level = reasoning if levels.include?(reasoning)
+    base_options(provider).merge(reasoning_options(level, provider))
   end
 
   # @rbs model: String
   # @rbs path: String
-  # @rbs return: Pricing?
-  def pricing_for(model, path: PATH)
-    read(path).models[model]
+  # @rbs return: void
+  def store_model(model, path: PATH)
+    write(path, read(path).merge(model: model))
   end
 
   # @rbs identifier: String
   # @rbs path: String
   # @rbs return: Hash[String, String]
   def provider_fields(identifier, path: PATH)
-    read(path).providers[identifier] || {}
+    Document.new(read(path)).providers[identifier] || {}
   end
 
   # @rbs identifier: String
@@ -68,17 +108,32 @@ module Riffer::Rig::Settings
 
   private
 
+  # @rbs home: Hash[Symbol, untyped]
+  # @rbs project: Hash[Symbol, untyped]
+  # @rbs return: Hash[Symbol, untyped]
+  def deep_merge(home, project)
+    home.merge(project) do |_key, earlier, later|
+      earlier.is_a?(Hash) && later.is_a?(Hash) ? deep_merge(earlier, later) : later
+    end
+  end
+
   # @rbs path: String
   # @rbs &: (Hash[String, Hash[String, String]]) -> Hash[String, Hash[String, String]]
   # @rbs return: void
   def update_providers(path)
-    source = read_source(path)
+    source = read(path)
     current = Document.new(source).providers
     providers = yield current
     return if providers == current
 
+    write(path, providers.empty? ? source.except(:providers) : source.merge(providers: providers))
+  end
+
+  # @rbs path: String
+  # @rbs document: Hash[Symbol, untyped]
+  # @rbs return: void
+  def write(path, document)
     FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
-    document = providers.empty? ? source.except('providers') : source.merge('providers' => providers)
     File.write(path, JSON.pretty_generate(document))
   end
 
@@ -90,15 +145,6 @@ module Riffer::Rig::Settings
     {}
   end
 
-  # @rbs path: String
-  # @rbs provider: String?
-  # @rbs return: String?
-  def reasoning_for(path: PATH, provider: nil)
-    level = read(path).reasoning
-    valid_levels = (provider && REASONING_LEVELS_BY_PROVIDER[provider]) || []
-    valid_levels.include?(level) ? level : nil
-  end
-
   # @rbs level: String?
   # @rbs provider: String?
   # @rbs return: Hash[Symbol, untyped]
@@ -114,20 +160,4 @@ module Riffer::Rig::Settings
       {}
     end
   end
-
-  # @rbs path: String
-  # @rbs return: Document
-  def read(path)
-    Document.new(read_source(path))
-  end
-
-  # @rbs path: String
-  # @rbs return: Hash[String, untyped]
-  def read_source(path)
-    return {} unless File.file?(path)
-
-    JSON.parse(File.read(path))
-  rescue JSON::ParserError
-    {}
-  end
 end

data/lib/riffer/rig/skills/sources.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Upstream candidate: riffer's Skills::Config takes a single backend, so the
+# sources every extension registers are merged into one here.
+class Riffer::Rig::Skills::Sources < Riffer::Skills::Backend
+  # @rbs @backends: Array[Riffer::Skills::Backend]
+
+  # @rbs backends: Array[Riffer::Skills::Backend]
+  # @rbs return: void
+  def initialize(backends)
+    super()
+    @backends = backends
+  end
+
+  # @rbs return: Array[Riffer::Skills::Frontmatter]
+  def list_skills
+    @backends.flat_map(&:list_skills).uniq(&:name)
+  end
+
+  # @rbs name: String
+  # @rbs return: String
+  def read_skill(name)
+    backend = @backends.find { |source| source.list_skills.any? { |skill| skill.name == name } }
+    raise Riffer::ArgumentError, "Skill not found: '#{name}'" unless backend
+
+    backend.read_skill(name)
+  end
+end

data/lib/riffer/rig/skills.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Skills
+  extend self
+
+  # @rbs cwd: String
+  # @rbs return: Array[String]
+  def directories(cwd)
+    project = Riffer::Rig::Directories.up_to_repo_root(cwd).map { |dir| File.join(dir, '.agents', 'skills') }
+    [*project, File.join(Dir.home, '.agents', 'skills')]
+  end
+end

data/lib/riffer/rig/{events/event.rb → support/equatable.rb}

@@ -1,16 +1,7 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::Event
-  # @rbs return: Symbol
-  def type
-    raise NotImplementedError, "#{self.class.name} must define type"
-  end
-
-  # @rbs return: Hash[Symbol, untyped]
-  def to_h
-    raise NotImplementedError, "#{self.class.name} must define to_h"
-  end
-
+# @rbs module-self Riffer::Rig::Support::_ToH
+module Riffer::Rig::Support::Equatable
   # @rbs other: untyped
   # @rbs return: bool
   def ==(other)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::UI::Animator
+class Riffer::Rig::Terminal::Animator
   REVEAL_FRAME_SECONDS = 0.05 #: Float
 
   SPINNER_FRAME_SECONDS = 0.12 #: Float
@@ -22,16 +22,16 @@ class Riffer::Rig::UI::Animator
   REASONING_TICK_RANGE = (1..5) #: Range[Integer]
 
   # @rbs @io: IO
-  # @rbs @theme: Riffer::Rig::UI::Theme
+  # @rbs @theme: Riffer::Rig::Terminal::Theme
   # @rbs @thread: Thread?
   # @rbs @mode: Symbol
   # @rbs @phrase: String?
   # @rbs @stop: bool
 
   # @rbs io: IO
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs return: void
-  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io))
+  def initialize(io: $stdout, theme: Riffer::Rig::Terminal::Theme.for(io))
     @io = io
     @theme = theme
     @thread = nil

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Riffer::Rig::UI::Banner
+module Riffer::Rig::Terminal::Banner
   extend self
 
   WORDMARK = [
@@ -13,57 +13,53 @@ module Riffer::Rig::UI::Banner
   ].freeze #: Array[String]
 
   ROW_COLOURS = [
-    Riffer::Rig::UI::Palette::PINK,
-    Riffer::Rig::UI::Palette::MAGENTA,
-    Riffer::Rig::UI::Palette::PURPLE,
-    Riffer::Rig::UI::Palette::BLUE,
-    Riffer::Rig::UI::Palette::CYAN,
-    Riffer::Rig::UI::Palette::CYAN
+    Riffer::Rig::Terminal::Palette::PINK,
+    Riffer::Rig::Terminal::Palette::MAGENTA,
+    Riffer::Rig::Terminal::Palette::PURPLE,
+    Riffer::Rig::Terminal::Palette::BLUE,
+    Riffer::Rig::Terminal::Palette::CYAN,
+    Riffer::Rig::Terminal::Palette::CYAN
   ].freeze #: Array[Array[Integer]]
 
   INFO_LABEL_WIDTH = 8 #: Integer
 
   INDENT = '  ' #: String
 
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs model: String
   # @rbs cwd: String
-  # @rbs context: String
   # @rbs skills: String
   # @rbs version: String
   # @rbs return: String
-  def call(theme, model:, cwd:, context:, skills:, version:)
-    lines(theme, model: model, cwd: cwd, context: context, skills: skills, version: version).join("\n")
+  def call(theme, model:, cwd:, skills:, version:)
+    lines(theme, model: model, cwd: cwd, skills: skills, version: version).join("\n")
   end
 
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs model: String
   # @rbs cwd: String
-  # @rbs context: String
   # @rbs skills: String
   # @rbs version: String
   # @rbs return: Array[String]
-  def lines(theme, model:, cwd:, context:, skills:, version:)
-    [''] + art(theme) + [''] +
-      info(theme, model: model, cwd: cwd, context: context, skills: skills, version: version) + ['']
+  def lines(theme, model:, cwd:, skills:, version:)
+    [''] + art(theme) + [''] + info(theme, model: model, cwd: cwd, skills: skills, version: version) + ['']
   end
 
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs return: Array[String]
   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
 
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs model: String
   # @rbs cwd: String
-  # @rbs context: String
   # @rbs skills: String
   # @rbs version: String
   # @rbs return: Array[String]
-  def info(theme, model:, cwd:, context:, skills:, version:)
-    rows = { model: model, cwd: cwd, context: context, skills: skills, version: version }.map do |label, value|
+  def info(theme, model:, cwd:, skills:, version:)
+    rows = { model: model, cwd: cwd, skills: skills, version: version }.map do |label, value|
       "  #{theme.magenta('▸')} #{theme.grey(label.to_s.ljust(INFO_LABEL_WIDTH))}#{value}"
     end
     rows + ['', "  #{theme.dim('type /exit to quit')}"]

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

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::UI::Cursor
+class Riffer::Rig::Terminal::Cursor
   HIDE = "\e[?25l" #: String
 
   SHOW = "\e[?25h" #: String
 
   # @rbs @io: IO
-  # @rbs @theme: Riffer::Rig::UI::Theme
+  # @rbs @theme: Riffer::Rig::Terminal::Theme
 
   # @rbs io: IO
-  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs return: void
-  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io))
+  def initialize(io: $stdout, theme: Riffer::Rig::Terminal::Theme.for(io))
     @io = io
     @theme = theme
   end

data/lib/riffer/rig/terminal/host.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+class Riffer::Rig::Terminal::Host
+  CAPABILITIES = Set[:ask, :confirm, :notify, :progress].freeze #: Set[Symbol]
+
+  # @rbs @input: IO
+  # @rbs @renderer: Riffer::Rig::Terminal::Renderer
+  # @rbs @animator: Riffer::Rig::Terminal::Animator
+
+  # @rbs input: IO
+  # @rbs renderer: Riffer::Rig::Terminal::Renderer
+  # @rbs animator: Riffer::Rig::Terminal::Animator
+  # @rbs return: void
+  def initialize(input:, renderer:, animator:)
+    @input = input
+    @renderer = renderer
+    @animator = animator
+  end
+
+  # @rbs return: Set[Symbol]
+  def capabilities
+    CAPABILITIES
+  end
+
+  # @rbs question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
+  # @rbs return: String?
+  def ask(question = nil, options: nil, secret: false)
+    @animator.stop
+    @renderer.question(question, options, secret)
+    answer = secret ? read_secret : @input.gets
+    return nil if answer.nil?
+
+    choice(answer.strip, options)
+  end
+
+  # @rbs question: String?
+  # @rbs return: bool
+  def confirm(question = nil)
+    ask("#{question} [y/N]").to_s.downcase.start_with?('y')
+  end
+
+  # @rbs message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(message = nil, level: :info)
+    @animator.stop
+    @renderer.notify(message.to_s, level)
+  end
+
+  # @rbs label: String?
+  # @rbs &block: ? () -> void
+  # @rbs return: void
+  def progress(label = nil, &block)
+    @renderer.notice(label) if label
+    @animator.start
+    block&.call
+  ensure
+    @animator.stop
+  end
+
+  private
+
+  # @rbs return: String?
+  def read_secret
+    return @input.gets unless @input.tty?
+
+    answer = @input.noecho(&:gets)
+    # noecho swallows the newline the user typed along with the secret.
+    @renderer.newline
+    answer
+  end
+
+  # @rbs answer: String
+  # @rbs options: Array[String]?
+  # @rbs return: String
+  def choice(answer, options)
+    return answer unless options && answer.match?(/\A[1-9]\d*\z/)
+
+    options[answer.to_i - 1] || answer
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Riffer::Rig::UI::Palette
+module Riffer::Rig::Terminal::Palette
   PINK = [255, 106, 193].freeze #: Array[Integer]
 
   MAGENTA = [192, 76, 253].freeze #: Array[Integer]