brute_cli 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d935729b509640bc8f34ab0250ba7aa4760c66f600e2f8ce4dc74ad2e9e756a
-  data.tar.gz: 7b61d6668976f55bfd334d718b6beb274ffb29a6cd85de1cd4178b7da59e211b
+  metadata.gz: 6f33b8ddd973b65aaa7541e4105c3d87d52f39b22ea9500d613a3b3e193024ac
+  data.tar.gz: 4c02c1b1cf76a2564062a120e235212ea86304366901bb1f574fa95bbecc95b3
 SHA512:
-  metadata.gz: 750488466360f678c3ec34a637980dbb727e64f8b24cd27e86f015503a14b9dedd36da7eca002f905f4e7ddd191b42a9fe2d163bad229c83765d2a26de9f8ecf
-  data.tar.gz: 7917a11383995c907541543b4893f2067ab50ae16389b56054255e866a3f35f7b223e3b37d69c4b4b97876e245c9ef1bb843567598cf05024b497fde2fe43880
+  metadata.gz: 5d0bcbadf66e5d7d0abc8445f89c5bdb153b44eb08effad501f43bf5847d6475b476e5215ad1be4fbdf712af83e947002037e78d7d50462b1b139e79d825a9d9
+  data.tar.gz: e93b600e57fda32304b8ec61c097f82cd4ecc06e659eba08dcbcb6f0c6a74d1d54012fd0907c70ea94aea5e0cb8e3d351c4b51925fb3f015ca60f815f27f0be6

data/exe/brute

@@ -11,10 +11,13 @@ OptionParser.new do |opts|
   opts.on("-d", "--directory DIR", "Working directory") { |d| options[:cwd] = File.expand_path(d) }
   opts.on("-s", "--session ID", "Resume a session")    { |id| options[:session_id] = id }
   opts.on("--list-sessions", "List saved sessions")    { options[:list] = true }
+  opts.on("--theme NAME", "Color theme (#{BruteCLI::THEMES.keys.join(', ')})") { |t| options[:theme] = t }
   opts.on("-v", "--version", "Show version")           { puts "brute #{Brute::VERSION}"; exit }
   opts.on("-h", "--help", "Show help")                 { puts opts; exit }
 end.parse!
 
+BruteCLI.apply_theme!(options[:theme]) if options[:theme]
+
 # ── List sessions ──
 
 if options[:list]

data/lib/brute_cli/bat.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module BruteCLI
+  # Thin wrapper around the `bat` command for syntax-highlighted terminal output.
+  # Provides two rendering modes: one for unified diffs and one for markdown prose.
+  module Bat
+    BAT_BIN = ENV.fetch("BRUTE_BAT_BIN", "bat")
+
+    COMMON_FLAGS = %w[
+      --color=always
+      --paging=never
+    ].freeze
+
+    # Render a unified diff with line numbers and a grid border.
+    #
+    #   BruteCLI::Bat.diff_mode(patch_text, width: 100)
+    #
+    def self.diff_mode(text, width: 80)
+      run(text, language: "diff", style: "numbers,grid", width: width)
+    end
+
+    # Render markdown source with syntax highlighting (headers, bold, fenced
+    # code blocks, etc.) — no extra decorations so it reads like prose.
+    #
+    #   BruteCLI::Bat.markdown_mode(md_text, width: 120)
+    #
+    def self.markdown_mode(text, width: 80)
+      run(text, language: "markdown", style: "plain", width: width)
+    end
+
+    # Returns true if the bat binary is found on PATH.
+    def self.available?
+      return @available if defined?(@available)
+      @available = ENV["PATH"].to_s.split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, BAT_BIN)) }
+    end
+
+    # Low-level: pipe +text+ through bat with arbitrary options.
+    def self.run(text, language:, style:, width: 80)
+      cmd = [
+        BAT_BIN,
+        *COMMON_FLAGS,
+        "--language=#{language}",
+        "--style=#{style}",
+        "--terminal-width=#{width}",
+      ]
+
+      stdout, status = Open3.capture2(*cmd, stdin_data: text)
+
+      if status.success?
+        stdout
+      else
+        # If bat exits non-zero, return the raw text so we never swallow output.
+        text
+      end
+    rescue Errno::ENOENT
+      unless @bat_missing_warned
+        msg = " bat not found — diff syntax highlighting unavailable.\n" \
+              " Install: https://github.com/sharkdp/bat#installation "
+        $stderr.puts msg.colorize(background: :red, color: :white)
+        @bat_missing_warned = true
+      end
+      text
+    end
+  end
+end

