riffer-rig 0.5.0 → 0.7.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Commands::Model
+  extend self
+
+  HINT = 'Use /model provider/name, with a provider from: ' \
+         "#{Riffer::Rig::Settings::PROVIDERS.join(', ')}".freeze #: String
+
+  SAVE_UNAVAILABLE = '/model --save is not available in this host'
+
+  # @rbs return: Riffer::Rig::Command
+  def command
+    Riffer::Rig::Command.new(
+      'model',
+      description: 'Switch the model for this session: /model provider/name',
+      extension: 'core'
+    ) { |ctx| run(ctx) }
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs return: void
+  def run(ctx)
+    model = ctx.args.strip
+    return ctx.host.notify(SAVE_UNAVAILABLE, level: :error) if model.split.include?('--save')
+    return ctx.say("Model: #{ctx.runtime.model}") if model.empty?
+
+    provider = Riffer::Rig::Settings.provider_for(model)
+    return ctx.say(HINT) unless provider && Riffer::Providers::Repository.find(provider)
+
+    missing = missing_credentials(provider, ctx.runtime.credentials)
+    return ctx.host.notify(refusal(model, provider, missing), level: :error) unless missing.empty?
+
+    ctx.runtime.model = model
+    ctx.say("Model: #{model}")
+  end
+
+  private
+
+  # @rbs model: String
+  # @rbs provider: String
+  # @rbs missing: Array[Symbol]
+  # @rbs return: String
+  def refusal(model, provider, missing)
+    "Not switching to #{model}: #{provider} has no #{missing.join(', ')} in credentials"
+  end
+
+  # @rbs provider: String
+  # @rbs credentials: Hash[Symbol, Hash[Symbol, String]]
+  # @rbs return: Array[Symbol]
+  def missing_credentials(provider, credentials)
+    required = Riffer::Rig::ProviderSetup[provider]&.fields&.select(&:required) || []
+    required.map(&:name).reject { |name| credentials.dig(provider.to_sym, name) }
+  end
+end

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/resolution.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Credentials::Resolution
+  # @dynamic values, missing
+  attr_reader :values #: Hash[Symbol, String]
+  attr_reader :missing #: Array[Symbol]
+
+  # @rbs values: Hash[Symbol, String]
+  # @rbs missing: Array[Symbol]
+  # @rbs return: void
+  def initialize(values:, missing:)
+    @values = values.freeze
+    @missing = missing.freeze
+    freeze
+  end
+end

data/lib/riffer/rig/credentials.rb

@@ -2,88 +2,179 @@
 
 require 'json'
 require 'fileutils'
+require 'open3'
 
-# Reads and writes API keys for each supported provider in
-# <tt>~/.riffer/auth.json</tt>.
-#
-# Keys are stored under the provider name, e.g.:
-#
-#   {
-#     "anthropic": "sk-ant-...",
-#     "openai": "sk-...",
-#     "gemini": "...",
-#     "openrouter": "sk-or-..."
-#   }
-#
-# The environment variable checked per provider:
-#
-#   anthropic  → ANTHROPIC_API_KEY
-#   openai     → OPENAI_API_KEY
-#   gemini     → GEMINI_API_KEY
-#   openrouter → OPENROUTER_API_KEY
-#
 module Riffer::Rig::Credentials
   extend self
 
   PATH = File.expand_path('~/.riffer/auth.json') #: String
 
