riffer-rig 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f73a840a836511a6fae8b5c7d6e74ec91fbcb538512db64ad08e9fe75968941
+  data.tar.gz: c8d503c5bc6a363be2b4d940441436c865a760b88919ada174672e2422a20904
+SHA512:
+  metadata.gz: 43cdadee5554656753dd5d2e46bae4456df480844d30e7119d4e45b5647395236cb1acc5209aa9fbfec5da501888f04221d21ddbd49925183edef56daca4b3f7
+  data.tar.gz: d05268fab46137782a580f18a134105c48aae93b50d1249936c6b76fe7ba056bf3f08bd23ba6d15a4a75fb80b02dfefd5aad98fdac54fbb51f433aa4e41a844d

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 0.1.0 (2026-09-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* the gem, executable, namespace, config directory and environment variable are all renamed; nothing reads the old names.
+
+### Features
+
+* add prompt caching, token tally, and settings ([#7](https://github.com/bottrall/riffer-rig/issues/7)) ([bb02a95](https://github.com/bottrall/riffer-rig/commit/bb02a954c2fffa13ad8e564513c82681ab02d1e4))
+* add skills support to CLI, REPL, and banner ([#5](https://github.com/bottrall/riffer-rig/issues/5)) ([5ac1dd1](https://github.com/bottrall/riffer-rig/commit/5ac1dd186c3f05adb342e1dead6102f2544d3b2b))
+* configurable reasoning levels ([#34](https://github.com/bottrall/riffer-rig/issues/34)) ([a9604f3](https://github.com/bottrall/riffer-rig/commit/a9604f3994fc2cef5888c653fd1f07b82ac662f8))
+* multi-provider support (Anthropic, OpenAI, Gemini, OpenRouter) ([#32](https://github.com/bottrall/riffer-rig/issues/32)) ([30b5ccf](https://github.com/bottrall/riffer-rig/commit/30b5ccf92ea43182953f1b5da089fe9e4550c9c9))
+* rename to riffer-rig ([#95](https://github.com/bottrall/riffer-rig/issues/95)) ([d036d57](https://github.com/bottrall/riffer-rig/commit/d036d57f6fd48c3171383708caa0f22a34f7343d))
+
+
+### Bug Fixes
+
+* point riffer dependency to janeapp/riffer ([#2](https://github.com/bottrall/riffer-rig/issues/2)) ([0060283](https://github.com/bottrall/riffer-rig/commit/00602835baf9759d4a012b4506605f2b6ed7c250))
+* rename Riffer::Boolean to Riffer::Params::Boolean ([#3](https://github.com/bottrall/riffer-rig/issues/3)) ([8996d01](https://github.com/bottrall/riffer-rig/commit/8996d0114a69b4db212cc9b0cbd2ec796f35a779))
+* require /skill: prefix to activate skills ([#37](https://github.com/bottrall/riffer-rig/issues/37)) ([ac6313d](https://github.com/bottrall/riffer-rig/commit/ac6313d7622e3483271cacef8b7bfe60ed33503a))

data/README.md

@@ -0,0 +1,79 @@
+# riffer-rig
+
+A dead-simple terminal coding agent built on [riffer](https://github.com/janeapp/riffer).
+
+`riffer-rig` is an interactive terminal coding agent with read, write, edit, and bash tools — point it at your project and chat with it from the command line.
+
+## Requirements
+
+- Ruby >= 4.0
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install riffer-rig
+```
+
+This provides a `riffer` executable.
+
+## Usage
+
+Run the agent from any project directory:
+
+```bash
+riffer
+```
+
+### Authentication
+
+`riffer-rig` talks to Anthropic. Provide your API key in either of two ways:
+
+- Set the `ANTHROPIC_API_KEY` environment variable, or
+- Run `riffer` and paste your key when prompted on first launch. It is saved to `~/.riffer/auth.json` (file permissions `600`) for subsequent runs.
+
+Create a key at https://console.anthropic.com/settings/keys.
+
+### Configuration
+
+- `RIFFER_MODEL` — override the default model.
+- `AGENTS.md` — if present, an `AGENTS.md` in the current working directory and/or a global `~/.riffer/AGENTS.md` is loaded as additional context.
+
+## Development
+
+Every project chore is a script in `bin/`. The Rakefile behind them is an implementation detail; you never need to call rake directly.
+
+| Script | What it does |
+| --- | --- |
+| `bin/setup` | Install dependencies on a fresh checkout |
+| `bin/test` | Run the test suite. Pass files and/or Minitest flags: `bin/test test/foo_test.rb -n /pattern/` |
+| `bin/lint` | Run RuboCop. Arguments are forwarded, e.g. `bin/lint -a` |
+| `bin/typecheck` | Check `sig/generated` is current, then type-check with Steep |
+| `bin/rbs` | Regenerate `sig/generated` from the inline annotations in `lib/` |
+| `bin/rbs-watch` | Regenerate `sig/generated` whenever `lib/` changes |
+| `bin/ci` | Run everything CI runs, serially. Use before pushing |
+
+## Releasing
+
+PR titles are [conventional commits](https://www.conventionalcommits.org/) and are linted in CI: `feat:` bumps the minor version, `fix:` bumps the patch, and `feat!:` marks a breaking change (also a minor bump while we are on 0.x). `chore:`, `docs:`, `ci:`, `refactor:` and `test:` never release. Squash-merging makes the title the commit on `main`.
+
+[release-please](https://github.com/googleapis/release-please) keeps a release PR open that bumps `lib/riffer/rig/version.rb` and writes `CHANGELOG.md`. Merging that PR tags `vX.Y.Z`, creates the GitHub Release and publishes the gem to RubyGems.org through Trusted Publishing; nothing is pushed by hand.
+
+riffer is pinned to one minor (`~> 0.45.0`) because its 0.x minors may break. When Dependabot opens the riffer bump, retitle it `feat(deps):` or `fix(deps):` before merging so it releases and appears in the changelog.
+
+## Contributing
+
+1. Fork the repository and create your branch: `git checkout -b feature/foo`
+2. Run the tests and linters locally.
+3. Submit a pull request with a clear description of the change.
+
+Please follow the [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+Licensed under the MIT License. See [`LICENSE.txt`](LICENSE.txt) for details.
+
+## Maintainer
+
+- Jake Bottrall - https://github.com/bottrall

data/exe/riffer

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup" if File.exist?(File.expand_path("../Gemfile", __dir__))
+
+require_relative "../lib/riffer/rig"
+
+exit(Riffer::Rig::CLI.start)

data/lib/riffer/rig/cli.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Riffer::Rig::CLI
+  extend self
+
+  PROVIDER_URLS = {
+    'anthropic' => 'https://console.anthropic.com/settings/keys',
+    'openai' => 'https://platform.openai.com/api-keys',
+    'gemini' => 'https://aistudio.google.com/app/apikey',
+    'openrouter' => 'https://openrouter.ai/keys'
+  }.freeze
+
+  def start(output: $stdout, input: $stdin)
+    theme = Riffer::Rig::UI::Theme.for(output)
+
+    model    = Riffer::Rig::Settings.model
+    provider = Riffer::Rig::Settings.provider_for(model)
+
+    api_key = (provider && Riffer::Rig::Credentials.api_key_for(provider)) ||
+              onboard(provider, theme, output:, input:)
+    return 1 if api_key.nil?
+
+    configure_provider(provider, api_key)
+
+    agent    = Riffer::Rig::CodingAgent.new
+    animator = Riffer::Rig::UI::Animator.new(io: output, theme:)
+
+    reveal_banner(theme, animator, model)
+
+    tally    = Riffer::Rig::TokenTally.new(pricing: Riffer::Rig::Settings.pricing_for(model))
+    renderer = Riffer::Rig::UI::Renderer.new(io: output, theme:, tally:)
+    Riffer::Rig::REPL.new(agent:, renderer:, animator:, theme:, input:, output:).run
+    0
+  end
+
+  private
+
+  def configure_provider(provider, api_key)
+    case provider
+    when 'anthropic'  then Riffer.configure { |c| c.anthropic.api_key  = api_key }
+    when 'openai'     then Riffer.configure { |c| c.openai.api_key     = api_key }
+    when 'gemini'     then Riffer.configure { |c| c.gemini.api_key     = api_key }
+    when 'openrouter' then Riffer.configure { |c| c.openrouter.api_key = api_key }
+    end
+  end
+
+  def onboard(provider, theme, output:, input:)
+    url  = (provider && PROVIDER_URLS[provider]) || 'your provider'
+    name = provider ? provider.capitalize : 'provider'
+
+    output.puts(theme.cyan('♪ welcome to riffer-rig ♪'))
+    output.puts(theme.grey("No #{name} API key found. Create one at #{url}"))
+    output.print("#{theme.pink('›')} Paste your #{name} API key #{theme.grey('(hidden)')}: ")
+
+    key = read_secret(input).to_s.strip
+    output.puts
+
+    if key.empty?
+      output.puts(theme.grey("No key entered. Set #{env_var_for(provider)} or re-run riffer to try again."))
+      return nil
+    end
+
+    Riffer::Rig::Credentials.save_api_key(provider, key) if provider
+    output.puts(theme.grey("Saved to #{Riffer::Rig::Credentials::PATH} (permissions 600)."))
+    key
+  end
+
+  def env_var_for(provider)
+    (provider && Riffer::Rig::Credentials::PROVIDER_ENV_VARS[provider]) || 'the appropriate API key env var'
+  end
+
+  def read_secret(input)
+    return input.noecho(&:gets) if input.respond_to?(:noecho) && input.tty?
+
+    input.gets
+  end
+
+  def reveal_banner(theme, animator, model)
+    loaded  = [Riffer::Rig::CodingAgent::GLOBAL_AGENTS_FILE, File.join(Dir.pwd, 'AGENTS.md')].select { |path| File.file?(path) }
+    context = loaded.empty? ? 'none' : loaded.join(', ')
+
+    glints = Riffer::Rig::UI::Riffy::GLINT_COLS + [nil]
+    frames = glints.map do |glint_col|
+      Riffer::Rig::UI::Banner.lines(theme, model: model, cwd: Dir.pwd, context: context, skills: count_skills, version: Riffer::Rig::VERSION, glint_col: glint_col)
+    end
+    animator.reveal(frames)
+  end
+
+  def count_skills
+    dirs    = [Riffer::Rig::CodingAgent::GLOBAL_SKILLS_DIR, Riffer::Rig::CodingAgent::PROJECT_SKILLS_DIR.call]
+    backend = Riffer::Skills::FilesystemBackend.new(*dirs)
+    count   = backend.list_skills.length
+    count.zero? ? 'none' : count.to_s
+  rescue StandardError
+    'none'
+  end
+end

data/lib/riffer/rig/coding_agent.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'date'
+
+class Riffer::Rig::CodingAgent < Riffer::Agent
+  GLOBAL_AGENTS_FILE = File.expand_path('~/.riffer/AGENTS.md')
+  GLOBAL_SKILLS_DIR  = File.expand_path('~/.riffer/skills')
+  PROJECT_SKILLS_DIR = -> { File.join(Dir.pwd, '.skills') }
+
+  model Riffer::Rig::Settings.model
+  model_options Riffer::Rig::Settings.model_options
+
+  uses_tools [
+    Riffer::Rig::Tools::Read,
+    Riffer::Rig::Tools::Write,
+    Riffer::Rig::Tools::Edit,
+    Riffer::Rig::Tools::Bash
+  ]
+
+  skills do
+    backend(->(_ctx) { Riffer::Skills::FilesystemBackend.new(GLOBAL_SKILLS_DIR, PROJECT_SKILLS_DIR.call) })
+  end
+
+  max_steps nil
+
+  instructions(lambda do
+    context_files = [GLOBAL_AGENTS_FILE, File.join(Dir.pwd, 'AGENTS.md')]
+      .select { |path| File.file?(path) }
+      .map { |path| "<project_instructions path=\"#{path}\">\n#{File.read(path)}\n</project_instructions>" }
+
+    project_context =
+      if context_files.empty?
+        ''
+      else
+        "\n\n<project_context>\n#{context_files.join("\n\n")}\n</project_context>"
+      end
+
+    <<~PROMPT.chomp + project_context + "\n\nCurrent date: #{Date.today}\nCurrent working directory: #{Dir.pwd}"
+      You are an expert coding assistant running inside riffer-rig, a terminal coding agent. You help the user by reading files, running shell commands, editing code, and writing new files.
+
+      Available tools:
+      - read: read a file's contents
+      - write: create or overwrite a file
+      - edit: replace an exact string in a file
+      - bash: run a shell command (use it for ls, rg/grep, find, tests, git, etc.)
+
+      Guidelines:
+      - Be concise and direct in your responses.
+      - Show file paths clearly when working with files.
+      - Use bash for file exploration (ls, rg, find) rather than guessing.
+      - Prefer editing existing files over creating new ones.
+    PROMPT
+  end)
+end

data/lib/riffer/rig/credentials.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+# 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')
+
+  PROVIDER_ENV_VARS = {
+    'anthropic' => 'ANTHROPIC_API_KEY',
+    'openai' => 'OPENAI_API_KEY',
+    'gemini' => 'GEMINI_API_KEY',
+    'openrouter' => 'OPENROUTER_API_KEY'
+  }.freeze
+
+  # Returns the API key for +provider+, checking the environment variable first,
+  # then the stored file. Returns +nil+ if no key is available.
+  def api_key_for(provider, path: PATH)
+    env_var = 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)
+  end
+
+  # Saves an API key for +provider+ to the auth file with 0600 permissions.
+  def save_api_key(provider, key, path: PATH)
+    FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
+    data = read(path).tap { |h| h[provider] = key }
+    File.open(path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |file|
+      file.write(JSON.pretty_generate(data))
+    end
+    key
+  end
+
+  private
+
+  def key_from_file(provider, path)
+    key = read(path)[provider]
+    key unless key.nil? || key.strip.empty?
+  end
+
+  def read(path)
+    return {} unless File.file?(path)
+
+    JSON.parse(File.read(path))
+  rescue JSON::ParserError
+    {}
+  end
+end

data/lib/riffer/rig/repl.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::REPL
+  EXIT_COMMANDS = ['/exit', '/quit'].freeze
+  SKILL_COMMAND = %r{\A/skill:([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+(.*))?\z}m
+
+  def initialize(agent:, renderer:, input: $stdin, output: $stdout, theme: Riffer::Rig::UI::Theme.for(output), animator: Riffer::Rig::UI::Animator.new(io: output, theme:))
+    @agent = agent
+    @renderer = renderer
+    @animator = animator
+    @theme = theme
+    @input = input
+    @output = output
+    @agent.session.on_message { |message| @renderer.render_tool_result(message) }
+  end
+
+  def run
+    loop do
+      @output.print("\n#{@theme.pink('›')} ")
+      line = @input.gets
+      break if line.nil?
+
+      prompt = line.strip
+      next if prompt.empty?
+      break if EXIT_COMMANDS.include?(prompt)
+
+      match = SKILL_COMMAND.match(prompt)
+
+      if match
+        run_skill_command(match[1], match[2].to_s.strip)
+      else
+        run_turn(prompt)
+      end
+    end
+
+    @output.puts("\n#{@theme.grey('see you on the next riff.')}")
+  end
+
+  private
+
+  def run_turn(prompt)
+    @animator.start_thinking
+    @agent.stream(prompt).each do |event|
+      @animator.stop_thinking
+      @renderer.render(event)
+    end
+    @output.puts
+  rescue StandardError => e
+    @output.puts("\nError: #{e.message}")
+  ensure
+    @animator.stop_thinking
+  end
+
+  def run_skill_command(name, args)
+    block = activate_skill(name)
+    return if block.nil?
+
+    run_turn([block, args].reject(&:empty?).join("\n\n"))
+  end
+
+  def activate_skill(name)
+    skills = @agent.context.skills
+
+    unless skills
+      @output.puts(@theme.grey('No skills configured.'))
+      return
+    end
+
+    # TODO: read the body without mutating activation state once riffer exposes
+    # a non-mutating Context#read. `activate` marks the skill model-activated as
+    # a side effect, which drops it from the model's catalog after manual use.
+    body = skills.activate(name)
+    @output.puts(@theme.magenta("✦ skill: #{name}"))
+    skill_block(name, body)
+  rescue Riffer::ArgumentError
+    @output.puts(@theme.red("Unknown skill: #{name}"))
+    nil
+  rescue StandardError => e
+    @output.puts(@theme.red("Error activating skill: #{e.message}"))
+    nil
+  end
+
+  def skill_block(name, body)
+    "<skill name=\"#{name}\">\n#{body}\n</skill>"
+  end
+end

data/lib/riffer/rig/settings.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+# 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
+  extend self
+
+  PATH = File.expand_path('~/.riffer/settings.json')
+  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
+
+  # Returns the configured model string, or +DEFAULT_MODEL+ if not set.
+  def model(path: PATH)
+    read(path).fetch('model', DEFAULT_MODEL)
+  end
+
+  # Returns model options for the configured model and reasoning level, ready
+  # to pass directly to the Riffer agent's +model_options+.
+  def model_options(path: PATH)
+    provider = provider_for(model(path:))
+    base_options(provider).merge(reasoning_options(reasoning_for(path:, provider:), provider))
+  end
+
+  # 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.
+  def provider_for(model_string)
+    model_string.split('/', 2).first if model_string.include?('/')
+  end
+
+  # Returns the pricing hash for +model+, or +nil+ if not configured.
+  #
+  # The returned hash has symbol keys +:input+, +:output+, +:cache_write+,
+  # +:cache_read+ (all Float, USD per million tokens).
+  def pricing_for(model, path: PATH)
+    entry = read(path).dig('models', model)
+    return nil unless entry
+
+    {
+      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
+
+  private
+
+  def base_options(provider)
+    return { cache_control: { type: :ephemeral } } if provider == 'anthropic'
+
+    {}
+  end
+
+  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
+
+  # Maps a reasoning level to the provider-specific model option hash expected
+  # by Riffer. Returns an empty hash when +level+ is +nil+.
+  def reasoning_options(level, provider)
+    return {} unless level
+
+    case provider
+    when 'anthropic'
+      { output_config: { effort: level } }
+    when 'openai', 'openrouter'
+      { reasoning: level }
+    else
+      {}
+    end
+  end
+
+  def read(path)
+    return {} unless File.file?(path)
+
+    JSON.parse(File.read(path))
+  rescue JSON::ParserError
+    {}
+  end
+end

data/lib/riffer/rig/token_tally.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Accumulates token usage across multiple turns in a session and computes an
+# estimated cost based on a pricing hash 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
+  attr_reader :input_tokens, :output_tokens, :cache_write_tokens, :cache_read_tokens
+
+  def initialize(pricing: nil)
+    @pricing = pricing
+    @input_tokens = 0
+    @output_tokens = 0
+    @cache_write_tokens = 0
+    @cache_read_tokens = 0
+  end
+
+  # Accumulates token counts from a +Riffer::Providers::TokenUsage+ object.
+  #
+  def add(usage)
+    @input_tokens += usage.input_tokens
+    @output_tokens += usage.output_tokens
+    @cache_write_tokens += usage.cache_write_tokens || 0
+    @cache_read_tokens += usage.cache_read_tokens || 0
+  end
+
+  # Returns the total token count across all categories.
+  #
+  def total_tokens
+    @input_tokens + @output_tokens + @cache_write_tokens + @cache_read_tokens
+  end
+
+  # Returns +true+ if any tokens have been counted.
+  #
+  def any?
+    total_tokens.positive?
+  end
+
+  # Returns the estimated cost in USD, or +nil+ if no pricing was provided.
+  #
+  def estimated_cost
+    return nil unless @pricing
+
+    (
+      (@input_tokens       * @pricing[:input]) +
+      (@output_tokens      * @pricing[:output])       +
+      (@cache_write_tokens * @pricing[:cache_write])  +
+      (@cache_read_tokens  * @pricing[:cache_read])
+    ) / 1_000_000.0
+  end
+end

data/lib/riffer/rig/tools/bash.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+class Riffer::Rig::Tools::Bash < Riffer::Tool
+  identifier 'bash'
+  description 'Run a shell command in the working directory and return its combined stdout/stderr and exit status. ' \
+              'Use this for listing, searching (rg/grep/find), running tests, git, etc.'
+
+  timeout 600
+
+  DEFAULT_TIMEOUT_MS = 120_000
+  MAX_OUTPUT_BYTES = 30_000
+
+  params do
+    required :command, String, description: 'The shell command to run'
+    optional :timeout_ms, Integer, description: 'Kill the command after this many milliseconds', default: DEFAULT_TIMEOUT_MS
+  end
+
+  def call(context:, command:, timeout_ms: DEFAULT_TIMEOUT_MS)
+    output, status = run(command, timeout_ms / 1000.0)
+    output = truncate(output.rstrip)
+
+    return error("Command exited with status #{status}\n#{output}", type: :command_failed) unless status.zero?
+
+    text(output.empty? ? '(no output)' : output)
+  end
+
+  private
+
+  def run(command, timeout_seconds)
+    stdin, stdout_and_stderr, wait_thread = Open3.popen2e(command, chdir: Dir.pwd, pgroup: true)
+    stdin.close
+
+    unless wait_thread.join(timeout_seconds)
+      kill_group(wait_thread.pid)
+      output = stdout_and_stderr.read
+      stdout_and_stderr.close
+      return ["#{output}\n[timed out after #{timeout_seconds.round}s]", 124]
+    end
+
+    output = stdout_and_stderr.read
+    stdout_and_stderr.close
+    [output, wait_thread.value.exitstatus || 1]
+  end
+
+  def kill_group(pid)
+    Process.kill('TERM', -Process.getpgid(pid))
+  rescue Errno::ESRCH, Errno::EPERM
+    nil
+  end
+
+  def truncate(output)
+    return output if output.bytesize <= MAX_OUTPUT_BYTES
+
+    "#{output.byteslice(0, MAX_OUTPUT_BYTES)}\n[output truncated to #{MAX_OUTPUT_BYTES} bytes]"
+  end
+end

data/lib/riffer/rig/tools/edit.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Tools::Edit < Riffer::Tool
+  identifier 'edit'
+  description 'Replace an exact string in a file. By default old_string must occur exactly once; ' \
+              'set replace_all to replace every occurrence.'
+
+  params do
+    required :path, String, description: 'Path to the file (absolute, or relative to the working directory)'
+    required :old_string, String, description: 'The exact text to replace'
+    required :new_string, String, description: 'The text to replace it with'
+    optional :replace_all, Riffer::Params::Boolean, description: 'Replace all occurrences instead of requiring a unique match', default: false
+  end
+
+  def call(context:, path:, old_string:, new_string:, replace_all: false)
+    resolved = File.expand_path(path, Dir.pwd)
+    return error("File not found: #{path}", type: :not_found) unless File.file?(resolved)
+
+    content = File.read(resolved)
+    occurrences = content.scan(old_string).length
+
+    return error("old_string not found in #{path}", type: :not_found) if occurrences.zero?
+    return error("old_string is not unique in #{path} (#{occurrences} matches). Pass replace_all or add more context.", type: :ambiguous_match) if occurrences > 1 && !replace_all
+
+    # Block form so backslash sequences in new_string (\0, \1, \\) are inserted
+    # literally instead of being interpreted as regexp backreferences.
+    updated = replace_all ? content.gsub(old_string) { new_string } : content.sub(old_string) { new_string }
+    File.write(resolved, updated)
+
+    text("Edited #{path} (#{replace_all ? occurrences : 1} replacement#{'s' if replace_all && occurrences > 1})")
+  end
+end

data/lib/riffer/rig/tools/read.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Tools::Read < Riffer::Tool
+  identifier 'read'
+  description 'Read a file from the filesystem. Returns its contents with line numbers. ' \
+              'Use offset/limit to read a slice of a large file.'
+
+  DEFAULT_LIMIT = 2000
+
+  params do
+    required :path, String, description: 'Path to the file (absolute, or relative to the working directory)'
+    optional :offset, Integer, description: '1-based line number to start reading from'
+    optional :limit, Integer, description: 'Maximum number of lines to read', default: DEFAULT_LIMIT
+  end
+
+  def call(context:, path:, offset: nil, limit: DEFAULT_LIMIT)
+    resolved = File.expand_path(path, Dir.pwd)
+    return error("File not found: #{path}", type: :not_found) unless File.file?(resolved)
+    return error('offset must be >= 1', type: :invalid_argument) if offset && offset < 1
+
+    start = offset ? offset - 1 : 0
+    lines = File.readlines(resolved, chomp: true)
+    slice = lines[start, limit] || []
+
+    numbered = slice.each_with_index.map do |line, i|
+      format("%<lineno>6d\t%<text>s", lineno: start + i + 1, text: line)
+    end
+
+    text(numbered.join("\n"))
+  end
+end

data/lib/riffer/rig/tools/write.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+class Riffer::Rig::Tools::Write < Riffer::Tool
+  identifier 'write'
+  description 'Write content to a file, creating it (and any parent directories) or overwriting it.'
+
+  params do
+    required :path, String, description: 'Path to the file (absolute, or relative to the working directory)'
+    required :content, String, description: 'The full content to write to the file'
+  end
+
+  def call(context:, path:, content:)
+    resolved = File.expand_path(path, Dir.pwd)
+    FileUtils.mkdir_p(File.dirname(resolved))
+    File.write(resolved, content)
+
+    text("Wrote #{content.bytesize} bytes to #{path}")
+  end
+end

data/lib/riffer/rig/ui/animator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# 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 = 0.05
+  SPINNER_FRAME_SECONDS = 0.12
+
+  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io))
+    @io = io
+    @theme = theme
+    @thread = nil
+  end
+
+  # When not on a TTY, prints the final frame once instead of animating.
+  def reveal(frames)
+    unless enabled?
+      frames.last.each { |line| @io.puts(line) }
+      return
+    end
+
+    height = frames.first.length
+    frames.each_with_index do |lines, index|
+      lines.each { |line| @io.print("#{line}\e[K\n") }
+      @io.flush
+      sleep(REVEAL_FRAME_SECONDS)
+      @io.print("\e[#{height}A\r") unless index == frames.length - 1
+    end
+  end
+
+  def start_thinking
+    return unless enabled?
+
+    @stop = false
+    @thread = Thread.new do
+      tick = 0
+      until @stop
+        @io.print("\r  #{Riffer::Rig::UI::Riffy.equalizer(@theme, tick)}\e[K")
+        @io.flush
+        sleep(SPINNER_FRAME_SECONDS)
+        tick += 1
+      end
+    end
+  end
+
+  def stop_thinking
+    return unless @thread
+
+    @stop = true
+    @thread.join
+    @thread = nil
+    @io.print("\r\e[K")
+    @io.flush
+  end
+
+  private
+
+  def enabled?
+    @theme.enabled && @io.respond_to?(:tty?) && @io.tty?
+  end
+end

data/lib/riffer/rig/ui/banner.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::UI::Banner
+  extend self
+
+  WORDMARK = [
+    '██████╗ ██╗███████╗███████╗███████╗██████╗ ',
+    '██╔══██╗██║██╔════╝██╔════╝██╔════╝██╔══██╗',
+    '██████╔╝██║█████╗  █████╗  █████╗  ██████╔╝',
+    '██╔══██╗██║██╔══╝  ██╔══╝  ██╔══╝  ██╔══██╗',
+    '██║  ██║██║██║     ██║     ███████╗██║  ██║',
+    '╚═╝  ╚═╝╚═╝╚═╝     ╚═╝     ╚══════╝╚═╝  ╚═╝'
+  ].freeze
+
+  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
+  ].freeze
+
+  INFO_LABEL_WIDTH = 8
+  INDENT = '  '
+  BEAR_GAP = '  '
+
+  def call(theme, model:, cwd:, context:, skills:, version:, glint_col: nil)
+    lines(theme, model: model, cwd: cwd, context: context, skills: skills, version: version, glint_col: glint_col).join("\n")
+  end
+
+  def lines(theme, model:, cwd:, context:, skills:, version:, glint_col: nil)
+    [''] + art(theme, glint_col: glint_col) + [''] +
+      info(theme, model: model, cwd: cwd, context: context, skills: skills, version: version) + ['']
+  end
+
+  def art(theme, glint_col: nil)
+    bear = Riffer::Rig::UI::Riffy.render(theme, glint_col: glint_col)
+    right = WORDMARK.each_index.map { |i| theme.paint(WORDMARK[i], ROW_COLOURS[i]) }
+    right += ['', "#{theme.grey('· code ·')}   #{theme.cyan("♪ let's riff ♪")}"]
+
+    pad = (bear.length - right.length) / 2
+    bear.each_index.map do |i|
+      side = right[i - pad] if (pad...(pad + right.length)).cover?(i)
+      "#{INDENT}#{bear[i]}#{BEAR_GAP}#{side}".rstrip
+    end
+  end
+
+  def info(theme, model:, cwd:, context:, skills:, version:)
+    rows = { model: model, cwd: cwd, context: context, 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')}"]
+  end
+end

data/lib/riffer/rig/ui/palette.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::UI::Palette
+  PINK = [255, 106, 193].freeze
+  MAGENTA = [192, 76, 253].freeze
+  PURPLE = [122, 92, 255].freeze
+  BLUE = [77, 124, 255].freeze
+  CYAN = [45, 226, 230].freeze
+  GREY = [138, 139, 154].freeze
+  RED = [255, 92, 122].freeze
+end

data/lib/riffer/rig/ui/pixels.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Each character cell stacks two vertical pixels via half-block glyphs (▀ top,
+# ▄ bottom): the foreground colours the top pixel and the background the bottom,
+# doubling vertical resolution. A disabled theme falls back to plain block
+# glyphs so piped/non-colour output stays escape-free.
+module Riffer::Rig::UI::Pixels
+  extend self
+
+  RESET = "\e[0m"
+
+  def render(sprite, palette, theme)
+    sprite.each_slice(2).map do |top, bottom|
+      render_row(top, bottom || [], palette, theme)
+    end
+  end
+
+  private
+
+  def render_row(top, bottom, palette, theme)
+    width = [top.length, bottom.length].max
+    (0...width).map { |x| cell(palette[top[x]], palette[bottom[x]], theme) }.join
+  end
+
+  def cell(top_rgb, bottom_rgb, theme)
+    return ' ' if top_rgb.nil? && bottom_rgb.nil?
+
+    unless theme.enabled
+      return '█' if top_rgb && bottom_rgb
+      return '▀' if top_rgb
+
+      return '▄'
+    end
+
+    if top_rgb && bottom_rgb
+      "#{fg(top_rgb)}#{bg(bottom_rgb)}▀#{RESET}"
+    elsif top_rgb
+      "#{fg(top_rgb)}▀#{RESET}"
+    else
+      "#{fg(bottom_rgb)}▄#{RESET}"
+    end
+  end
+
+  def fg(rgb) = "\e[38;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m"
+
+  def bg(rgb) = "\e[48;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m"
+end

data/lib/riffer/rig/ui/renderer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class Riffer::Rig::UI::Renderer
+  RESULT_PREVIEW_LIMIT = 200
+
+  def initialize(io: $stdout, theme: Riffer::Rig::UI::Theme.for(io), tally: nil)
+    @io = io
+    @theme = theme
+    @tally = tally
+  end
+
+  def render(event)
+    case event
+    when Riffer::StreamEvents::TextDelta
+      @io.print(event.content)
+    when Riffer::StreamEvents::ToolCallDone
+      @io.puts("\n#{@theme.cyan("⚙ #{event.name}(#{format_arguments(event.arguments)})")}")
+    when Riffer::StreamEvents::SkillActivation
+      @io.puts("\n#{@theme.magenta("✦ skill: #{event.name}")}")
+    when Riffer::StreamEvents::Interrupt
+      @io.puts(@theme.dim("[interrupted: #{event.reason}]"))
+    when Riffer::StreamEvents::TokenUsageDone
+      render_token_usage(event.token_usage)
+    end
+  end
+
+  def render_tool_result(message)
+    return unless message.is_a?(Riffer::Messages::Tool)
+
+    line = "↳ #{preview(message.content)}"
+    @io.puts(message.error? ? @theme.red(line) : @theme.dim(line))
+  end
+
+  private
+
+  def render_token_usage(usage)
+    return unless @tally
+
+    @tally.add(usage)
+
+    parts = ["↑#{usage.input_tokens}", "↓#{usage.output_tokens}"]
+    parts << "cache_write:#{usage.cache_write_tokens}" if usage.cache_write_tokens&.positive?
+    parts << "cache_read:#{usage.cache_read_tokens}" if usage.cache_read_tokens&.positive?
+
+    session_parts = ["session #{@tally.total_tokens} tok"]
+    cost = @tally.estimated_cost
+    session_parts << format('~$%.4f', cost) if cost
+
+    @io.puts("\n#{@theme.dim("#{parts.join(' · ')}   #{session_parts.join(' · ')}")}")
+  end
+
+  def format_arguments(arguments)
+    parsed = JSON.parse(arguments)
+    parsed.map { |key, value| "#{key}: #{value.inspect}" }.join(', ')
+  rescue JSON::ParserError
+    arguments
+  end
+
+  def preview(content)
+    first_line = content.to_s.lines.first.to_s.chomp
+    return first_line if first_line.length <= RESULT_PREVIEW_LIMIT
+
+    "#{first_line[0, RESULT_PREVIEW_LIMIT]}…"
+  end
+end

data/lib/riffer/rig/ui/riffy.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# riffer-rig's mascot sprite, authored as a character grid (see LEGEND).
+module Riffer::Rig::UI::Riffy
+  extend self
+
+  LEGEND = {
+    '.' => nil,
+    'D' => :outline,  # deep purple outline / shadow / nose
+    'B' => :body,     # purple fur
+    'M' => :shade,    # mid purple (inner ear, jaw shadow, leg lines)
+    'L' => :light,    # light lilac (snout, paw pads)
+    'K' => :shades,   # near-black sunglasses
+    'W' => :glint     # lens glint (intro only)
+  }.freeze
+
+  PALETTE = {
+    outline: [74, 46, 122],
+    body: [157, 92, 232],
+    shade: [120, 66, 190],
+    light: [212, 180, 250],
+    shades: [12, 10, 20],
+    glint: [240, 240, 255]
+  }.freeze
+
+  GRID = [
+    '...DDDD......DDDD...',
+    '..DBBBBD....DBBBBD..',
+    '..DBMMBD....DBMMBD..',
+    '..DBMMBD....DBMMBD..',
+    '..DBBDDDDDDDDDDBBD..',
+    '...DBBBBBBBBBBBBD...',
+    '...DKKKKKKKKKKKKD...',
+    '...DKKKKKBBKKKKKD...',
+    '...DBKKKBBBBKKKBD...',
+    '...DBBBBBDDBBBBBD...',
+    '...DBBBBLLLLBBBBD...',
+    '...DBBBMLLLLMBBBD...',
+    '....DBBBBBBBBBBD....',
+    '....DDMMMMMMMMDD....',
+    '.....DBBBBBBBBD.....',
+    '....DBBBBBBBBBBD....',
+    '...DBBBBBBBBBBBBD...',
+    '..DBBBBBBBBBBBBBBD..',
+    '.DBBBBBBBBBBBBBBBBD.',
+    '.DBBBBDBBDDBBDBBBBD.',
+    '.DLLLDDLLDDLLDDLLLD.'
+  ].freeze
+
+  WIDTH = GRID.first.length
+  HEIGHT = (GRID.length + 1) / 2
+
+  LENS_ROWS = [6, 7, 8].freeze
+  GLINT_COLS = [4, 5, 6, 7, 8, 11, 12, 13, 14, 15].freeze
+
+  EQ_LEVELS = '▁▂▃▄▅▆▇█'.chars.freeze
+  EQ_BARS = 7
+
+  def render(theme, glint_col: nil)
+    sprite = GRID.map { |row| row.chars.map { |char| LEGEND.fetch(char) } }
+    apply_glint(sprite, glint_col) if glint_col
+    Riffer::Rig::UI::Pixels.render(sprite, PALETTE, theme)
+  end
+
+  def equalizer(theme, tick)
+    bars = Array.new(EQ_BARS) do |i|
+      height = (Math.sin((tick + i) * 0.6).abs * (EQ_LEVELS.length - 1)).round
+      bar = EQ_LEVELS[height]
+      i.even? ? theme.cyan(bar) : theme.magenta(bar)
+    end
+    "#{bars.join} #{theme.grey('riffing…')}"
+  end
+
+  private
+
+  def apply_glint(sprite, column)
+    LENS_ROWS.each do |row|
+      sprite[row][column] = :glint if sprite[row][column] == :shades
+    end
+  end
+end

data/lib/riffer/rig/ui/theme.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# +enabled+ gates every escape so the same code path emits plain, escape-free
+# text when piped or tested.
+Riffer::Rig::UI::Theme = Data.define(:enabled)
+
+# Behaviour lives in a reopened class (rather than the `Data.define` block) so
+# the type checker can analyse the methods.
+class Riffer::Rig::UI::Theme
+  def self.for(io)
+    new(enabled: io.respond_to?(:tty?) && io.tty? && !ENV.key?('NO_COLOR'))
+  end
+
+  def paint(text, rgb)
+    return text.to_s unless enabled
+
+    "\e[38;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m#{text}\e[0m"
+  end
+
+  def pink(text) = paint(text, Riffer::Rig::UI::Palette::PINK)
+
+  def magenta(text) = paint(text, Riffer::Rig::UI::Palette::MAGENTA)
+
+  def purple(text) = paint(text, Riffer::Rig::UI::Palette::PURPLE)
+
+  def blue(text) = paint(text, Riffer::Rig::UI::Palette::BLUE)
+
+  def cyan(text) = paint(text, Riffer::Rig::UI::Palette::CYAN)
+
+  def grey(text) = paint(text, Riffer::Rig::UI::Palette::GREY)
+
+  def red(text) = paint(text, Riffer::Rig::UI::Palette::RED)
+
+  def dim(text)
+    return text.to_s unless enabled
+
+    "\e[2m#{text}\e[0m"
+  end
+
+  def bold(text)
+    return text.to_s unless enabled
+
+    "\e[1m#{text}\e[0m"
+  end
+end

data/lib/riffer/rig/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Riffer
+  module Rig
+    VERSION = '0.1.0'
+  end
+end

data/lib/riffer/rig.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'riffer'
+require_relative 'rig/version'
+
+loader = Zeitwerk::Loader.for_gem_extension(Riffer)
+loader.ignore("#{__dir__}/rig/version.rb")
+loader.inflector.inflect('cli' => 'CLI', 'repl' => 'REPL', 'ui' => 'UI')
+loader.setup

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: riffer-rig
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jake Bottrall
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: riffer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.45.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.45.0
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: An interactive terminal coding agent (read/write/edit/bash) built on
+  the riffer agentic framework.
+email:
+- jakebottrall@gmail.com
+executables:
+- riffer
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- exe/riffer
+- lib/riffer/rig.rb
+- lib/riffer/rig/cli.rb
+- lib/riffer/rig/coding_agent.rb
+- lib/riffer/rig/credentials.rb
+- lib/riffer/rig/repl.rb
+- lib/riffer/rig/settings.rb
+- lib/riffer/rig/token_tally.rb
+- lib/riffer/rig/tools/bash.rb
+- lib/riffer/rig/tools/edit.rb
+- lib/riffer/rig/tools/read.rb
+- lib/riffer/rig/tools/write.rb
+- lib/riffer/rig/ui/animator.rb
+- lib/riffer/rig/ui/banner.rb
+- lib/riffer/rig/ui/palette.rb
+- lib/riffer/rig/ui/pixels.rb
+- lib/riffer/rig/ui/renderer.rb
+- lib/riffer/rig/ui/riffy.rb
+- lib/riffer/rig/ui/theme.rb
+- lib/riffer/rig/version.rb
+homepage: https://github.com/bottrall/riffer-rig
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  changelog_uri: https://github.com/bottrall/riffer-rig/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/bottrall/riffer-rig
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: A dead-simple terminal coding agent built on riffer.
+test_files: []