llm.rb 12.6.0 → 13.1.0

data/lib/llm/repl/input.rb

@@ -12,16 +12,30 @@ class LLM::Repl
       F: Curses::KEY_CTRL_F,
       K: Curses::KEY_CTRL_K,
       Y: Curses::KEY_CTRL_Y,
-      D: Curses::KEY_CTRL_D
+      D: Curses::KEY_CTRL_D,
+      P: Curses::KEY_CTRL_P,
+      N: Curses::KEY_CTRL_N
     }
 
+    ##
+    # This hash tracks how many times a given key
+    # was pressed repeatedly without being
+    # interrupted by another key. The previous key
+    # is reset to 0 when a different key is pressed.
+    REPEATS = {}
+    REPEATS.default = 0
+
     UP        = Curses::Key::UP
     DOWN      = Curses::Key::DOWN
     LEFT      = Curses::Key::LEFT
     RIGHT     = Curses::Key::RIGHT
+    PGUP      = Curses::KEY_PPAGE
+    PGDOWN    = Curses::KEY_NPAGE
+
+    TAB       = 9
     ESC       = 27
-    ENTER     = [Curses::Key::ENTER, 10, 13]
-    BACKSPACE = [Curses::Key::BACKSPACE, 127]
+    ENTER     = 10
+    BACKSPACE = 127
 
     ##
     # Threshold in seconds. If characters arrive faster than
@@ -35,21 +49,24 @@ class LLM::Repl
     attr_reader :buffer
 
     ##
-    # @param [Boolean] bool
+    # @param [Boolean] value
     # @return [void]
     attr_writer :paste
 
     ##
-    # @param [LLM::Agent] agent
+    # @param [LLM::Repl] repl
     # @return [LLM::Repl::Input]
-    def initialize(agent, options = {})
-      @agent = agent
-      @provider = agent.llm.name
+    def initialize(repl, options = {})
+      @name = repl.name
+      @agent = repl.agent
+      @provider = @agent.llm.name
       @buffer = +""
       @cursor = 0
       @scroll = 0
       @height = options.fetch(:height, 3)
       @last_char_at = nil
+      @memory = @agent.messages.select(&:user?).map(&:content)
+      @walker = Walker.new(@memory)
       @paste = false
     end
 
@@ -59,8 +76,28 @@ class LLM::Repl
     # @return [Symbol, nil]
     def on_char(window, char, now)
       is_paste = lambda { @last_char_at and (now - @last_char_at) < PASTE_THRESHOLD }
-      if ESC == char
+      if char and @char != char
+        REPEATS[@char] = 0
+      end
+      if PGUP == char
+        (window.rows - 3).times { window.scroll_up }
+        :pageup
+      elsif PGDOWN == char
+        (window.rows - 3).times { window.scroll_down }
+        :pagedown
+      elsif TAB == char
+        autocomplete
+        :tab
+      elsif ESC == char
         @agent.cancel!
+      elsif CTRL[:P] == char
+        @buffer = @walker.prev.dup
+        @cursor = @buffer.size
+        :ctrl_p
+      elsif CTRL[:N] == char
+        @buffer = @walker.next.dup
+        @cursor = @buffer.size
+        :ctrl_n
       elsif CTRL[:D] == char
         delete
         :ctrl_d
@@ -85,14 +122,16 @@ class LLM::Repl
       elsif char == RIGHT
         move_right
         :right
-      elsif BACKSPACE.include?(char)
+      elsif BACKSPACE == char
         backspace
         :backspace
-      elsif ENTER.include?(char)
+      elsif ENTER == char
         if @paste = is_paste.()
           insert("\n")
           :char
         else
+          @memory.push(@buffer.dup)
+          @walker.cursor = @memory.size
           :submit
         end
       elsif char == UP
@@ -108,19 +147,23 @@ class LLM::Repl
         nil
       end
     ensure
-      @last_char_at = now if char
+      if char
+        REPEATS[char] += 1
+        @last_char_at = now
+        @char = char
+      end
     end
 
     ##
     # @return [String]
     def to_s