data/lib/brute_cli/commands.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module BruteCLI
+  # Registry of slash commands available in the REPL.
+  #
+  # Each command maps to a method name on the REPL instance.
+  # Reline's completion_proc uses +names+ to offer autocomplete suggestions
+  # when the user types "/" at the start of a line.
+  #
+  module Commands
+    Entry = Struct.new(:name, :description, :method_name, keyword_init: true)
+
+    REGISTRY = [
+      Entry.new(name: "/menu",     description: "Open main menu",          method_name: :cmd_menu),
+      Entry.new(name: "/model",    description: "Change model",            method_name: :cmd_model),
+      Entry.new(name: "/provider", description: "Change provider",         method_name: :cmd_provider),
+      Entry.new(name: "/help",     description: "Show available commands", method_name: :cmd_help),
+      Entry.new(name: "/compact",  description: "Compact conversation",    method_name: :cmd_compact),
+      Entry.new(name: "/exit",     description: "Exit brute",             method_name: :cmd_exit),
+    ].freeze
+
+    # All command names, for Reline completion.
+    def self.names
+      REGISTRY.map(&:name)
+    end
+
+    # Does this input look like a slash command?
+    def self.match?(input)
+      input.strip.start_with?("/")
+    end
+
+    # Find the matching Entry for the given input, or nil.
+    def self.find(input)
+      cmd = input.strip.split(/\s+/, 2).first
+      REGISTRY.detect { |e| e.name == cmd }
+    end
+  end
+end

data/lib/brute_cli/emoji.rb

@@ -27,5 +27,7 @@ module BruteCLI
     WRITING    = find('writing_hand')
     ROBOT      = find('robot')
     FOLDER     = find('file_folder')
+    SQUARE     = find('white_large_square')
+    ARROWS     = find('arrows_counterclockwise')
   end
 end

