brute_cli 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d25022bbf25ee324c11c0517e9186a65e13b4838d33dde2dc4250b9803783631
-  data.tar.gz: 1831cd59d1263dd3099854dc58cc5ecfb73f1448ac180cac73271ab836541fb6
+  metadata.gz: 7faec8b9ffa2108882a1deb9e4eeb1a5747ce41ed8d6afb15414817de129fcca
+  data.tar.gz: 0ffc0437131b4244123eed92bb9850062af2f785ff7dcaa873ed8a4d6ace1310
 SHA512:
-  metadata.gz: c03d4a80b353b12ab4e28cdddd4aed2c4a3645cbbb8f9d96d9636d6e889873f509ec3ca8dc813013ebbed1f8d38bdb4c6f41cc554998a0fcbfbd27f167e6e5eb
-  data.tar.gz: e3dc1f1741c4bbb83a406164034788564ce6d5a1c45a286702b2a36470997789ed0a41632d02c467b12ac88dd4f279b4f613b6bddeb4a9aecd49b3de58b540a0
+  metadata.gz: 60607a8e7d25dc568a9e29b267985f524bd7f3d5f7b9f791e5a2c51641813f40dfb0f0e5f8a3cd0a43c1d216d33f13782460ceed40f30b5520fafc1b333fd572
+  data.tar.gz: a89c64d5621373a349f1f8d27d5ab8d8f2add3f409e69d9caaad43d201171db22ae9b7db2a00cae8aa485a5613466251d791765331067ec5301ff4e92fe0d487

data/exe/brute

@@ -18,43 +18,28 @@ end.parse!
 
 BruteCLI.apply_theme!(options[:theme]) if options[:theme]
 
-# ── List sessions ──
-
 if options[:list]
-  sessions = Brute::Session.list
-  if sessions.empty?
-    puts "No saved sessions."
-  else
-    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}"
+  Brute::Session.list.tap do |sessions|
+    if sessions.empty?
+      puts "No saved sessions."
+    else
+      puts "Not implemented"
     end
   end
+
   exit
 end
 
-# ── Collect prompt ──
-
-prompt = ARGV.join(" ")
-prompt = $stdin.read.strip if prompt.empty? && !$stdin.tty?
-
-# ── Run ──
-
-repl = BruteCLI::REPL.new(options)
-
 begin
+  prompt = ARGV.join(" ")
+  prompt = $stdin.read.strip if prompt.empty? && !$stdin.tty?
+
   if prompt.empty?
     # Interactive mode
-    repl.run_interactive
+    BruteCLI::REPL.new(options).run
   else
     # Single prompt mode
-    repl.run_once(prompt)
+    BruteCLI::Execution.new(options).run(prompt)
     puts
   end
 rescue Interrupt

data/lib/brute_cli/buffer_output/error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "json"
+require "brute_cli/styles"
+require "brute_cli/emoji"
+
+module BruteCLI
+  module BufferOutput
+    # Renderable error badge with pretty-printed message.
+    #
+    #   puts BufferOutput::Error.new(err)
+    #   # => "✖ ERROR"
+    #   # => "\"Something went wrong\""
+    #
+    class Error
+      def initialize(err)
+        @err = err
+      end
+
+      def to_s
+        header = "#{Emoji::CROSS} #{"ERROR".colorize(ERROR_BG)}"
+        parsed = JSON.parse(@err.message) rescue @err.message
+        "#{header}\n#{parsed.pretty_inspect.chomp}"
+      end
+    end
+  end
+end

data/lib/brute_cli/buffer_output/model_line.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "brute_cli/styles"
+
+module BruteCLI
+  module BufferOutput
+    # Renderable provider / model / agent status line.
+    #
+    #   puts BufferOutput::ModelLine.new(
+    #     provider_name: "anthropic",
+    #     model_short:   "3.5-sonnet",
+    #     current_agent: "build"
+    #   )
+    #   # => "anthropic 3.5-sonnet · agent build"
+    #
+    class ModelLine
+      def initialize(provider_name:, model_short:, current_agent:)
+        @provider_name = provider_name
+        @model_short = model_short
+        @current_agent = current_agent
+      end
+
+      def to_s
+        parts = []
+        parts << stat_span(@provider_name, @model_short) if @provider_name && @model_short
+        parts << stat_span("agent", @current_agent)
+        parts.join(" \u00b7 ".colorize(DIM))
+      end
+
+      private
+
+      def stat_span(label, value)
+        "#{label} ".colorize(DIM) + value.to_s.colorize(ACCENT)
+      end
+    end
+  end
+end

