riffer-rig 0.6.0 → 0.7.0

data/lib/riffer/rig/commands/skill.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Commands::Skill
+  extend self
+
+  # @rbs skill: Riffer::Skills::Frontmatter
+  # @rbs return: Riffer::Rig::Command
+  def command(skill)
+    Riffer::Rig::Command.new("skill:#{skill.name}", description: skill.description, extension: 'core') do |ctx|
+      run(ctx, skill)
+    end
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs skill: Riffer::Skills::Frontmatter
+  # @rbs return: void
+  def run(ctx, skill)
+    skills = ctx.runtime.agent.context.skills
+    return ctx.host.notify("Skill #{skill.name} is no longer available", level: :error) unless skills
+
+    # Context#read, not #activate: a skill the user runs stays in the model's
+    # catalog, and only the model's own activations are recorded.
+    content = skills.adapter.render_activation(skill, skills.read(skill.name))
+    ctx.emit(Riffer::Rig::Events::SkillActivated.new(skill.name))
+    ctx.prompt([content, ctx.args.strip].reject(&:empty?).join("\n\n"))
+  end
+end

data/lib/riffer/rig/commands.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Commands
+end

data/lib/riffer/rig/credentials.rb

@@ -12,7 +12,7 @@ module Riffer::Rig::Credentials
   ENTRY_TYPE = 'api_key'
 
   # @rbs identifier: String | Symbol
-  # @rbs host: Riffer::Rig::Hosts::Base
+  # @rbs host: Riffer::Rig::Hosts::_Host
   # @rbs setup: Riffer::Rig::ProviderSetup
   # @rbs env: Riffer::Rig::Env
   # @rbs auth_path: String
@@ -106,7 +106,7 @@ module Riffer::Rig::Credentials
 
   # @rbs fields: Array[Riffer::Rig::ProviderSetup::Field]
   # @rbs identifier: String | Symbol
-  # @rbs host: Riffer::Rig::Hosts::Base
+  # @rbs host: Riffer::Rig::Hosts::_Host
   # @rbs return: Hash[Symbol, String]
   def ask_for(fields, identifier, host)
     fields.to_h do |field|

data/lib/riffer/rig/directories.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Directories
+  extend self
+
+  # @rbs dir: String
+  # @rbs return: Array[String]
+  def ancestors(dir)
+    parent = File.dirname(dir)
+    parent == dir ? [dir] : [dir, *ancestors(parent)]
+  end
+
+  # @rbs cwd: String
+  # @rbs return: Array[String]
+  def up_to_repo_root(cwd)
+    dirs = ancestors(File.expand_path(cwd))
+    root = dirs.index { |dir| File.exist?(File.join(dir, '.git')) } || 0
+    dirs.take(root + 1)
+  end
+end

data/lib/riffer/rig/env/invalid.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Env::Invalid
+  # @dynamic message
+  attr_reader :message #: String
+
+  # @rbs message: String
+  # @rbs return: void
+  def initialize(message)
+    @message = message
+    freeze
+  end
+end

data/lib/riffer/rig/env.rb

@@ -3,14 +3,25 @@
 class Riffer::Rig::Env
   # @rbs @source: Hash[String, String]
 
-  # @dynamic no_color
+  # @dynamic no_color, model
   attr_reader :no_color #: bool
+  attr_reader :model #: String?
+
+  # @rbs source: Hash[String, String]
+  # @rbs return: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
+  def self.load(source = ENV.to_h)
+    env = new(source)
+    model = env.model
+    rejection = model && Riffer::Rig::Settings.rejection(model)
+    rejection ? Invalid.new("RIFFER_MODEL: #{rejection}") : env
+  end
 
   # @rbs source: Hash[String, String]
   # @rbs return: void
   def initialize(source = ENV.to_h)
     @source = source.freeze
     @no_color = @source.key?('NO_COLOR')
+    @model = self['RIFFER_MODEL']
     freeze
   end
 

