riffer-rig 0.5.0 → 0.7.0

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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)
+    @name = name
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :skill_activated
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, name: name }
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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?
+
+  # @rbs stop_reason: Symbol
+  # @rbs usage: ::Riffer::Providers::TokenUsage?
+  # @rbs return: void
+  def initialize(stop_reason, usage)
+    @stop_reason = stop_reason
+    @usage = usage
+    freeze
+  end
+
+  # @rbs return: Float?
+  def cost
+    usage&.cost
+  end
+
+  # @rbs return: Symbol
+  def type
+    :turn_end
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, stop_reason: stop_reason, usage: usage }
+  end
+end

data/lib/riffer/rig/events.rb

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

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,17 +1,17 @@
 # frozen_string_literal: true
 
-# An extension recorded by <tt>Riffer::Rig.extension</tt>: a name, an optional
-# Gem::Requirement on riffer-rig, and the block that runs against a Runtime's
-# registrar. The process registry holds these objects; Runtime.new runs their
-# blocks.
 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?
@@ -20,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
 
@@ -28,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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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::_Host
+  # @rbs return: void
+  def initialize(host)
+    @host = host
+    @capabilities = host.capabilities
+    @queue = []
+  end
+
+  # @rbs question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
+  # @rbs return: String?
+  def ask(question = nil, options: nil, secret: false)
+    @host.ask(question, options: options, secret: secret)
+  end
+
+  # @rbs question: String?
+  # @rbs return: bool
+  def confirm(question = nil)
+    @host.confirm(question)
+  end
+
+  # @rbs message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(message = nil, level: :info)
+    queue(Riffer::Rig::Events::Notify.new(message, level))
+    @host.notify(message, level: level)
+  end
+
+  # @rbs label: String?
+  # @rbs &block: ? () -> void
+  # @rbs return: void
+  def progress(label = nil, &block)
+    @host.progress(label) { block&.call }
+  end
+
+  # @rbs event: Riffer::Rig::Events::_Event
+  # @rbs return: void
+  def queue(event)
+    @queue << event
+  end
+
+  # @rbs return: Array[Riffer::Rig::Events::_Event]
+  def drain
+    queued = @queue
+    @queue = []
+    queued
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Hosts::Null
+  # @rbs return: Set[Symbol]
+  def capabilities
+    Set.new.freeze
+  end
+
+  # @rbs question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
+  # @rbs return: String?
+  def ask(question = nil, options: nil, secret: false)
+    nil
+  end
+
+  # @rbs question: String?
+  # @rbs return: bool
+  def confirm(question = nil)
+    false
+  end
+
+  # @rbs message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(message = nil, level: :info)
+    nil
+  end
+
+  # @rbs label: String?
+  # @rbs &block: ? () -> void
+  # @rbs return: void
+  def progress(label = nil, &block)
+    block&.call
+  end
+end

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

data/lib/riffer/rig/prompts/agents_md.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Prompts::AgentsMd
+  extend self
+
+  FRAMING = 'The user wrote the following instructions in AGENTS.md files, ordered from the most general to ' \
+            'the one closest to the working directory. Follow them; where they conflict with the guidance ' \
+            'above, they take precedence, and where they conflict with each other, the later file wins.' #: String
+
+  # @rbs cwd: String
+  # @rbs return: Array[String]
+  def paths(cwd)
+    global  = File.join(Dir.home, '.riffer', 'AGENTS.md')
+    project = Riffer::Rig::Directories.ancestors(File.expand_path(cwd)).reverse.map { |dir| File.join(dir, 'AGENTS.md') }
+    [global, *project].uniq.select { |path| File.file?(path) }
+  end
+
+  # @rbs cwd: String
+  # @rbs return: String?
+  def section(cwd)
+    blocks = paths(cwd).map { |path| block(path) }
+    [FRAMING, *blocks].join("\n\n") unless blocks.empty?
+  end
+
+  private
+
+  # @rbs path: String
+  # @rbs return: String
+  def block(path)
+    "<project_instructions path=\"#{path}\">\n#{File.read(path)}\n</project_instructions>"
+  end
+end

data/lib/riffer/rig/prompts.rb

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