data/lib/brute_cli/fzf_menu.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module BruteCLI
+  # A simple state-machine menu system powered by fzf.
+  #
+  # Each menu is a named bag of choices. Each choice points to either:
+  #   - a Symbol  → the name of the next menu to show
+  #   - nil       → exit the menu loop (Ctrl-C / Escape does the same)
+  #   - anything else → returned to the caller as an "action" value
+  #
+  # The engine is just: while current.is_a?(Symbol) { current = show(menu) }
+  #
+  # Menus can be static (block evaluated at definition time) or dynamic
+  # (block with arity > 0, evaluated fresh each time the menu is shown).
+  #
+  # Titles can be strings or callables (lambdas) for dynamic labels.
+  #
+  # Example:
+  #
+  #   app = BruteCLI::FzfMenu.new do
+  #     menu :main, "Cool Menu" do
+  #       choice "Status",  :status
+  #       choice "Manage",  :manage
+  #       choice "Exit",    nil
+  #     end
+  #
+  #     menu :status, "Status" do
+  #       choice "Back", :main
+  #     end
+  #
+  #     # Dynamic menu — block receives a fresh Menu at render time
+  #     menu :models, -> { "Select Model" } do |m|
+  #       models.each { |id| m.choice(id, [:set_model, id]) }
+  #       m.choice "Back", :main
+  #     end
+  #   end
+  #
+  #   result = app.call          # starts at :main
+  #   result = app.call(:models) # jump straight to :models
+  #
+  class FzfMenu
+    class Menu
+      attr_reader :title, :choices
+
+      def initialize(title = nil)
+        @title   = title
+        @choices = []
+      end
+
+      def resolved_title
+        @title.respond_to?(:call) ? @title.call : @title.to_s
+      end
+
+      def choice(label, target)
+        @choices << [label, target]
+      end
+    end
+
+    def initialize(&definition)
+      @menus   = {}   # name → Menu (static)
+      @dynamic = {}   # name → [title, block] (dynamic, built at render time)
+      instance_eval(&definition) if definition
+    end
+
+    # Define a named menu.
+    #
+    # Static (block with no params — evaluated once at definition):
+    #   menu :main, "Title" do
+    #     choice "Foo", :foo
+    #   end
+    #
+    # Dynamic (block with one param — evaluated each time the menu is shown):
+    #   menu :models, "Title" do |m|
+    #     m.choice "Foo", :foo
+    #   end
+    #
+    def menu(name, title = nil, &block)
+      if block.arity > 0
+        @dynamic[name] = [title, block]
+      else
+        m = Menu.new(title)
+        m.instance_eval(&block)
+        @menus[name] = m
+      end
+    end
+
+    # Run the menu loop starting at the given menu name.
+    # Returns the final non-Symbol value chosen (or nil on escape/Ctrl-C).
+    def call(start = nil)
+      start ||= @menus.keys.first || @dynamic.keys.first
+      current = start
+
+      while current.is_a?(Symbol)
+        current = show(resolve_menu(current))
+      end
+
+      current
+    end
+
+    # All registered menu names (static + dynamic).
+    def menu_names
+      @menus.keys | @dynamic.keys
+    end
+
+    private
+
+    def resolve_menu(name)
+      if @dynamic.key?(name)
+        title, builder = @dynamic[name]
+        m = Menu.new(title)
+        builder.call(m)
+        m
+      else
+        @menus.fetch(name) { raise KeyError, "Unknown menu: #{name.inspect}" }
+      end
+    end
+
+    def show(menu)
+      labels = menu.choices.map(&:first)
+      return nil if labels.empty?
+
+      selected = fzf(labels, prompt: menu.resolved_title)
+      return nil unless selected
+
+      menu.choices.detect { |label, _| label == selected }&.last
+    end
+
+    def fzf(items, prompt:)
+      unless fzf_available?
+        warn "fzf not found in PATH. Install fzf to use interactive menus."
+        return nil
+      end
+
+      cmd = ["fzf", "--prompt=#{prompt} › ", "--height=~#{items.size + 2}", "--reverse", "--no-info"]
+      IO.popen(cmd, "r+") do |io|
+        io.puts items
+        io.close_write
+        io.gets&.strip
+      end
+    rescue Errno::ENOENT
+      warn "fzf not found in PATH. Install fzf to use interactive menus."
+      nil
+    end
+
+    def fzf_available?
+      return @fzf_available if defined?(@fzf_available)
+      @fzf_available = ENV["PATH"].to_s.split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, "fzf")) }
+    end
+  end
+end