data/lib/riffer/rig/events/after_response.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::AfterResponse
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic message
+  attr_reader :message #: ::Riffer::Messages::Assistant
+
+  # @rbs message: ::Riffer::Messages::Assistant
+  # @rbs return: void
+  def initialize(message)
+    @message = message
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :after_response
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, message: message }
+  end
+end

data/lib/riffer/rig/events/after_tool_call.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::AfterToolCall
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic tool, args, result
+  attr_reader :tool #: String
+  attr_reader :args #: Hash[Symbol, untyped]
+  attr_reader :result #: ::Riffer::Tools::Response
+
+  # @rbs tool: String
+  # @rbs args: Hash[Symbol, untyped]
+  # @rbs result: ::Riffer::Tools::Response
+  # @rbs return: void
+  def initialize(tool, args, result)
+    @tool = tool
+    @args = args.dup.freeze
+    @result = result
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :after_tool_call
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, tool: tool, args: args, result: result }
+  end
+end

data/lib/riffer/rig/events/before_prompt.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::BeforePrompt
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic text
+  attr_reader :text #: String
+
+  # @rbs text: String
+  # @rbs return: void
+  def initialize(text)
+    @text = text
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :before_prompt
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, text: text }
+  end
+end

data/lib/riffer/rig/events/before_request.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::BeforeRequest
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic messages
+  attr_reader :messages #: Array[::Riffer::Messages::Base]
+
+  # @rbs messages: Array[::Riffer::Messages::Base]
+  # @rbs return: void
+  def initialize(messages)
+    @messages = messages.dup.freeze
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :before_request
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, messages: messages }
+  end
+end

data/lib/riffer/rig/events/before_tool_call.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::BeforeToolCall
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic tool, args
+  attr_reader :tool #: String
+  attr_reader :args #: Hash[Symbol, untyped]
+
+  # @rbs tool: String
+  # @rbs args: Hash[Symbol, untyped]
+  # @rbs return: void
+  def initialize(tool, args)
+    @tool = tool
+    @args = args.dup.freeze
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :before_tool_call
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, tool: tool, args: args }
+  end
+end

data/lib/riffer/rig/events/command_output.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::CommandOutput < Riffer::Rig::Events::Event
+class Riffer::Rig::Events::CommandOutput
+  include Riffer::Rig::Support::Equatable
+
   # @dynamic command, text
   attr_reader :command #: String
   attr_reader :text #: String
@@ -9,7 +11,6 @@ class Riffer::Rig::Events::CommandOutput < Riffer::Rig::Events::Event
   # @rbs text: String
   # @rbs return: void
   def initialize(command, text)
-    super()
     @command = command
     @text = text
     freeze

data/lib/riffer/rig/events/notify.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::Notify < Riffer::Rig::Events::Event
+class Riffer::Rig::Events::Notify
+  include Riffer::Rig::Support::Equatable
+
   # @dynamic message, level
   attr_reader :message #: String?
   attr_reader :level #: Symbol
@@ -9,7 +11,6 @@ class Riffer::Rig::Events::Notify < Riffer::Rig::Events::Event
   # @rbs level: Symbol
   # @rbs return: void
   def initialize(message, level)
-    super()
     @message = message
     @level = level
     freeze

data/lib/riffer/rig/events/session_end.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::SessionEnd < Riffer::Rig::Events::Event
+class Riffer::Rig::Events::SessionEnd
+  include Riffer::Rig::Support::Equatable
+
   # @dynamic reason
   attr_reader :reason #: Symbol
 
   # @rbs reason: Symbol
   # @rbs return: void
   def initialize(reason)
-    super()
     @reason = reason
     freeze
   end

data/lib/riffer/rig/events/session_start.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::SessionStart < Riffer::Rig::Events::Event
+class Riffer::Rig::Events::SessionStart
+  include Riffer::Rig::Support::Equatable
+
   # @dynamic id, reason
   attr_reader :id #: String
   attr_reader :reason #: Symbol
