brute_cli 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8505051f8c9895144293784e61c82810556a9a9e82896a7808a69c6ea28df7f1
-  data.tar.gz: f17b5dbe8a96c4a0c8960f9e871fce0190c54a06d1e52610ee2b1448c7dfaea0
+  metadata.gz: 5d935729b509640bc8f34ab0250ba7aa4760c66f600e2f8ce4dc74ad2e9e756a
+  data.tar.gz: 7b61d6668976f55bfd334d718b6beb274ffb29a6cd85de1cd4178b7da59e211b
 SHA512:
-  metadata.gz: 1ac361628483b1be32ce71fd2d4a140df73f4813be3636edc00e59ea4ad78fbf6fedb86c38083b3e28de39e517895fd300ffafe8fb9134ba6f822068bfb28f41
-  data.tar.gz: 80cbf082aceb6af2aeff93dbd589f56dc9722151bd8ff82abe68f071bea46360fa5ada02eaa9df50de9b38a5b7d19525bafe9eb6f8b163eabb7da7369dec4732
+  metadata.gz: 750488466360f678c3ec34a637980dbb727e64f8b24cd27e86f015503a14b9dedd36da7eca002f905f4e7ddd191b42a9fe2d163bad229c83765d2a26de9f8ecf
+  data.tar.gz: 7917a11383995c907541543b4893f2067ab50ae16389b56054255e866a3f35f7b223e3b37d69c4b4b97876e245c9ef1bb843567598cf05024b497fde2fe43880

data/exe/brute

@@ -15,73 +15,50 @@ OptionParser.new do |opts|
   opts.on("-h", "--help", "Show help")                 { puts opts; exit }
 end.parse!
 
+# ── List sessions ──
+
 if options[:list]
   sessions = Brute::Session.list
   if sessions.empty?
     puts "No saved sessions."
   else
-    sessions.each { |s| puts "  #{s[:id]}  #{s[:title] || "(untitled)"}  #{s[:saved_at]}" }
+    title_style = Lipgloss::Style.new.bold(true).foreground(BruteCLI::Styles::PURPLE)
+    id_style    = Lipgloss::Style.new.foreground(BruteCLI::Styles::CYAN)
+    time_style  = Lipgloss::Style.new.foreground(BruteCLI::Styles::DIM)
+
+    sessions.each do |s|
+      id    = id_style.render(s[:id][0..7])
+      title = title_style.render(s[:title] || "(untitled)")
+      time  = time_style.render(s[:saved_at].to_s)
+      puts "  #{id}  #{title}  #{time}"
+    end
   end
   exit
 end
 
-# Agent is created lazily on first prompt — no API key needed to boot.
-session = Brute::Session.new(id: options[:session_id])
-orch = nil
-
-make_agent = -> {
-  return orch if orch
-  orch = Brute.agent(
-    cwd: options[:cwd],
-    session: session,
-    on_content:     ->(text) { print text },
-    on_reasoning:   ->(_text) { },
-    on_tool_call:   ->(name, args) {
-      $stderr.puts "\n--- [tool] #{name} ---"
-      if args.is_a?(Hash)
-        args.each { |k, v| $stderr.puts "  #{k}: #{v.to_s[0..100]}" }
-      end
-    },
-    on_tool_result: ->(name, result) {
-      if result.is_a?(Hash) && result[:error]
-        $stderr.puts "  [FAILED] #{result[:error]}"
-      else
-        $stderr.puts "  [ok]"
-      end
-    },
-  )
-  session.restore(orch.context) if options[:session_id]
-  orch
-}
+# ── Collect prompt ──
 
 prompt = ARGV.join(" ")
 prompt = $stdin.read.strip if prompt.empty? && !$stdin.tty?
 
+# ── Run ──
+
+repl = BruteCLI::REPL.new(options)
+
 begin
   if prompt.empty?