-  PROVIDER_ENV_VARS = {
-    'anthropic' => 'ANTHROPIC_API_KEY',
-    'openai' => 'OPENAI_API_KEY',
-    'gemini' => 'GEMINI_API_KEY',
-    'openrouter' => 'OPENROUTER_API_KEY'
-  }.freeze #: Hash[String, String]
-
-  # Returns the API key for +provider+, checking the environment variable first,
-  # then the stored file. Returns +nil+ if no key is available.
-  #
-  # @rbs provider: String?
-  # @rbs path: String
-  # @rbs return: String?
-  def api_key_for(provider, path: PATH)
-    env_var = provider && PROVIDER_ENV_VARS[provider]
-    key = env_var && ENV.fetch(env_var, nil).then { |v| v unless v.nil? || v.strip.empty? }
-    key || key_from_file(provider, path)
+  ENTRY_TYPE = 'api_key'
+
+  # @rbs identifier: String | Symbol
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs setup: Riffer::Rig::ProviderSetup
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
+  # @rbs return: Resolution
+  def resolve(
+    identifier,
+    host:,
+    setup: Riffer::Rig::ProviderSetup.for(identifier),
+    env: Riffer::Rig::Env.new,
+    auth_path: PATH,
+    settings_path: Riffer::Rig::Settings::PATH
+  )
+    secrets = stored_secrets(identifier, auth_path)
+    plain = Riffer::Rig::Settings.provider_fields(identifier.to_s, path: settings_path)
+    found = setup.fields.to_h do |field|
+      [field.name, env.value_for(field) || stored_value(field, secrets, plain, env) || field.fallback&.call]
+    end.compact
+    required = setup.fields.select(&:required)
+    answers = ask_for(required.reject { |field| found.key?(field.name) }, identifier, host)
+    store(identifier, answers, setup:, auth_path:, settings_path:)
+
+    values = found.merge(answers)
+    Resolution.new(values:, missing: required.map(&:name) - values.keys)
   end
 