@@ -9,7 +11,6 @@ class Riffer::Rig::Events::SessionStart < Riffer::Rig::Events::Event
   # @rbs reason: Symbol
   # @rbs return: void
   def initialize(id, reason)
-    super()
     @id = id
     @reason = reason
     freeze

data/lib/riffer/rig/events/skill_activated.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::SkillActivated < Riffer::Rig::Events::Event
+class Riffer::Rig::Events::SkillActivated
+  include Riffer::Rig::Support::Equatable
+
   # @dynamic name
   attr_reader :name #: String
 
   # @rbs name: String
   # @rbs return: void
   def initialize(name)
-    super()
     @name = name
     freeze
   end

data/lib/riffer/rig/events/turn_end.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Events::TurnEnd < Riffer::Rig::Events::Event
+class Riffer::Rig::Events::TurnEnd
+  include Riffer::Rig::Support::Equatable
+
   # @dynamic stop_reason, usage
   attr_reader :stop_reason #: Symbol
   attr_reader :usage #: ::Riffer::Providers::TokenUsage?
@@ -9,7 +11,6 @@ class Riffer::Rig::Events::TurnEnd < Riffer::Rig::Events::Event
   # @rbs usage: ::Riffer::Providers::TokenUsage?
   # @rbs return: void
   def initialize(stop_reason, usage)
-    super()
     @stop_reason = stop_reason
     @usage = usage
     freeze

data/lib/riffer/rig/extension/failure.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Extension::Failure
+  # @dynamic extension, error
+  attr_reader :extension #: Riffer::Rig::Extension
+  attr_reader :error #: StandardError
+
+  # @rbs extension: Riffer::Rig::Extension
+  # @rbs error: StandardError
+  # @rbs return: void
+  def initialize(extension:, error:)
+    @extension = extension
+    @error = error
+    freeze
+  end
+end

data/lib/riffer/rig/extension.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Extension
+  class RequirementError < StandardError; end
+
   # @rbs @name: String
   # @rbs @requires: Gem::Requirement?
+  # @rbs @mismatch: RequirementError?
   # @rbs @block: ^(::Riffer::Rig::Registrar) -> void
 
-  # @dynamic name, requires
+  # @dynamic name, requires, mismatch
   attr_reader :name #: String
   attr_reader :requires #: Gem::Requirement?
+  attr_reader :mismatch #: RequirementError?
 
   # @rbs name: String
   # @rbs requires: String?
@@ -16,6 +20,7 @@ class Riffer::Rig::Extension
   def initialize(name, requires: nil, &block)
     @name = name
     @requires = requires && Gem::Requirement.new(requires)
+    @mismatch = check(@requires)
     @block = block
   end
 
@@ -24,4 +29,14 @@ class Riffer::Rig::Extension
   def run(registrar)
     @block.call(registrar)
   end
+
+  private
+
+  # @rbs requirement: Gem::Requirement?
+  # @rbs return: RequirementError?
+  def check(requirement)
+    return if requirement.nil? || requirement.satisfied_by?(Gem::Version.new(Riffer::Rig::VERSION))
+
+    RequirementError.new("extension #{@name} requires riffer-rig #{requirement}, found #{Riffer::Rig::VERSION}")
+  end
 end

data/lib/riffer/rig/hosts/mirror.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Hosts::Mirror < Riffer::Rig::Hosts::Base
-  # @rbs @host: Riffer::Rig::Hosts::Base
-  # @rbs @queue: Array[Riffer::Rig::Events::Event]
+class Riffer::Rig::Hosts::Mirror
+  # @rbs @host: Riffer::Rig::Hosts::_Host
+  # @rbs @queue: Array[Riffer::Rig::Events::_Event]
 
   # @dynamic capabilities
   attr_reader :capabilities #: Set[Symbol]
 
-  # @rbs host: Riffer::Rig::Hosts::Base
+  # @rbs host: Riffer::Rig::Hosts::_Host
   # @rbs return: void
   def initialize(host)
-    super()
     @host = host
     @capabilities = host.capabilities
     @queue = []