data/lib/brute_cli/question_screen.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require "bubbletea"
+require "lipgloss"
+require "bubbles"
+
+module BruteCLI
+  # Full-screen alternate-buffer question form built directly on Bubbletea.
+  #
+  # Opens a new terminal screen (like fzf/vim) via alt_screen: true,
+  # renders select/multi-select forms with Lipgloss styling, handles
+  # keyboard input through Bubbletea's raw-mode event loop (termios),
+  # and restores the original screen when done.
+  class QuestionScreen
+    include Bubbletea::Model
+
+    # ── Styles ──
+
+    ACCENT     = "#FFCC00"
+    DIM        = "#666666"
+    SELECTED   = "#00FF88"
+    HELP_COLOR = "#555555"
+
+    # ── Public API ──
+
+    def self.ask(questions)
+      screen = new(questions)
+      screen.run
+    end
+
+    def initialize(questions)
+      @questions = questions.map { |q| normalize(q) }
+      @question_idx = 0
+      @cursor = 0
+      @selected = Set.new         # for multi-select
+      @answers = []               # collected answers per question
+      @state = :selecting         # :selecting | :other_input | :done | :aborted
+      @text_input = Bubbles::TextInput.new
+      @text_input.prompt = "  > "
+      @text_input.placeholder = "Type your response..."
+      @width = 80
+      @height = 24
+
+      build_styles
+    end
+
+    def run
+      # Release the terminal from reline before bubbletea takes over.
+      # Reline may hold termios flags (cooked mode, echo, signal handling)
+      # that prevent bubbletea's Go FFI from entering raw mode and reading
+      # escape sequences (arrow keys). deprep_terminal restores the
+      # terminal to its pre-reline state so bubbletea gets a clean slate.
+      reline_active = defined?(Reline) && Reline.respond_to?(:deprep_terminal)
+      Reline.deprep_terminal if reline_active
+
+      Bubbletea.run(self, alt_screen: true)
+      @state == :aborted ? @questions.map { [] } : @answers
+    ensure
+      # Re-prep reline so the REPL prompt works when we return.
+      Reline.prep_terminal if reline_active
+    end
+
+    # ── Bubbletea::Model interface ──
+
+    def init
+      [self, nil]
+    end
+
+    def update(message)
+      case message
+      when Bubbletea::WindowSizeMessage
+        @width = message.width
+        @height = message.height
+        [self, nil]
+      when Bubbletea::KeyMessage
+        handle_key(message)
+      else
+        [self, nil]
+      end
+    end
+
+    def view
+      return "" if @state == :done || @state == :aborted
+
+      case @state
+      when :selecting
+        view_selecting
+      when :other_input
+        view_other_input
+      else
+        ""
+      end
+    end
+
+    private
+
+    # ── Key handling ──
+
+    def handle_key(msg)
+      case @state
+      when :selecting
+        handle_selecting_key(msg)
+      when :other_input
+        handle_other_input_key(msg)
+      else
+        [self, nil]
+      end
+    end
+
+    def handle_selecting_key(msg)
+      opts = current_options_with_other
+
+      # Match on KeyMessage type methods first (reliable across Go FFI
+      # versions), then fall back to string name for character keys.
+      if msg.to_s == "ctrl+c" || msg.to_s == "q"
+        @state = :aborted
+        return [self, Bubbletea.quit]
+      end
+
+      if msg.up? || msg.to_s == "k"
+        @cursor = (@cursor - 1) % opts.size
+        return [self, nil]
+      end
+
+      if msg.down? || msg.to_s == "j"
+        @cursor = (@cursor + 1) % opts.size
+        return [self, nil]
+      end
+
+      if msg.space? || msg.to_s == "x"
+        if current_multiple?
+          if @selected.include?(@cursor)
+            @selected.delete(@cursor)
+          else
+            @selected.add(@cursor)
+          end
+        end
+        return [self, nil]
+      end
+
+      if msg.enter?
+        return confirm_selection
+      end
+
+      [self, nil]
+    end
+
+    def handle_other_input_key(msg)
+      if msg.enter?
+        val = @text_input.value.strip
+        current_answer = pending_selected_labels
+        current_answer << val unless val.empty?
+        return finalize_answer(current_answer)
+      end
+
+      if msg.esc?
+        @state = :selecting
+        return [self, nil]
+      end
+
+      if msg.to_s == "ctrl+c"
+        @state = :aborted
+        return [self, Bubbletea.quit]
+      end
+
+      @text_input, cmd = @text_input.update(msg)
+      [self, cmd]
+    end
+
+    # ── Selection logic ──
+
+    def confirm_selection
+      opts = current_options_with_other
+
+      if current_multiple?
+        labels = @selected.sort.map { |i| opts[i] }
+      else
+        labels = [opts[@cursor]]
+      end
+
+      if labels.include?(:other)
+        labels.delete(:other)
+        @state = :other_input
+        @text_input.value = ""
+        @text_input.focus
+        @pending_labels = labels.map { |l| l.is_a?(Hash) ? l[:value] : l }
+        return [self, nil]
+      end
+
+      answer = labels.map { |l| l.is_a?(Hash) ? l[:value] : l.to_s }
+      finalize_answer(answer)
+    end
+
+    def pending_selected_labels
+      (@pending_labels || []).map(&:to_s)
+    end
+
+    def finalize_answer(answer)
+      @answers << answer.map(&:to_s)
+
+      # Advance to next question
+      @question_idx += 1
+      if @question_idx >= @questions.size
+        @state = :done
+        [self, Bubbletea.quit]
+      else
+        @cursor = 0
+        @selected = Set.new
+        @state = :selecting
+        [self, nil]
+      end
+    end
+
+    # ── View rendering ──
+
+    def view_selecting
+      q = current_question
+      opts = current_options_with_other
+      lines = []
+
+      # Header
+      lines << ""
+      lines << @header_style.render("  #{q['header'] || 'Question'}")
+      lines << ""
+
+      # Question text
+      lines << @question_style.render("  #{q['question']}")
+      lines << ""
+
+      # Options
+      opts.each_with_index do |opt, i|
+        is_cursor = i == @cursor
+        label = opt == :other ? "Other (custom answer)" : "#{opt[:label]} -- #{opt[:desc]}"
+
+        if current_multiple?
+          check = @selected.include?(i) ? "[x]" : "[ ]"
+          prefix = is_cursor ? " > #{check} " : "   #{check} "
+        else
+          prefix = is_cursor ? "  > " : "    "
+        end
+
+        text = "#{prefix}#{label}"
+        lines << if is_cursor
+          @cursor_style.render(text)
+        else
+          @option_style.render(text)
+        end
+      end
+
+      # Help bar
+      lines << ""
+      help = if current_multiple?
+        "  up/down navigate | space toggle | enter confirm | q quit"
+      else
+        "  up/down navigate | enter select | q quit"
+      end
+      lines << @help_style.render(help)
+
+      # Progress
+      if @questions.size > 1
+        lines << @help_style.render("  question #{@question_idx + 1}/#{@questions.size}")
+      end
+
+      content = lines.join("\n")
+
+      # Center vertically
+      content_lines = content.split("\n").size
+      pad = [(@height - content_lines) / 2, 1].max
+      ("\n" * pad) + content
+    end
+
+    def view_other_input
+      q = current_question
+      lines = []
+
+      lines << ""
+      lines << @header_style.render("  #{q['header'] || 'Question'}")
+      lines << ""
+      lines << @question_style.render("  Your answer:")
+      lines << ""
+      lines << "  #{@text_input.view}"
+      lines << ""
+      lines << @help_style.render("  enter submit | esc back | ctrl+c quit")
+
+      content = lines.join("\n")
+      content_lines = content.split("\n").size
+      pad = [(@height - content_lines) / 2, 1].max
+      ("\n" * pad) + content
+    end
+
+    # ── Helpers ──
+
+    def normalize(q)
+      q.transform_keys(&:to_s).tap do |h|
+        h["options"] = (h["options"] || []).map { |o| o.transform_keys(&:to_s) }
+      end
+    end
+
+    def current_question
+      @questions[@question_idx]
+    end
+
+    def current_multiple?
+      current_question["multiple"]
+    end
+
+    def current_options_with_other
+      opts = current_question["options"].map do |o|
+        { label: o["label"], desc: o["description"], value: o["label"] }
+      end
+      opts << :other
+      opts
+    end
+
+    def build_styles
+      @header_style = Lipgloss::Style.new
+        .bold(true)
+        .foreground(ACCENT)
+
+      @question_style = Lipgloss::Style.new
+        .bold(true)
+
+      @cursor_style = Lipgloss::Style.new
+        .foreground(SELECTED)
+        .bold(true)
+
+      @option_style = Lipgloss::Style.new
+
+      @help_style = Lipgloss::Style.new
+        .foreground(HELP_COLOR)
+        .italic(true)
+    end
+  end
+end