-  # Saves an API key for +provider+ to the auth file with 0600 permissions.
-  #
-  # @rbs provider: String
-  # @rbs key: String
-  # @rbs path: String
-  # @rbs return: String
-  def save_api_key(provider, key, path: PATH)
-    FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
-    data = read(path).merge(provider => key)
-    File.open(path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |file|
-      file.write(JSON.pretty_generate(data))
+  # @rbs identifier: String | Symbol
+  # @rbs values: Hash[Symbol, String]
+  # @rbs config: Riffer::Config
+  # @rbs return: void
+  def apply(identifier, values, config: Riffer.config)
+    return unless Riffer::Rig::ProviderSetup[identifier]
+
+    provider_config = config.public_send(identifier)
+    values.each { |name, value| provider_config.public_send(:"#{name}=", value) }
+  end
+
+  # @rbs identifier: String | Symbol
+  # @rbs values: Hash[Symbol, String]
+  # @rbs setup: Riffer::Rig::ProviderSetup
+  # @rbs auth_path: String
+  # @rbs settings_path: String
+  # @rbs return: void
+  def store(
+    identifier,
+    values,
+    setup: Riffer::Rig::ProviderSetup.for(identifier),
+    auth_path: PATH,
+    settings_path: Riffer::Rig::Settings::PATH
+  )
+    secret_names = setup.fields.select(&:secret).map { |field| field.name.to_s }
+    fields = values.transform_keys(&:to_s)
+    secrets = fields.slice(*secret_names)
+    plain = fields.except(*secret_names)
+
+    unless secrets.empty?
+      entries = read_auth(auth_path).merge(identifier.to_s => secrets) do |_identifier, stored, given|
+        stored.merge(given)
+      end
+      write_auth(auth_path, entries)
     end
-    key
+    Riffer::Rig::Settings.store_provider(identifier.to_s, plain, path: settings_path) unless plain.empty?
+  end
+
+  # @rbs identifier: String | Symbol
+  # @rbs auth_path: String
+  # @rbs settings_path: String
+  # @rbs return: void
+  def remove(identifier, auth_path: PATH, settings_path: Riffer::Rig::Settings::PATH)
+    entries = read_auth(auth_path)
+    write_auth(auth_path, entries.except(identifier.to_s)) if entries.key?(identifier.to_s)
+    Riffer::Rig::Settings.remove_provider(identifier.to_s, path: settings_path)
+  end
+
+  # @rbs identifier: String | Symbol
+  # @rbs setup: Riffer::Rig::ProviderSetup
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs return: :env | :stored | :chain | :missing
+  def status(identifier, setup: Riffer::Rig::ProviderSetup.for(identifier), env: Riffer::Rig::Env.new, auth_path: PATH)
+    secret_fields = setup.fields.select(&:secret)
+    return :env if secret_fields.any? { |field| env.value_for(field) }
+
+    stored = stored_secrets(identifier, auth_path)
+    return :stored if secret_fields.any? { |field| stored.key?(field.name.to_s) }
+
+    setup.chain ? :chain : :missing
   end
 
   private
 
-  # @rbs provider: String?
-  # @rbs path: String
+  # @rbs fields: Array[Riffer::Rig::ProviderSetup::Field]
+  # @rbs identifier: String | Symbol
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs return: Hash[Symbol, String]
+  def ask_for(fields, identifier, host)
+    fields.to_h do |field|
+      [field.name, presence(host.ask("#{identifier} #{field.name}", secret: field.secret))]
+    end.compact
+  end
+
+  # @rbs field: Riffer::Rig::ProviderSetup::Field
+  # @rbs secrets: Hash[String, String]
+  # @rbs plain: Hash[String, String]
+  # @rbs env: Riffer::Rig::Env
+  # @rbs return: String?
+  def stored_value(field, secrets, plain, env)
+    field.secret ? expand(secrets[field.name.to_s], env) : plain[field.name.to_s]
+  end
+
+  # @rbs value: String?
+  # @rbs env: Riffer::Rig::Env
+  # @rbs return: String?
+  def expand(value, env)
+    return nil if value.nil?
+    return env[value.delete_prefix('$')] if value.start_with?('$')
+    return presence(run(value.delete_prefix('!'))) if value.start_with?('!')
+
+    value
+  end
+
+  # @rbs command: String
   # @rbs return: String?
-  def key_from_file(provider, path)
-    key = read(path)[provider]
-    return nil if key.nil? || key.strip.empty?
+  def run(command)
+    stdout, status = Open3.capture2(command)
+    stdout if status.success?
+  end
 
-    key
+  # @rbs value: String?
+  # @rbs return: String?
+  def presence(value)
+    stripped = value.to_s.strip
+    stripped unless stripped.empty?
   end
 
-  # The parsed auth file, or an empty hash when the file is absent or
-  # malformed. Non-string values can't be keys, so they're dropped here rather
-  # than re-checked by every reader.
-  #
+  # @rbs identifier: String | Symbol
   # @rbs path: String
   # @rbs return: Hash[String, String]
-  def read(path)
+  def stored_secrets(identifier, path)
+    read_auth(path)[identifier.to_s] || {}
+  end
+
+  # @rbs path: String
+  # @rbs return: Hash[String, Hash[String, String]]
+  def read_auth(path)
     return {} unless File.file?(path)
 
-    JSON.parse(File.read(path)).select { |_provider, key| key.is_a?(String) }
+    JSON.parse(File.read(path))
+        .select { |_identifier, entry| entry.is_a?(Hash) && entry['type'] == ENTRY_TYPE }
+        .transform_values { |entry| entry.except('type').select { |_name, value| value.is_a?(String) } }
   rescue JSON::ParserError
     {}
   end
+
+  # @rbs path: String
+  # @rbs entries: Hash[String, Hash[String, String]]
+  # @rbs return: void
+  def write_auth(path, entries)
+    FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
+    data = entries.transform_values { |fields| { 'type' => ENTRY_TYPE }.merge(fields) }
+    File.open(path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |file|
+      file.write(JSON.pretty_generate(data))
+    end
+  end
 end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Env
+  # @rbs @source: Hash[String, String]
+
+  # @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
+
+  # @rbs name: String
+  # @rbs return: String?
+  def [](name)
+    stripped = @source[name].to_s.strip
+    stripped unless stripped.empty?
+  end
+
+  # @rbs field: Riffer::Rig::ProviderSetup::Field
+  # @rbs return: String?
+  def value_for(field)
+    field.env.filter_map { |name| self[name] }.first
+  end
+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

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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::Notify
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic message, level
+  attr_reader :message #: String?
+  attr_reader :level #: Symbol
+
+  # @rbs message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def initialize(message, level)
+    @message = message
+    @level = level
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :notify
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, message: message, level: level }
+  end
+end

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

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

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

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