@@ -45,13 +44,13 @@ class Riffer::Rig::Hosts::Mirror < Riffer::Rig::Hosts::Base
     @host.progress(label) { block&.call }
   end
 
-  # @rbs event: Riffer::Rig::Events::Event
+  # @rbs event: Riffer::Rig::Events::_Event
   # @rbs return: void
   def queue(event)
     @queue << event
   end
 
-  # @rbs return: Array[Riffer::Rig::Events::Event]
+  # @rbs return: Array[Riffer::Rig::Events::_Event]
   def drain
     queued = @queue
     @queue = []

data/lib/riffer/rig/hosts/null.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Riffer::Rig::Hosts::Null < Riffer::Rig::Hosts::Base
+class Riffer::Rig::Hosts::Null
   # @rbs return: Set[Symbol]
   def capabilities
     Set.new.freeze

data/lib/riffer/rig/loader.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Loader
+  class ConfigurationError < StandardError; end
+
+  PROVIDER_LIST = Riffer::Rig::Settings::PROVIDERS.join(', ') #: String
+
+  ONBOARDING_QUESTION = 'Which model should riffer use? Enter provider/name, ' \
+                        "with a provider from: #{PROVIDER_LIST}".freeze #: String
+
+  NO_MODEL = 'No model is set: pass --model provider/name, set RIFFER_MODEL, or set "model" in ' \
+             "~/.riffer/settings.json, with a provider from: #{PROVIDER_LIST}".freeze #: String
+
+  private_constant :PROVIDER_LIST, :ONBOARDING_QUESTION, :NO_MODEL
+
+  # @rbs @cwd: String
+  # @rbs @host: Riffer::Rig::Hosts::_Host
+  # @rbs @env: Riffer::Rig::Env
+  # @rbs @home: String
+  # @rbs @riffer_config: Riffer::Config
+
+  # @rbs cwd: String
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
+  # @rbs home: String
+  # @rbs riffer_config: Riffer::Config
+  # @rbs model: String?
+  # @rbs extensions: bool
+  # @rbs skills: bool
+  # @rbs agents_md: bool
+  # @rbs tools: Array[String]?
+  # @rbs max_steps: Integer?
+  # @rbs return: Riffer::Rig::Runtime
+  def self.runtime(
+    cwd:,
+    host:,
+    env: Riffer::Rig::Env.load,
+    home: Dir.home,
+    riffer_config: Riffer.config,
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+  )
+    new(cwd:, host:, env:, home:, riffer_config:).runtime(model:, extensions:, skills:, agents_md:, tools:, max_steps:)
+  end
+
+  # @rbs cwd: String
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
+  # @rbs home: String
+  # @rbs riffer_config: Riffer::Config
+  # @rbs return: void
+  def initialize(cwd:, host:, env: Riffer::Rig::Env.load, home: Dir.home, riffer_config: Riffer.config)
+    raise ConfigurationError, env.message if env.is_a?(Riffer::Rig::Env::Invalid)
+
+    @cwd = cwd
+    @host = host
+    @env = env
+    @home = home
+    @riffer_config = riffer_config
+  end
+
+  # @rbs model: String?
+  # @rbs extensions: bool
+  # @rbs skills: bool
+  # @rbs agents_md: bool
+  # @rbs tools: Array[String]?
+  # @rbs max_steps: Integer?
+  # @rbs return: Riffer::Rig::Runtime
+  def runtime(
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+  )
+    settings = Riffer::Rig::Settings.merge(
+      Riffer::Rig::Settings.read(home_settings_path),
+      Riffer::Rig::Settings.read(File.join(@cwd, '.riffer', 'settings.json'))
+    )
+    document = Riffer::Rig::Settings::Document.new(settings)
+    selected = select_model(model || @env.model || document.model)
+    provider = Riffer::Rig::Settings.provider_for(selected).to_s
+    credentials = { provider.to_sym => credentials_for(provider) }
+    stripped = { skills: skills, agents_md: agents_md }.reject { |_name, kept| kept }.keys
+
+    Riffer::Rig::Runtime.new(
+      selected,
+      extensions: Riffer::Rig::Bundled::BY_NAME.except(*document.disabled.map(&:to_sym), *stripped).values,
+      tools: tools,
+      settings: settings,
+      host: @host,
+      cwd: @cwd,
+      max_steps: max_steps,
+      credentials: credentials,
+      pricing: document.models,
+      riffer_config: @riffer_config,
+      model_options: Riffer::Rig::Settings.model_options(selected, document.reasoning)
+    )
+  end
+
+  private
+
+  # @rbs configured: String?
+  # @rbs return: String
+  def select_model(configured)
+    model = configured || ask_for_model
+    rejection = Riffer::Rig::Settings.rejection(model)
+    raise ConfigurationError, rejection if rejection
+
+    Riffer::Rig::Settings.store_model(model, path: home_settings_path) unless configured
+    model
+  end
+
+  # @rbs return: String
+  def ask_for_model
+    answer = asking_host.ask(ONBOARDING_QUESTION).to_s.strip
+    raise ConfigurationError, NO_MODEL if answer.empty?
+
+    answer
+  end
+
+  # @rbs provider: String
+  # @rbs return: Hash[Symbol, String]
+  def credentials_for(provider)
+    resolution = Riffer::Rig::Credentials.resolve(
+      provider,
+      host: asking_host,
+      env: @env,
+      auth_path: File.join(@home, '.riffer', 'auth.json'),
+      settings_path: home_settings_path
+    )
+    raise ConfigurationError, missing_credentials(provider, resolution.missing) unless resolution.missing.empty?
+
+    Riffer::Rig::Credentials.apply(provider, resolution.values, config: @riffer_config)
+    resolution.values
+  end
+
+  # @rbs provider: String
+  # @rbs missing: Array[Symbol]
+  # @rbs return: String
+  def missing_credentials(provider, missing)
+    setup = Riffer::Rig::ProviderSetup.for(provider)
+    fields = setup.fields.select { |field| missing.include?(field.name) }
+    wanted = fields.map { |field| "#{field.name} (#{field.env.join(' or ')})" }.join(', ')
+    "#{provider} has no #{wanted}; set it in the environment or run riffer interactively to paste it" \
+      "#{" (create one at #{setup.url})" if setup.url}"
+  end
+
+  # @rbs return: Riffer::Rig::Hosts::_Host
+  def asking_host
+    @host.capabilities.include?(:ask) ? @host : Riffer::Rig::Hosts::Null.new
+  end
+
+  # @rbs return: String
+  def home_settings_path
+    File.join(@home, '.riffer', 'settings.json')
+  end
+end

data/lib/riffer/rig/mcp/declaration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Mcp::Declaration
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic url, headers
+  attr_reader :url #: String
+  attr_reader :headers #: Hash[String, String]
+
+  # @rbs url: String
+  # @rbs headers: Hash[String, String]
+  # @rbs return: void
+  def initialize(url:, headers:)
+    @url = url
+    @headers = headers
+    freeze
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { url: url, headers: headers }
+  end
+end

data/lib/riffer/rig/mcp/server.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Mcp::Server
+  # @dynamic declaration, registration
+  attr_reader :declaration #: Riffer::Rig::Mcp::Declaration
+  attr_reader :registration #: Riffer::Mcp::Registration
+
+  # @rbs declaration: Riffer::Rig::Mcp::Declaration
+  # @rbs registration: Riffer::Mcp::Registration
+  # @rbs return: void
+  def initialize(declaration:, registration:)
+    @declaration = declaration
+    @registration = registration
+    freeze
+  end
+end

data/lib/riffer/rig/mcp.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Mcp
+  extend self
+
+  # @rbs home: Hash[Symbol, untyped]
+  # @rbs project: Hash[Symbol, untyped]
+  # @rbs return: Hash[Symbol, untyped]
+  def merge(home, project)
+    home.merge(project, servers: home[:servers].to_h.merge(project[:servers].to_h))
+  end
+end