-      "#{@provider}> #{@buffer}"
+      "#{prompt}#{@buffer}"
     end
 
     ##
     # @return [Integer]
     def cursor
-      prompt.length + @cursor
+      prompt.size + @cursor
     end
 
     ##
@@ -182,6 +225,28 @@ class LLM::Repl
       @cursor = [0, @cursor + 1].max
     end
 
+    ##
+    # @return [void]
+    def autocomplete
+      return unless @buffer[0] == "/"
+      ##
+      # This method implements a simple autocomplete
+      # that supports cycling through all known
+      # commands. When given tab in quick succession,
+      # we cycle to the nearest neighbour for the last
+      # full match. However, it's not based on similarity,
+      # it's just the next element in the array.
+      keys = LLM::Command.registry.keys
+      candidates = LLM::Command.complete(@buffer)
+      if REPEATS[TAB] >= 1
+        candidate = keys[keys.index(candidates[0]) + 1] || keys[0]
+      else
+        candidate = candidates[0]
+      end
+      @buffer = "/#{candidate}"
+      @cursor = @buffer.size
+    end
+
     ##
     # @return [void]
     def kill
@@ -238,7 +303,7 @@ class LLM::Repl
     end
 
     def prompt
-      "#{@provider}> "
+      "#{@provider}(#{@name})> "
     end
 
     def insert(char)

data/lib/llm/repl/markdown/table.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class LLM::Repl::Markdown
+  ##
+  # Renders Kramdown `:table` nodes as aligned columns.
+  module Table
+    ##
+    # @api private
+    Node = LLM::Repl::Node
+    private_constant :Node
+
+    ##
+    # Renders a table node by collecting all cells first to
+    # compute column widths, then emitting each row with
+    # padded text.
+    def walk_table(node, attrs)
+      rows = collect_rows(node, attrs)
+      return if rows.empty?
+      widths = column_widths(rows)
+      rows.each do |row|
+        emit("| ", attrs)
+        row.each_with_index do |chunks, i|
+          width = widths[i]
+          chunks.each { |c| emit(c[:text].ljust(width), c[:attrs]) }
+          emit(" | ", attrs) unless i == row.size - 1
+        end
+        emit(" |", attrs)
+        emit("\n", attrs)
+      end
+      emit("\n", attrs)
+    end
+
+    private
+
+    def collect_rows(node, attrs)
+      node.children.each_with_object([]) do |section, rows|
+        next unless [:thead, :tbody].include?(section.type)
+        section.children.each do |tr|
+          next unless tr.type == :tr
+          cells = tr.children.filter_map do |td|
+            next unless [:td, :th].include?(td.type)
+            collect_chunks(td, attrs)
+          end
+          rows << cells
+        end
+      end
+    end
+
+    def collect_chunks(node, attrs)
+      [].tap do |chunks|
+        walk_collect(node, attrs, chunks)
+      end
+    end
+
+    def walk_collect(node, attrs, chunks)
+      case node.type
+      when :text
+        chunks << Node.new(node.value.to_s, attrs)
+      when :strong
+        node.children.each { walk_collect(_1, Curses::A_BOLD, chunks) }
+      when :em
+        node.children.each { walk_collect(_1, Curses::A_UNDERLINE, chunks) }
+      when :codespan
+        chunks << Node.new(node.value, Curses::A_REVERSE)
+      when :a
+        node.children.each { walk_collect(_1, Curses::A_UNDERLINE, chunks) }
+      else
+        node.children.each { walk_collect(_1, attrs, chunks) }
+      end
+    end
+
+    def column_widths(rows)
+      return [] if rows.empty?
+      cols = rows.first.size
+      (0...cols).map do |i|
+        rows.map { |r| r[i].map { _1[:text] }.join.length }.max
+      end
+    end
+  end
+end

data/lib/llm/repl/markdown.rb

@@ -8,16 +8,21 @@ class LLM::Repl
   # of text, and also optional style information for
   # that text (eg bold, underscore, ...)
   class Markdown
+    require_relative "markdown/table"
+    include Table
+
     ##
     # @param [String] text