data/lib/riffer/rig/provider_setup/field.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::ProviderSetup::Field
+  # @dynamic name, env, secret, required, fallback
+  attr_reader :name #: Symbol
+  attr_reader :env #: Array[String]
+  attr_reader :secret, :required #: bool
+  attr_reader :fallback #: (^() -> String?)?
+
+  # @rbs name: Symbol
+  # @rbs env: Array[String]
+  # @rbs secret: bool
+  # @rbs required: bool
+  # @rbs fallback: (^() -> String?)?
+  # @rbs return: void
+  def initialize(name:, env:, secret:, required:, fallback: nil)
+    @name = name
+    @env = env.freeze
+    @secret = secret
+    @required = required
+    @fallback = fallback
+    freeze
+  end
+end

data/lib/riffer/rig/provider_setup.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::ProviderSetup
+  # @dynamic url, chain, fields
+  attr_reader :url #: String?
+  attr_reader :chain #: bool
+  attr_reader :fields #: Array[Riffer::Rig::ProviderSetup::Field]
+
+  # @rbs fields: Array[Riffer::Rig::ProviderSetup::Field]
+  # @rbs url: String?
+  # @rbs chain: bool
+  # @rbs return: void
+  def initialize(fields:, url: nil, chain: false)
+    @url = url
+    @chain = chain
+    @fields = fields.freeze
+    freeze
+  end
+
+  AWS_SHARED_CONFIG_REGION = lambda do
+    require 'aws-sdk-core'
+    Object.const_get(:Aws).shared_config.region
+  rescue LoadError
+    nil
+  end #: ^() -> String?
+
+  # Upstream candidate: each riffer provider could declare its own credential
+  # fields, and this table would go.
+  TABLE = {
+    anthropic: new(
+      url: 'https://console.anthropic.com/settings/keys',
+      fields: [Field.new(name: :api_key, env: ['ANTHROPIC_API_KEY'], secret: true, required: true)]
+    ),
+    openai: new(
+      url: 'https://platform.openai.com/api-keys',
+      fields: [
+        Field.new(name: :api_key, env: ['OPENAI_API_KEY'], secret: true, required: true),
+        Field.new(name: :base_url, env: ['OPENAI_BASE_URL'], secret: false, required: false)
+      ]
+    ),
+    gemini: new(
+      url: 'https://aistudio.google.com/app/apikey',
+      fields: [Field.new(name: :api_key, env: ['GEMINI_API_KEY'], secret: true, required: true)]
+    ),
+    openrouter: new(
+      url: 'https://openrouter.ai/keys',
+      fields: [Field.new(name: :api_key, env: ['OPENROUTER_API_KEY'], secret: true, required: true)]
+    ),
+    azure_openai: new(
+      url: 'https://portal.azure.com',
+      fields: [
+        Field.new(name: :endpoint, env: ['AZURE_OPENAI_ENDPOINT'], secret: false, required: true),
+        Field.new(name: :api_key, env: ['AZURE_OPENAI_API_KEY'], secret: true, required: true)
+      ]
+    ),
+    amazon_bedrock: new(
+      url: 'https://console.aws.amazon.com/bedrock',
+      chain: true,
+      fields: [
+        Field.new(
+          name: :region,
+          env: %w[AWS_REGION AWS_DEFAULT_REGION],
+          secret: false,
+          required: true,
+          fallback: AWS_SHARED_CONFIG_REGION
+        ),
+        Field.new(name: :api_token, env: ['AWS_BEARER_TOKEN_BEDROCK'], secret: true, required: false)
+      ]
+    )
+  }.freeze #: Hash[Symbol, Riffer::Rig::ProviderSetup]
+
+  # @rbs identifier: String | Symbol
+  # @rbs return: Riffer::Rig::ProviderSetup?
+  def self.[](identifier)
+    TABLE[identifier.to_sym]
+  end
+
+  # @rbs identifier: String | Symbol
+  # @rbs return: Riffer::Rig::ProviderSetup
+  def self.for(identifier)
+    self[identifier] ||
+      new(fields: [Field.new(name: :api_key, env: ["#{identifier.to_s.upcase}_API_KEY"], secret: true, required: true)])
+  end
+end