-    $stderr.puts "brute> (interactive mode, Ctrl-D to exit)\n\n"
-    loop do
-      $stderr.print "brute> "
-      input = $stdin.gets&.chomp
-      break if input.nil? || input.strip == "exit"
-      next if input.strip.empty?
-      puts
-      make_agent.call.run(input)
-      puts "\n\n"
-    end
+    # Interactive mode
+    repl.run_interactive
   else
-    make_agent.call.run(prompt)
+    # Single prompt mode
+    repl.run_once(prompt)
     puts
   end
 rescue Interrupt
   $stderr.puts "\nAborted."
   exit 130
-rescue RuntimeError, LLM::RateLimitError, LLM::ServerError => e
-  BruteCLI.error(e.message)
-  $stderr.puts "  #{e.backtrace.first}".red if ENV["BRUTE_DEBUG"]
-  exit 1
 rescue => e
   BruteCLI.error(e.message)
-  $stderr.puts "  #{e.backtrace.first}".red if ENV["BRUTE_DEBUG"]
+  $stderr.puts "  #{e.backtrace&.first}" if ENV["BRUTE_DEBUG"]
   exit 1
 end

data/lib/brute_cli/emoji.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'gemoji'
+
+module BruteCLI
+  module Emoji
+    def self.find(name)
+      ::Emoji.find_by_alias(name)&.raw || ''
+    end
+
+    EYES       = find('eyes')
+    PENCIL     = find('pencil2')
+    PAGE       = find('page_facing_up')
+    COMPUTER   = find('computer')
+    SPARKLES   = find('sparkles')
+    GLOBE      = find('globe_with_meridians')
+    WASTEBASKET = find('wastebasket')
+    REWIND     = find('rewind')
+    DIAMOND    = find('diamond_shape_with_a_dot_inside')
+    GEAR       = find('gear')
+    MAG        = find('mag')
+    HAMMER     = find('hammer_and_wrench')
+    PACKAGE    = find('package')
+    CLIPBOARD  = find('clipboard')
+    CHECK      = find('white_check_mark')
+    CROSS      = find('x')
+    WRITING    = find('writing_hand')
+    ROBOT      = find('robot')
+    FOLDER     = find('file_folder')
+  end
+end