+    # @param [Integer] width
     # @return [LLM::Repl::Markdown]
-    def initialize(text)
+    def initialize(text, width)
       @doc = Kramdown::Document.new(text)
+      @width = width
       @ast = []
     end
 
     ##
-    # @return [Array<Hash>]
+    # @return [Array<Node>]
     def ast
       @ast.tap do
         ##
@@ -73,13 +78,38 @@ class LLM::Repl
         emit("\n\n", attrs)
       when :br
         emit("\n", attrs)
+      when :ul, :ol
+        node.children.each { walk(_1, attrs) }
+      when :li
+        node.children.each { walk(_1, attrs) }
+      when :table
+        walk_table(node, attrs)
+      when :thead, :tbody
+        node.children.each { walk(_1, attrs) }
+      when :tr
+        emit("| ", attrs)
+        node.children.each { walk(_1, attrs) }
+        emit("\n", attrs)
+      when :td, :th
+        node.children.each { walk(_1, attrs) }
+        emit(" | ", attrs)
+      when :blockquote
+        emit("> ", attrs)
+        node.children.each { walk(_1, attrs) }
+      when :hr
+        emit("─" * @width, attrs)
+        emit("\n\n", attrs)
+      when :a
+        node.children.each { walk(_1, Curses::A_UNDERLINE) }
+      when :img
+        emit("[image: #{node.attr["alt"]}]", attrs)
       else
         node.children.each { walk(_1, attrs) }
       end
     end
 
     def emit(text, attrs)
-      @ast.push({text: text.to_s, attrs:}.compact)
+      @ast.push(Node.new(text.to_s, attrs))
     end
   end
 end

data/lib/llm/repl/node.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Node LLM::Repl::Node} class wraps a piece
+  # of text and optional curses attributes.
+  # @api private
+  class Node
+    ##
+    # @return [String]
+    attr_reader :text
+
+    ##
+    # @return [Integer, nil]
+    attr_reader :attrs
+
+    ##
+    # @param [String] text
+    # @param [Integer, nil] attrs
+    # @return [LLM::Repl::Node]
+    def initialize(text, attrs = nil)
+      @text = text.to_s
+      @attrs = attrs
+    end
+
+    ##
+    # Hash-like lookup.
+    # @param [Symbol] key
+    # @return [String, Integer, nil]
+    def [](key)
+      case key
+      when :text then @text
+      when :attrs then @attrs
+      end
+    end
+  end
+end

data/lib/llm/repl/status.rb

@@ -7,11 +7,11 @@ class LLM::Repl
   # @api private
   class Status
     ##
-    # @param [String, Symbol] provider
+    # @param [LLM::Repl] repl
     # @return [LLM::Repl::Status]
-    def initialize(agent)
-      @agent = agent
-      @provider = agent.llm.name
+    def initialize(repl)
+      @agent = repl.agent
+      @provider = @agent.llm.name
       @text = "idle"
     end
 

data/lib/llm/repl/stream.rb

@@ -42,9 +42,9 @@ class LLM::Repl
     end
 
     ##
-    # Empty the accumulated buffer
+    # Clear the accumulated buffer
     # @return [void]
-    def empty!
+    def clear
       @buffer.clear
     end
 
@@ -60,9 +60,16 @@ class LLM::Repl
     # @param [Integer] max
     # @return [String]
     def format_args(tool, max: 50)
-      args = tool.arguments
-      pairs = args.to_h.map { "#{_1}: #{format_value(_2)}" }
-      result = pairs.join(", ")
+      ##
+      # 'tool.arguments' might be returned
+      # (by the model) in a different order
+      # than the tool definition - this code
+      # handles re-sorting.
+      args   = tool.arguments
+      props  = tool.params.properties.keys
+      props  = props.sort_by { tool.params.properties[_1].index }
+      props  = props.filter_map { args[_1] ? "#{_1}: #{format_value(args[_1])}" : nil }
+      result = props.join(", ")
       result.size > max ? "#{result[0...max - 1]}…" : result
     end
 