data/lib/brute_cli/buffer_output/separator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "brute_cli/styles"
+
+module BruteCLI
+  module BufferOutput
+    # Renderable horizontal rule for terminal output.
+    #
+    #   puts BufferOutput::Separator.new(width: 80)
+    #   puts BufferOutput::Separator.new(width: 80, thick: true)
+    #
+    class Separator
+      def initialize(width:, thick: false)
+        @width = width
+        @thick = thick
+      end
+
+      def to_s
+        char = @thick ? "\u2550" : "\u2500"
+        (char * [@width, 40].max).colorize(DIM)
+      end
+    end
+  end
+end

data/lib/brute_cli/buffer_output/stats_bar.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "brute_cli/styles"
+
+module BruteCLI
+  module BufferOutput
+    # Renderable token / timing / tool-call metrics line.
+    #
+    #   puts BufferOutput::StatsBar.new(metadata, width: 80)
+    #   # => "tokens 150 | in 100 | out 50 | time 45.5s | tools 5"
+    #
+    class StatsBar
+      def initialize(metadata, width:)
+        @metadata = metadata
+        @width = width
+      end
+
+      def to_s
+        tokens = @metadata[:tokens] || {}
+        timing = @metadata[:timing] || {}
+        tool_calls = @metadata[:tool_calls] || 0
+        sep = " | ".colorize(DIM)
+        parts = []
+        parts << stat_span("tokens", (tokens[:total] || 0).to_s)
+        parts << stat_span("in", (tokens[:total_input] || 0).to_s)
+        parts << stat_span("out", (tokens[:total_output] || 0).to_s)
+        parts << stat_span("time", format_time(timing[:total_elapsed] || 0))
+        parts << stat_span("tools", tool_calls.to_s) if tool_calls > 0
+        parts.join(sep)
+      end
+
+      private
+
+      def stat_span(label, value)
+        "#{label} ".colorize(DIM) + value.to_s.colorize(ACCENT)
+      end
+
+      def format_time(s)
+        s < 60 ? "#{s.round(1)}s" : "#{(s / 60).floor}m#{(s % 60).round(1)}s"
+      end
+    end
+  end
+end

data/lib/brute_cli/buffer_output.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "brute_cli/buffer_output/separator"
+require "brute_cli/buffer_output/stats_bar"
+require "brute_cli/buffer_output/error"
+require "brute_cli/buffer_output/model_line"
+
+module BruteCLI
+  module BufferOutput
+  end
+end

data/lib/brute_cli/configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BruteCLI
+  Configuration = Struct.new(:spinner) do
+    def initialize
+      super
+      self.spinner = BruteCLI::Spinner::Nyan
+    end
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+end

data/lib/brute_cli/emoji.rb

@@ -4,30 +4,33 @@ require 'gemoji'
 
 module BruteCLI
   module Emoji