data/lib/brute_cli/repl.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'io/console'
+require 'reline'
+require 'tty-spinner'
+require 'brute_cli/styles'
+
+module BruteCLI
+  class REPL
+    def initialize(options = {})
+      @options = options
+      @agent = nil
+      @session = nil
+      @width = detect_width
+      @content_buf = +''
+      @spinner = nil
+    end
+
+    def run_once(prompt)
+      ensure_agent!
+      execute(prompt)
+    end
+
+    def run_interactive
+      print_banner
+      resolve_provider_info
+      setup_reline
+
+      loop do
+        result = read_prompt
+        break if result.nil?
+        next if result.empty?
+        break if %w[exit quit].include?(result)
+
+        ensure_agent!
+        execute(result)
+        $stdout.puts
+      end
+    rescue Interrupt
+      $stdout.puts
+    end
+
+    private
+
+    # ── Reline ──
+
+    def setup_reline
+      subtitle = build_subtitle
+
+      Reline.prompt_proc = proc { |lines|
+        lines.map.with_index do |_, i|
+          i == 0 ? Styles::PROMPT.render('>') + ' ' : Styles::DIM_TEXT.render('.') + ' '
+        end
+      }
+
+      Reline.add_dialog_proc(:brute_status, lambda {
+        Reline::DialogRenderInfo.new(
+          pos: Reline::CursorPos.new(0, cursor_pos.y > 0 ? 3 : 1),
+          contents: [subtitle],
+          width: screen_width
+        )
+      }, nil)
+    end
+
+    def read_prompt
+      input = Reline.readmultiline(Styles::PROMPT.render('>') + ' ', true) { |t| !t.rstrip.end_with?('\\') }
+      return nil if input.nil?
+
+      input.gsub(/\\\n/, "\n").strip
+    end
+
+    # ── Provider ──
+
+    def resolve_provider_info
+      provider = begin
+        Brute.provider
+      rescue StandardError
+        nil
+      end
+      @provider_name = provider&.name&.to_s
+      @model_name = provider&.default_model&.to_s
+    end
+
+    def model_short
+      @model_name&.sub(/^claude-/, '')&.sub(/-\d{8}$/, '') || @model_name
+    end
+
+    def build_subtitle
+      parts = []
+      parts << stat_span(@provider_name, model_short) if @provider_name && model_short
+      parts << stat_span('agent', 'brute')
+      '  ' + parts.join(Styles::DIM_TEXT.render(' · '))
+    end
+
+    def stat_span(label, value)
+      Styles::DIM_TEXT.render("#{label} ") + Styles::STAT_VALUE.render(value)
+    end
+
+    # ── Agent ──
+
+    def ensure_agent!
+      return if @agent
+
+      @session = Brute::Session.new(id: @options[:session_id])
+      @agent = Brute.agent(
+        cwd: @options[:cwd] || Dir.pwd,
+        session: @session,
+        logger: Logger.new(File::NULL),
+        on_content: method(:on_content),
+        on_reasoning: method(:on_reasoning),
+        on_tool_call: method(:on_tool_call),
+        on_tool_result: method(:on_tool_result)
+      )
+      @session.restore(@agent.context) if @options[:session_id]
+    end
+
+    # ── Execute ──
+
+    def execute(prompt)
+      @content_buf = +''
+
+      print_model_line
+      start_spinner('Thinking...')
+
+      begin
+        @agent.run(prompt)
+      rescue Interrupt
+        stop_spinner
+        flush_content
+        styled_puts Styles::DIM_TEXT.render('  Aborted.')
+        print_stats_bar
+        return
+      rescue StandardError => e
+        stop_spinner
+        flush_content
+        print_error(e)
+        print_stats_bar
+        return
+      end
+
+      stop_spinner
+      flush_content
+      print_stats_bar
+    end
+
+    def print_model_line
+      parts = []
+      parts << stat_span(@provider_name, model_short) if @provider_name && model_short
+      parts << stat_span('agent', 'brute')
+      styled_puts '  ' + parts.join(Styles::DIM_TEXT.render(' · '))
+    end
+
+    # ── Spinner ──
+
+    RAINBOW = [
+      "\e[38;2;255;56;96m",  "\e[38;2;255;165;0m",
+      "\e[38;2;255;220;0m",  "\e[38;2;0;219;68m",
+      "\e[38;2;0;186;255m",  "\e[38;2;107;80;255m",
+      "\e[38;2;255;96;255m"
+    ].freeze
+    RESET = "\e[0m"
+
+    def nyan_frames
+      bar = '━' * 12
+      bar.length.times.map do |offset|
+        bar.chars.map.with_index { |c, i| RAINBOW[(i + offset) % RAINBOW.length] + c }.join + RESET
+      end
+    end
+
+    def start_spinner(label)
+      stop_spinner
+      @spinner = TTY::Spinner.new(
+        "  :spinner #{label}",
+        frames: nyan_frames,
+        interval: 8,
+        output: $stdout
+      )
+      @spinner.auto_spin
+    end
+
+    def stop_spinner
+      return unless @spinner
+
+      @spinner.stop('') if @spinner.spinning?
+      @spinner = nil
+    end
+
+    # ── Callbacks ──
+
+    def on_content(text)
+      stop_spinner
+      @content_buf << text
+    end
+
+    def on_reasoning(_text); end
+
+    INLINE_TOOLS = %w[read fs_search todo_read todo_write fetch].freeze
+    TOOL_ICONS = {
+      'read' => Emoji::EYES, 'patch' => Emoji::HAMMER, 'write' => Emoji::WRITING,
+      'shell' => Emoji::COMPUTER, 'fs_search' => Emoji::MAG, 'fetch' => Emoji::GLOBE,
+      'todo_read' => Emoji::CLIPBOARD, 'todo_write' => Emoji::CLIPBOARD,
+      'remove' => Emoji::WASTEBASKET, 'undo' => Emoji::REWIND, 'delegate' => Emoji::ROBOT
+    }.freeze
+
+    def on_tool_call(name, args)
+      stop_spinner
+      flush_content
+      @pending_tool = { name: name, args: args }
+    end
+
+    def on_tool_result(name, result)
+      stop_spinner
+      tool = @pending_tool || { name: name, args: {} }
+
+      if INLINE_TOOLS.include?(tool[:name])
+        print_inline_tool(tool, result)
+      else
+        print_block_tool(tool, result)
+      end
+
+      @pending_tool = nil
+      start_spinner('Thinking...')
+    end
+
+    # ── Output ──
+
+    def flush_content
+      return if @content_buf.strip.empty?
+
+      rendered = glamour_render(@content_buf)
+      $stdout.puts
+      $stdout.puts rendered
+      $stdout.flush
+      @content_buf = +''
+    end
+
+    def glamour_render(text)
+      width = [@width - 4, 40].max
+      Glamour.render(text.strip, style: 'auto', width: width).rstrip
+    rescue StandardError => _e
+      text
+    end
+
+    def print_inline_tool(tool, result)
+      icon = TOOL_ICONS[tool[:name].to_s] || Emoji::GEAR
+      name = tool[:name].to_s
+      summary = tool_summary(tool) || ''
+
+      if error_result?(result)
+        styled_puts "  #{icon} #{Styles::TOOL_BADGE.render(name)} #{summary} #{Styles::TOOL_FAIL.render('FAILED')}"
+      else
+        styled_puts "  #{icon} #{Styles::TOOL_BADGE.render(name)} #{summary}"
+      end
+    end
+
+    def print_block_tool(tool, result)
+      icon = TOOL_ICONS[tool[:name].to_s] || Emoji::GEAR
+      name = tool[:name].to_s
+      title = "#{icon} #{Styles::TOOL_BADGE.render(name)}"
+
+      body_lines = []
+
+      summary = tool_summary(tool) || ''
+      body_lines << summary unless summary.empty?
+
+      # Diff
+      diff = result.is_a?(Hash) && (result[:diff] || result['diff'])
+      body_lines.concat(format_diff_lines(diff)) if diff && !diff.strip.empty?
+
+      # Shell output
+      stdout = result.is_a?(Hash) && (result[:stdout] || result['stdout'])
+      if stdout && !stdout.strip.empty?
+        lines = stdout.strip.lines.map(&:chomp)
+        lines = lines.first(15) + [Styles::DIM_TEXT.render('... (truncated)')] if lines.size > 15
+        body_lines.concat(lines.map { |l| Styles::DIM_TEXT.render(l) })
+      end
+
+      # Status
+      if error_result?(result)
+        msg = error_message(result)
+        msg = msg[0..70] + '...' if msg.length > 70
+        body_lines << "#{Styles::TOOL_FAIL.render('FAILED')} #{Styles::DIM_TEXT.render(msg)}"
+      else
+        body_lines << Styles::TOOL_OK.render('OK')
+      end
+
+      styled_puts render_titled_frame(title, body_lines)
+    end
+
+    def error_result?(result)
+      return false unless result.is_a?(Hash)
+
+      result[:error] || result['error']
+    end
+
+    def error_message(result)
+      return '' unless result.is_a?(Hash)
+
+      (result[:message] || result['message'] || result[:error] || result['error']).to_s
+    end
+
+    def tool_summary(tool)
+      args = tool[:args]
+      return '' unless args.is_a?(Hash) && !args.empty?
+
+      # Show the most relevant arg (file_path, command, etc.)
+      path = args['file_path'] || args[:file_path]
+      cmd = args['command'] || args[:command]
+      pattern = args['pattern'] || args[:pattern]
+
+      if path
+        Styles::DIM_TEXT.render(path.to_s)
+      elsif cmd
+        Styles::DIM_TEXT.render(cmd.to_s[0..60])
+      elsif pattern
+        Styles::DIM_TEXT.render("\"#{pattern}\"")
+      else
+        ''
+      end
+    end
+
+    def format_diff_lines(diff_text)
+      diff_text.lines.map do |line|
+        l = line.chomp
+        case l[0]
+        when '+' then Styles::DIFF_ADDED.render(l)
+        when '-' then Styles::DIFF_REMOVED.render(l)
+        when '@' then Styles::DIFF_HUNK.render(l)
+        else          Styles::DIFF_CONTEXT.render(l)
+        end
+      end
+    end
+
+    def render_titled_frame(title, body_lines)
+      m = Styles::SEPARATOR
+      title_w = visible_width(title)
+      body_w = body_lines.map { |l| visible_width(l) }.max || 0
+      inner_w = [title_w, body_w].max + 2
+
+      top = m.render('╭─ ') + title + ' ' + m.render('─' * [inner_w - title_w - 1, 0].max + '╮')
+      bot = m.render('╰' + '─' * (inner_w + 2) + '╯')
+      mid = body_lines.map do |l|
+        pad = inner_w - visible_width(l)
+        m.render('│') + ' ' + l + ' ' * [pad, 0].max + ' ' + m.render('│')
+      end
+
+      ([top] + mid + [bot]).join("\n")
+    end
+
+    def visible_width(str)
+      str.gsub(/\e\[[0-9;]*m/, '').gsub(/\p{Emoji_Presentation}|\p{Emoji}\uFE0F?/, 'XX').length
+    end
+
+    # ── Stats ──
+
+    def print_stats_bar
+      metadata = @agent&.env&.dig(:metadata) || {}
+      tokens = metadata[:tokens] || {}
+      timing = metadata[:timing] || {}
+      tool_calls = metadata[:tool_calls] || 0
+      parts = []
+      parts << format_stat('tokens', format_tokens(tokens))
+      parts << format_stat('time', format_time(timing[:total_elapsed] || 0))
+      parts << format_stat('tools', tool_calls.to_s) if tool_calls > 0
+      $stdout.puts
+      styled_puts separator
+      styled_puts '  ' + parts.join(Styles::DIM_TEXT.render('  |  '))
+      styled_puts separator
+    end
+
+    def format_stat(l, v)
+      Styles::DIM_TEXT.render("#{l} ") + Styles::STAT_VALUE.render(v)
+    end
+
+    def format_tokens(t)
+      total = t[:total] || 0
+      return '0' if total == 0
+
+      "#{total} (#{t[:total_input] || 0}in/#{t[:total_output] || 0}out)"
+    end
+
+    def format_time(s)
+      s < 60 ? "#{s.round(1)}s" : "#{(s / 60).floor}m#{(s % 60).round(1)}s"
+    end
+
+    # ── Error ──
+
+    def print_error(err)
+      styled_puts "\n#{Styles::ERROR_BADGE.render('ERROR')} #{Styles::ERROR_REASON.render(err.message)}"
+      styled_puts Styles::DIM_TEXT.render("  #{err.backtrace.first}") if ENV['BRUTE_DEBUG'] && err.backtrace&.first
+    end
+
+    # ── UI ──
+
+    def print_banner
+      styled_puts separator
+      styled_puts Styles::DIM_TEXT.render("  brute #{Brute::VERSION} — interactive mode")
+      styled_puts separator
+      $stdout.puts
+    end
+
+    def styled_puts(text)
+      $stdout.puts text
+      $stdout.flush
+    end
+
+    def separator
+      Styles::SEPARATOR.render('─' * [@width, 40].max)
+    end
+
+    def detect_width
+      _rows, cols = IO.console&.winsize
+      cols || 80
+    rescue StandardError
+      80
+    end
+  end
+end

data/lib/brute_cli/styles.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'lipgloss'
+
+module BruteCLI
+  module Styles
+    # Styles.foreground("#fff").bold(true) etc -- delegates to Lipgloss::Style.new
+    def self.method_missing(name, *args, &block)
+      Lipgloss::Style.new.send(name, *args, &block)
+    end
+
+    def self.respond_to_missing?(name, include_private = false)
+      Lipgloss::Style.new.respond_to?(name) || super
+    end
+
+    # Brand colors
+    PURPLE  = '#6B50FF'
+    PINK    = '#FF60FF'
+    CYAN    = '#3EEFCF'
+    RED     = '#FF5F87'
+    DIM     = '#757575'
+    MUTED   = '#585858'
+    WHITE   = '#F1F1F1'
+    DARK_BG = '#1A1A2E'
+
+    PROMPT       = foreground(PURPLE).bold(true)
+    DIM_TEXT     = foreground(DIM)
+    SEPARATOR    = foreground(MUTED)
+    STAT_VALUE   = foreground(CYAN)
+    ERROR_BADGE  = foreground(WHITE).background(RED).bold(true).padding_left(1).padding_right(1)
+    ERROR_REASON = foreground(RED)
+    TOOL_BADGE   = foreground(DARK_BG).background(CYAN).bold(true).padding_left(1).padding_right(1)
+    TOOL_ARG_KEY = foreground(PURPLE)
+    TOOL_ARG_VAL = foreground(DIM)
+    TOOL_OK      = foreground(DARK_BG).background(CYAN).padding_left(1).padding_right(1)
+    TOOL_FAIL    = foreground(WHITE).background(RED).bold(true).padding_left(1).padding_right(1)
+    TOOL_FRAME   = border_style(:rounded).border_foreground(MUTED).padding_left(1).padding_right(1)
+
+    DIFF_ADDED   = foreground('#4fd6be')
+    DIFF_REMOVED = foreground('#c53b53')
+    DIFF_HUNK    = foreground(CYAN).bold(true)
+    DIFF_CONTEXT = foreground(DIM)
+    TOOL_INLINE  = foreground(DIM)
+  end
+end

data/lib/brute_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BruteCli
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/brute_cli.rb

@@ -1,29 +1,27 @@
 # frozen_string_literal: true
 
-require "brute"
-require "colorize"
-require "emoji"
+require 'brute'
 
-# Optionally load brute_flow if available.
 begin
-  require "brute_flow"
+  require 'brute_flow'
 rescue LoadError
-  # brute_flow is optional for CLI usage
 end
 
-module BruteCLI
-  VERSION = "0.1.1"
+require 'tty-spinner'
+require 'lipgloss'
+require 'glamour'
 
-  CROSS_MARK   = Emoji.find_by_alias("x").raw
-  WARNING_SIGN = Emoji.find_by_alias("warning").raw
+require 'brute_cli/version'
+require 'brute_cli/styles'
+require 'brute_cli/emoji'
+require 'brute_cli/repl'
 
-  # Print a red error message with a cross mark prefix to stderr.
+module BruteCLI
   def self.error(message)
-    $stderr.puts "#{CROSS_MARK} #{message}".red
+    warn "#{Styles::ERROR_BADGE.render('ERROR')} #{Styles::ERROR_REASON.render(message)}"
   end
 
-  # Print a yellow warning to stderr.
   def self.warn(message)
-    $stderr.puts "#{WARNING_SIGN} #{message}".yellow
+    warn Styles::DIM_TEXT.render("warning: #{message}")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute_cli
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Brute Contributors
@@ -38,33 +38,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: colorize
+  name: gemoji
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
-  name: gemoji
+  name: glamour
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: lipgloss
+  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: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: Interactive command-line interface for the Brute coding agent. Supports
   single-prompt, interactive, piped, and session modes.
 executables:
@@ -74,6 +102,9 @@ extra_rdoc_files: []
 files:
 - exe/brute
 - lib/brute_cli.rb
+- lib/brute_cli/emoji.rb
+- lib/brute_cli/repl.rb
+- lib/brute_cli/styles.rb
 - lib/brute_cli/version.rb
 licenses:
 - MIT