data/lib/llm/repl/walker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # Walks through an array from the last element backward,
+  # one step at a time. {#next} moves forward toward the end.
+  # Both methods clamp at the array boundaries.
+  class Walker
+    ##
+    # Sets the cursor position
+    attr_writer :cursor
+
+    ##
+    # @param [Array] items
+    def initialize(items)
+      @items = items
+      @cursor = items.size
+    end
+
+    ##
+    # @return [Object, nil]
+    def next
+      if @items.empty?
+        nil
+      elsif @cursor >= @items.size - 1
+        @items[@cursor]
+      else
+        @cursor += 1
+        @items[@cursor]
+      end
+    end
+
+    ##
+    # @return [Object, nil]
+    def prev
+      if @items.empty?
+        nil
+      elsif @cursor <= 0
+        @items[@cursor]
+      else
+        @cursor -= 1
+        @items[@cursor]
+      end
+    end
+  end
+end

data/lib/llm/repl/window.rb

@@ -11,22 +11,21 @@ class LLM::Repl
     attr_reader :status
 
     ##
-    # @return [LLM::Repl::Transcript]
-    attr_reader :transcript
+    # @return [LLM::Repl::Buffer]
+    attr_reader :buffer
 
     ##
     # @return [LLM::Repl::Input]
     attr_reader :input
 
     ##
-    # @param [LLM::Repl::Status] status
-    # @param [LLM::Repl::Transcript] transcript
-    # @param [LLM::Repl::Input] input
+    # @param [LLM::Repl] repl
+    #  A read-eval-print loop.
     # @return [LLM::Repl::Window]
-    def initialize(status, transcript, input)
-      @status = status
-      @transcript = transcript
-      @input = input
+    def initialize(repl)
+      @status = repl.status
+      @buffer = repl.buffer
+      @input  = repl.input
     end
 
     ##
@@ -48,7 +47,7 @@ class LLM::Repl
     def redraw
       draw_status(offset: input.height + 1)
       draw_divider(offset: 5)
-      draw_transcript(offset: 0)
+      draw_buffer(offset: 0)
       draw_input
       Curses.refresh
     end
@@ -86,23 +85,42 @@ class LLM::Repl
     ##
     # @return [void]
     def scroll_up
-      transcript.scroll_up(rows)
+      buffer.scroll_up(rows)
     end
 
     ##
     # @return [void]
     def scroll_down
-      transcript.scroll_down
+      buffer.scroll_down
     end
 
     ##
     # @return [void]
     def scroll_to_bottom
-      transcript.scroll_to_bottom
+      buffer.scroll_to_bottom
     end
 
     private
 
+    def draw_buffer(offset:)
+      rows = buffer.visible(self.rows)
+      rows.each.with_index(offset) do |row, index|
+        Curses.setpos(index, 0)
+        Curses.clrtoeol
+        row.each do |chunk|
+          text, attrs = chunk.text, chunk.attrs
+          Curses.attron(attrs) if attrs
+          Curses.addstr(text)
+          Curses.attroff(attrs) if attrs
+        end
+      end
+      last_drawn = offset + rows.size
+      (last_drawn...self.rows).each do |line|
+        Curses.setpos(line, 0)
+        Curses.clrtoeol
+      end
+    end
+
     def draw_status(offset:)
       Curses.setpos(Curses.lines - offset, 0)
       Curses.clrtoeol
@@ -132,25 +150,6 @@ class LLM::Repl
       Curses.setpos((Curses.lines - input.height) + line, col)
     end
 
-    def draw_transcript(offset:)
-      rows = transcript.visible(self.rows)
-      rows.each.with_index(offset) do |row, index|
-        Curses.setpos(index, 0)
-        Curses.clrtoeol
-        row.each do |chunk|
-          text, attrs = chunk.values_at(:text, :attrs)
-          Curses.attron(attrs) if attrs
-          Curses.addstr(text)
-          Curses.attroff(attrs) if attrs
-        end
-      end
-      last_drawn = offset + rows.size
-      (last_drawn...self.rows).each do |line|
-        Curses.setpos(line, 0)
-        Curses.clrtoeol
-      end
-    end
-
     ##
     # @return [Integer]
     def columns