-    def self.find(name)
+    def self.💩(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')
-    SQUARE     = find('white_large_square')
-    ARROWS     = find('arrows_counterclockwise')
+    # brutal mate...
+
+    EYES        = 💩 'eyes'
+    PENCIL      = 💩 'pencil2'
+    PAGE        = 💩 'page_facing_up'
+    COMPUTER    = 💩 'computer'
+    SPARKLES    = 💩 'sparkles'
+    GLOBE       = 💩 'globe_with_meridians'
+    WASTEBASKET = 💩 'wastebasket'
+    REWIND      = 💩 'rewind'
+    DIAMOND     = 💩 'diamond_shape_with_a_dot_inside'
+    GEAR        = 💩 'gear'
+    MAG         = 💩 'mag'
+    HAMMER      = 💩 'hammer_and_wrench'
+    PACKAGE     = 💩 'package'
+    CLIPBOARD   = 💩 'clipboard'
+    CHECK       = 💩 'white_check_mark'
+    CROSS       = 💩 'x'
+    WRITING     = 💩 'writing_hand'
+    ROBOT       = 💩 'robot'
+    FOLDER      = 💩 'file_folder'
+    SQUARE      = 💩 'white_large_square'
+    ARROWS      = 💩 'arrows_counterclockwise'
+    SMOKE       = 💩 'dash'
   end
 end

data/lib/brute_cli/execution.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "logger"
+require "io/console"
+require "json"
+require "pp"
+require "brute_cli/styles"
+require "brute_cli/phase"
+require "brute_cli/tool_output"
+
+module BruteCLI
+  # Execution encapsulates running a single prompt (or repeated prompts) against
+  # an agent, streaming output to the terminal.  It owns the agent lifecycle,
+  # streaming callbacks, spinner, and stats rendering.
+  #
+  # Use directly for non-interactive (pipe / single-prompt) mode:
+  #
+  #   BruteCLI::Execution.new(options).run(prompt)
+  #
+  # Or let BruteCLI::REPL wrap it for interactive use.
+  class Execution
+    AGENTS = %w[build plan bash ruby python nix].freeze
+
+    SAVE_CURSOR    = "\e7"
+    RESTORE_CURSOR = "\e8"
+    CLEAR_TO_END   = "\e[J"
+
+    # Shell-mode agents: agent name -> shell interpreter (model name).
+    # These agents use the Shell provider instead of the current LLM provider.
+    SHELL_AGENTS = {
+      "bash"   => "bash",
+      "ruby"   => "ruby",
+      "python" => "python",
+      "nix"    => "nix",
+    }.freeze
+
+    attr_reader :current_agent, :provider_name, :model_name
+    attr_accessor :agent
+    attr_writer :selected_model, :current_agent
+
+    def initialize(options = {})
+      @options = options
+      @current_agent = AGENTS.first
+      @agent = nil
+      @session = nil
+      @selected_model = nil    # user-chosen model override (nil = provider default)
+      @width = TTY::Screen.width
+      @streamer = StreamFormatter.new(width: @width)
+      spinner_class = options[:spinner] || BruteCLI.config.spinner
+      @spinner = spinner_class.new
+      @last_output = nil  # :separator, :content, or :tool — used to deduplicate separators
+      @current_phase = nil
+    end
+
+    # Run a single prompt against the agent.  This is the primary public API.
+    def run(prompt)
+      ensure_agent!
+      execute(prompt)
+    end
+
+    def execute(prompt)
+      @current_phase = nil
+      @streamer.reset
+      @last_output = nil
+
+      start_spinner
+
+      begin
+        @agent.run(prompt)
+      rescue Interrupt
+        stop_spinner
+        flush_content
+        puts "Aborted.".colorize(DIM)
+        print_stats_bar
+        return
+      rescue => e
+        stop_spinner
+        flush_content
+        print_error(e)
+        print_stats_bar
+        return
+      end
+
+      stop_spinner
+      flush_content
+      print_stats_bar
+    end
+
+
+    # ── Provider ──
+
+    def resolve_provider_info
+      if (shell_model = SHELL_AGENTS[@current_agent])
+        @provider_name = "shell"
+        @model_name = shell_model
+      else
+        provider = Brute.provider rescue nil
+        @provider_name = provider&.name&.to_s
+        @model_name = @selected_model || provider&.default_model&.to_s
+      end
+    end
+
+    def model_short
+      @model_name&.sub(/^claude-/, "")&.sub(/-\d{8}$/, "") || @model_name
+    end
+
+    # ── Agent ──
+
+    def ensure_session!
+      @session ||= Brute::Session.new(id: @options[:session_id])
+    end
+
+    def ensure_agent!
+      return if @agent
+
+      ensure_session!
+
+      @agent = Brute.agent(
+        cwd: @options[:cwd] || Dir.pwd,
+        model: @selected_model,
+        agent_name: @current_agent,
+        session: @session,
+        logger: Logger.new(File::NULL),
+        on_content:          method(:on_content),
+        on_reasoning:        method(:on_reasoning),
+        on_tool_call_start:  method(:on_tool_call_start),
+        on_tool_result:      method(:on_tool_result),
+        # on_question: disabled until bubbletea terminal integration is fixed
+      )
+      @session.restore(@agent.context) if @options[:session_id]
+    end
+
+    def detect_width
+      TTY::Screen.width
+    end
+
+    private
+
+      # ── Spinner ──
+
+      def start_spinner
+        stop_spinner
+
+        unless @last_output == :separator
+          puts BufferOutput::Separator.new(width: @width)
+          @last_output = :separator
+        end
+
+        @spinner.start
+      end
+
+      def stop_spinner
+        if @spinner.spinning?
+          @spinner.stop
+        end
+      end
+
+      # ── Callbacks ──
+      #
+      # All callbacks fire sequentially on the same thread — no
+      # synchronization needed.  The orchestrator guarantees:
+      #
+      #   on_content* → on_tool_call_start → on_tool_result* → (repeat)
+      #
+
+      def on_content(text)
+        stop_spinner
+        unless @current_phase.is_a?(Phase::ContentPhase)
+          puts BufferOutput::Separator.new(width: @width) unless @last_output == :separator
+          @current_phase = Phase::ContentPhase.new(@streamer)
+        end
+        @current_phase.append(text)
+        @last_output = :content
+      end
+
+      def on_reasoning(_text); end
+
+      # Receives the full batch of tool calls for this LLM turn.
+      # Renders all tool call headers upfront.
+      def on_tool_call_start(calls)
+        stop_spinner
+        flush_content
+
+        @current_phase = Phase::ToolPhase.new(calls)
+
+        puts BufferOutput::Separator.new(width: @width) unless @last_output == :separator
+        print SAVE_CURSOR
+        render_tool_phase
+        @last_output = :tool
+
+        start_spinner
+      end
+
+      # Fires once per tool as each completes.
+      # Re-renders the entire tool phase block.
+      def on_tool_result(name, result)
+        stop_spinner
+
+        if @current_phase.is_a?(Phase::ToolPhase)
+          @current_phase.resolve(name, result)
+
+          print RESTORE_CURSOR
+          print CLEAR_TO_END
+          render_tool_phase
+          @last_output = :tool
+          start_spinner
+        end
+      end
+
+      # TODO: Interactive question forms are disabled while the bubbletea
+      # terminal integration is being worked on. For now, auto-select the
+      # first option for each question so the agent can continue.
+      def on_question(questions, reply_queue)
+        answers = questions.map do |q|
+          q = q.respond_to?(:transform_keys) ? q.transform_keys(&:to_s) : q
+          options = (q["options"] || []).map { |o| o.respond_to?(:transform_keys) ? o.transform_keys(&:to_s) : o }
+          first = options.first
+          first ? [first["label"].to_s] : []
+        end
+
+        reply_queue.push(answers)
+      end
+
+      # ── Output ──
+
+      def flush_content
+        if @current_phase.is_a?(Phase::ContentPhase)
+          @current_phase.finish
+          @last_output = :content unless @current_phase.empty?
+        end
+      end
+
+      # Render every tool call in the current ToolPhase.
+      # Resolved calls show header + body + error; pending calls show header only.
+      def render_tool_phase
+        @current_phase.tool_calls.each do |call|
+          puts ToolOutput.for(call, width: @width)
+        end
+      end
+
+      def render_markdown(text)
+        BruteCLI::Bat.markdown_mode(text.strip, width: @width)
+      end
+
+      # ── Stats ──
+
+      def print_stats_bar
+        metadata = @agent&.env&.dig(:metadata) || {}
+        puts BufferOutput::Separator.new(width: @width) unless @last_output == :separator
+        puts BufferOutput::StatsBar.new(metadata, width: @width)
+        puts BufferOutput::Separator.new(width: @width, thick: true)
+      end
+
+      # ── Error ──
+
+      def print_error(err)
+        puts BufferOutput::Error.new(err)
+      end
+    end
+end

data/lib/brute_cli/phase/content_phase.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BruteCLI
+  module Phase
+    # Accumulates streamed text tokens. Owns a StreamFormatter for
+    # incremental terminal output.
+    class ContentPhase
+      attr_reader :buf
+
+      def initialize(streamer)
+        @streamer = streamer
+        @buf = +""
+      end
+
+      def append(text)
+        @buf << text
+        @streamer << text
+      end
+
+      def finish
+        return if @buf.strip.empty?
+        @streamer.flush
+        @buf = +""
+      end
+
+      def empty? = @buf.strip.empty?
+    end
+  end
+end

data/lib/brute_cli/phase/tool_call.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BruteCLI
+  module Phase
+    # Pure data object representing a single tool invocation.
+    # Holds name, arguments, and (once resolved) the result.
+    class ToolCall
+      attr_reader :name, :arguments
+      attr_accessor :result
+
+      def initialize(name:, arguments:)
+        @name = name
+        @arguments = arguments || {}
+        @result = nil
+      end
+
+      def resolved? = !@result.nil?
+      def pending?  = @result.nil?
+    end
+  end
+end

data/lib/brute_cli/phase/tool_phase.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BruteCLI
+  module Phase
+    # Holds a batch of ToolCall objects for a single LLM turn.
+    # The orchestrator fires on_tool_call_start with the full batch,
+    # then on_tool_result per-tool as each completes.
+    class ToolPhase
+      attr_reader :tool_calls
+
+      def initialize(calls)
+        @tool_calls = calls.map do |c|
+          ToolCall.new(name: c[:name], arguments: c[:arguments])
+        end
+      end
+
+      # Resolve the first unresolved call matching +name+.
+      # Returns the ToolCall, or nil if no match.
+      def resolve(name, result)
+        call = @tool_calls.find { |c| c.name == name && c.pending? }
+        return unless call
+        call.result = result
+        call
+      end
+
+      def finished? = @tool_calls.all?(&:resolved?)
+    end
+  end
+end

data/lib/brute_cli/phase.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "brute_cli/phase/tool_call"
+require "brute_cli/phase/tool_phase"
+require "brute_cli/phase/content_phase"
+
+module BruteCLI
+  module Phase
+  end
+end