llm.rb 13.1.0 → 15.0.0

data/lib/llm/repl/input.rb

@@ -6,6 +6,10 @@ class LLM::Repl
   # the editable input line shown at the bottom of the REPL.
   # @api private
   class Input
+    require_relative "input/row"
+    require_relative "input/char"
+    require_relative "input/cache"
+
     CTRL = {
       A: Curses::KEY_CTRL_A,
       E: Curses::KEY_CTRL_E,
@@ -25,12 +29,13 @@ class LLM::Repl
     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
+    UP         = Curses::Key::UP
+    DOWN       = Curses::Key::DOWN
+    LEFT       = Curses::Key::LEFT
+    RIGHT      = Curses::Key::RIGHT
+    PGUP       = Curses::KEY_PPAGE
+    PGDOWN     = Curses::KEY_NPAGE
+    KEY_RESIZE = Curses::KEY_RESIZE
 
     TAB       = 9
     ESC       = 27
@@ -44,10 +49,6 @@ class LLM::Repl
     # distinguishes a paste from manual typing.
     PASTE_THRESHOLD = 0.05
 
-    ##
-    # @return [String]
-    attr_reader :buffer
-
     ##
     # @param [Boolean] value
     # @return [void]
@@ -57,11 +58,12 @@ class LLM::Repl
     # @param [LLM::Repl] repl
     # @return [LLM::Repl::Input]
     def initialize(repl, options = {})
+      @repl = repl
       @name = repl.name
       @agent = repl.agent
       @provider = @agent.llm.name
-      @buffer = +""
-      @cursor = 0
+      @rows = [Row.new]
+      @cursor = [0, 0]
       @scroll = 0
       @height = options.fetch(:height, 3)
       @last_char_at = nil
@@ -70,6 +72,13 @@ class LLM::Repl
       @paste = false
     end
 
+    ##
+    # @return [String]
+    #  The input buffer as an ordinary string.
+    def buffer
+      text
+    end
+
     ##
     # @param [LLM::Repl::Window] window
     # @param [Object] char
@@ -91,12 +100,10 @@ class LLM::Repl
       elsif ESC == char
         @agent.cancel!
       elsif CTRL[:P] == char
-        @buffer = @walker.prev.dup
-        @cursor = @buffer.size
+        set(text: @walker.prev.dup)
         :ctrl_p
       elsif CTRL[:N] == char
-        @buffer = @walker.next.dup
-        @cursor = @buffer.size
+        set(text: @walker.next.dup)
         :ctrl_n
       elsif CTRL[:D] == char
         delete
@@ -122,18 +129,21 @@ class LLM::Repl
       elsif char == RIGHT
         move_right
         :right
-      elsif BACKSPACE == char
+      elsif char == BACKSPACE
         backspace
         :backspace
-      elsif ENTER == char
+      elsif char == ENTER
         if @paste = is_paste.()
           insert("\n")
           :char
         else
-          @memory.push(@buffer.dup)
+          @memory.push(text)
           @walker.cursor = @memory.size
           :submit
         end
+      elsif char == KEY_RESIZE
+        window.resize
+        :resize
       elsif char == UP
         window.scroll_up
         :up
@@ -141,7 +151,16 @@ class LLM::Repl
         window.scroll_down
         :down
       elsif String === char
-        insert(char)
+        ##
+        # A paste arrives as a burst of fast characters. Flag it so the
+        # next loop iteration drains the rest through read_paste in a
+        # single shot, instead of inserting one character at a time and
+        # redrawing after each. A string that is already the product of
+        # read_paste (multi-character) is inserted as-is, one char at a
+        # time, so every newline creates a row and every Char stays a
+        # single character.
+        @paste = true if char.length == 1 && is_paste.()
+        char.each_char { |c| insert(c) }
         :char
       else
         nil
@@ -157,13 +176,10 @@ class LLM::Repl
     ##
     # @return [String]
     def to_s
-      "#{prompt}#{@buffer}"
-    end
-
-    ##
-    # @return [Integer]
-    def cursor
-      prompt.size + @cursor
+      @rows
+        .each_with_index
+        .map { |row, i| (i.zero? ? prompt : "") + row.to_s }
+        .join("\n")
     end
 
     ##
@@ -173,14 +189,15 @@ class LLM::Repl
     end
 
     ##
-    # Returns the visible lines of the input buffer,
-    # split by newlines. The viewport follows the cursor
-    # so the cursor line is always visible.
+    # Returns the visible lines of the input buffer. The viewport
+    # follows the cursor so the cursor line is always visible.
     # @return [Array<String>]
     def lines
       scroll!
-      chunks = to_s.split("\n", -1)
-      chunks[@scroll, height] || []
+      visible = @rows[@scroll, height] || []
+      visible.each_with_index.map do |row, i|
+        (i.zero? && @scroll.zero? ? prompt : "") + row.to_s
+      end
     end
 
     ##
@@ -189,93 +206,128 @@ class LLM::Repl
     # @return [Array(Integer, Integer)]
     def cursor_pos
       scroll!
-      before = to_s[0...cursor]
-      line  = before.count("\n")
-      col   = cursor - (before.rindex("\n") || -1) - 1
-      [line - @scroll, col]
+      row, col = @cursor
+      col += prompt.size if row.zero?
+      [row - @scroll, col]
     end
 
     ##
     # @return [void]
     def move_start
-      @cursor = 0
+      @cursor = [0, 0]
     end
 
     ##
     # @return [void]
     def move_end
-      @cursor = [0, @buffer.size].max
+      @cursor = [@rows.size - 1, @rows.last.chars.size]
     end
 
     ##
     # @return [void]
     def move_left
-      @cursor = [@cursor - 1, 0].max
+      row, col = @cursor
+      @cursor =
+        if col > 0 then [row, col - 1]
+        elsif row > 0 then [row - 1, @rows[row - 1].chars.size]
+        else [0, 0]
+        end
     end
 
     ##
     # @return [void]
     def move_right
-      @cursor = [@cursor + 1, @buffer.size].min
+      row, col = @cursor
+      @cursor =
+        if col < @rows[row].chars.size then [row, col + 1]
+        elsif row < @rows.size - 1 then [row + 1, 0]
+        else [row, col]
+        end
     end
 
     ##
     # @return [void]
     def move_forward
-      @cursor = [0, @cursor + 1].max
+      move_right
     end
 
     ##
     # @return [void]
     def autocomplete
-      return unless @buffer[0] == "/"
+      return unless text[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]
+      # There are two kinds of an autocomplete
+      # that can take place. The first kind
+      # autocompletes command names, and the
+      # second kind autocompletes command
+      # arguments.
+      #
+      # Command arguments are given to the
+      # `Command#complete(...)` method and
+      # returns an array of potential candidates.
+      if text.include?(" ")
+        complete(:argument)
       else
-        candidate = candidates[0]
+        complete(:command)
       end
-      @buffer = "/#{candidate}"
-      @cursor = @buffer.size
     end
 
     ##
     # @return [void]
     def kill
-      @copy = @buffer.slice(@cursor, @buffer.size)
-      @buffer[@cursor, @buffer.size] = ""
-      @cursor = @buffer.size
+      row, col = @cursor
+      tail = @rows[row].chars[col..].map(&:to_s).join
+      tail += @rows[(row + 1)..].map(&:to_s).join("\n")
+      @copy = tail
+      @rows[row].chars.slice!(col..)
+      @rows = @rows[0..row]
+      @cursor = [row, col]
     end
 
     ##
+    # Deletes the character at the cursor, or consumes
+    # the break and pulls up the next row at the end of
+    # a row.
     # @return [void]
     def delete
-      @buffer[@cursor] = ""
-      @cursor = [0, @cursor].max
+      row, col = @cursor
+      if col < @rows[row].chars.size
+        @rows[row].chars.delete_at(col)
+      elsif row < @rows.size - 1
+        nxt = @rows[row + 1]
+        ##
+        # A wrapped row was split at a space; restore it so
+        # the merged words don't run together.
+        @rows[row].chars << Char.new(" ") if nxt.break_type == :space
+        @rows[row].chars.concat(nxt.chars)
+        @rows.delete_at(row + 1)
+      end
     end
 
     ##
     # @return [void]
     def restore
       return unless @copy
-      @buffer.insert(@cursor, @copy)
-      @cursor += @copy.size
+      row, col = @cursor
+      @copy.each_char do |char|
+        if char == "\n"
+          @rows.insert(row + 1, Row.new(:newline))
+          row += 1
+          col = 0
+        else
+          @rows[row].chars.insert(col, Char.new(char))
+          col += 1
+        end
+      end
+      @cursor = [row, col]
     end
 
     ##
     # @return [String]
     def take
-      @buffer.dup.tap do
-        @buffer.clear
-        @cursor = 0
+      text.tap do
+        @rows = [Row.new]
+        @cursor = [0, 0]
         @scroll = 0
       end
     end
@@ -288,16 +340,74 @@ class LLM::Repl
 
     private
 
+    ##
+    # Autocompletes command names and their arguments.
+    # @param [Symbol] kind
+    #  The kind of completion
+    # @return [void]
+    def complete(kind)
+      case kind
+      when :command
+        fragment = text[1..]
+        candidates =
+          if @cache&.include?(fragment)
+            @cache.candidates
+          else
+            LLM::Command.complete(text)
+          end
+        candidate = cycle(candidates, fragment)
+        set(text: "/#{candidate}")
+      when :argument
+        name, *args = text.split(" ", -1)
+        command = LLM::Command.find_by(name: name[1..])
+        return unless command
+        fragment, index = args.last, args.size - 1
+        param = command.parameters.values.find { _1.index == index }
+        return unless param
+        cmd = command.new(@repl)
+        candidates =
+          if @cache&.include?(fragment)
+            @cache.candidates
+          else
+            list = cmd.method(:complete).call(param.name => fragment)
+            return if list.empty?
+            list
+          end
+        candidate = cycle(candidates, fragment)
+        set(text: "#{name} #{args[0..-2].compact.join(" ")} #{candidate}".squeeze(" "))
+      end
+    end
+
+    ##
+    # Returns the next candidate, cycling through the list
+    # when the current value is already one of the candidates.
+    # @param [Array<String>] candidates
+    # @param [String] current
+    # @return [String]
+    def cycle(candidates, current)
+      return "" if candidates.empty?
+      index =
+        if @cache and @cache.candidates == candidates
+          @cache.next_index
+        elsif (i = candidates.index(current))
+          (i + 1) % candidates.size
+        else
+          0
+        end
+      @cache = Cache.new(candidates, index)
+      @cache.value
+    end
+
     ##
     # Adjusts @scroll so the cursor line is visible within
     # the viewport.
     def scroll!(total_lines = nil)
-      total_lines ||= to_s.split("\n", -1).size
-      cursor_line = to_s[0...cursor].count("\n")
-      if cursor_line < @scroll
-        @scroll = cursor_line
-      elsif cursor_line >= (@scroll + height)
-        @scroll = (cursor_line - height) + 1
+      total_lines ||= @rows.size
+      cursor_row = @cursor[0]
+      if cursor_row < @scroll
+        @scroll = cursor_row
+      elsif cursor_row >= (@scroll + height)
+        @scroll = (cursor_row - height) + 1
       end
       @scroll = [[@scroll, (total_lines - height)].min, 0].max
     end
@@ -306,20 +416,158 @@ class LLM::Repl
       "#{@provider}(#{@name})> "
     end
 
+    ##
+    # Returns the line the cursor is on, including the prompt.
+    # @return [String]
+    def current_line
+      row = @cursor[0]
+      (row.zero? ? prompt : "") + @rows[row].to_s
+    end
+
+    ##
+    # Inserts a character at the cursor, wrapping the current row at
+    # the terminal width by starting a new row. A word that would be
+    # cut in half is moved whole onto the new row.
+    # @param [String] char
+    # @return [void]
     def insert(char)
-      if lines[-1].size >= Curses.cols
-        @buffer.insert(@cursor, "\n")
-        @cursor += 1
+      row, col = @cursor
+      if char == "\n"
+        @rows.insert(row + 1, Row.new(:newline))
+        @cursor = [row + 1, 0]
+      elsif current_line.size >= Curses.cols
+        if char == " "
+          @rows.insert(row + 1, Row.new(:space))
+          @cursor = [row + 1, 0]
+        elsif (index = current_line.rindex(" "))
+          offset = row.zero? ? prompt.size : 0
+          split = index - offset
+          tail = @rows[row].chars.slice!((split + 1)..) || []
+          @rows[row].chars.delete_at(split)
+          @rows.insert(row + 1, Row.new(:space))
+          @rows[row + 1].chars.concat(tail)
+          @rows[row + 1].chars << Char.new(char)
+          @cursor = [row + 1, @rows[row + 1].chars.size]
+        else
+          @rows.insert(row + 1, Row.new(:space))
+          @rows[row + 1].chars << Char.new(char)
+          @cursor = [row + 1, 1]
+        end
+      else
+        @rows[row].chars.insert(col, Char.new(char))
+        @cursor = [row, col + char.length]
       end
-      @buffer.insert(@cursor, char)
-      @cursor += char.length
       scroll!
     end
 
+    ##
+    # @return [void]
     def backspace
-      return if @cursor <= 0
-      @buffer.slice!(@cursor - 1)
-      @cursor -= 1
+      row, col = @cursor
+      if col > 0
+        @rows[row].chars.delete_at(col - 1)
+        @cursor = [row, col - 1]
+      elsif row > 0
+        prev = @rows[row - 1]
+        prev.chars.concat(@rows[row].chars)
+        @rows.delete_at(row)
+        @cursor = [row - 1, prev.chars.size]
+      end
+    end
+
+    ##
+    # Flattens the rows into a single string. Each row joins the one
+    # before it using its own `break_type`: a row started by an
+    # auto-wrap joins with a space, a row started by a real newline
+    # joins with a newline.
+    # @return [String]
+    def text
+      out = +""
+      @rows.each_with_index do |row, i|
+        out << row.to_s
+        nxt = @rows[i + 1]
+        if nxt
+          out << (nxt.break_type == :newline ? "\n" : " ")
+        end
+      end
+      out
+    end
+
+    ##
+    # Feeds one character into the row model: newlines
+    # start a row, overflowing rows wrap at a word.
+    # @param [String] char
+    # @return [void]
+    def feed(char)
+      if char == "\n"
+        ##
+        # A real newline is a row boundary in the model,
+        # not a character, so it becomes a new row.
+        @rows << Row.new(:newline)
+        return
+      end
+      row = @rows.last
+      ##
+      # Only the first row shares its columns with the prompt,
+      # so it has fewer columns left for text.
+      width = Curses.cols - (row.equal?(@rows.first) ? prompt.size : 0)
+      if row.chars.any? and row.to_s.length + 1 > width
+        wrap(row)
+      end
+      @rows.last.chars << Char.new(char)
+    end
+
+    ##
+    # Moves the word tail of a full row onto a new
+    # continuation row, keeping the overflow word whole.
+    # @param [LLM::Repl::Input::Row] row
+    # @return [void]
+    def wrap(row)
+      index = row.to_s.rindex(" ")
+      if index
+        ##
+        # Move everything after the last space down and
+        # drop the space; break_type restores it on flatten.
+        tail = row.chars.slice!((index + 1)..) || []
+        row.chars.pop
+        @rows << Row.new(:space).tap { |r| r.chars.concat(tail) }
+      else
+        ##
+        # A single unbroken word longer than the width hard-breaks.
+        @rows << Row.new(:space)
+      end
+    end
+
+    ##
+    # Replaces the input with the given text, reflowing it into rows
+    # at the terminal width. The cursor ends at the last row.
+    # @param [String] text
+    # @return [void]
+    def set(text:)
+      return if noop_set?(text)
+      @rows = [Row.new]
+      text.each_char { |char| feed(char) }
+      ##
+      # A trailing newline leaves an empty last row; drop it
+      # so the cursor rests at the end of the content row.
+      @rows.pop while @rows.size > 1 and @rows.last.empty?
+      @cursor = [@rows.size - 1, @rows.last.chars.size]
+    end
+
+    ##
+    # Returns true when the {#set} method should return early.
+    # @param [String, nil] str
+    #  The new string to set.
+    # @return [Boolean]
+    def noop_set?(str)
+      if str.nil?
+        true
+      elsif @rows.size == 1
+        chars = @rows[0].to_s
+        str.empty? and chars.empty?
+      else
+        false
+      end
     end
   end
 end

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

@@ -6,8 +6,10 @@ class LLM::Repl::Markdown
   module Table
     ##
     # @api private
-    Node = LLM::Repl::Node
+    Node  = LLM::Repl::Node
+    Color = LLM::Repl::Color
     private_constant :Node
+    private_constant :Color
 
     ##
     # Renders a table node by collecting all cells first to
@@ -61,9 +63,11 @@ class LLM::Repl::Markdown
       when :em
         node.children.each { walk_collect(_1, Curses::A_UNDERLINE, chunks) }
       when :codespan
-        chunks << Node.new(node.value, Curses::A_REVERSE)
+        chunks << Node.new(node.value, Color.green)
       when :a
         node.children.each { walk_collect(_1, Curses::A_UNDERLINE, chunks) }
+      when :typographic_sym, :smart_quote
+        chunks << Node.new(symbol(node), attrs)
       else
         node.children.each { walk_collect(_1, attrs, chunks) }
       end

data/lib/llm/repl/markdown.rb

@@ -11,12 +11,32 @@ class LLM::Repl
     require_relative "markdown/table"
     include Table
 
+    ##
+    # Kramdown goes a bit beyond a standard markdown
+    # parser by representing certain characters or
+    # character sequences as distinct node types that are
+    # represented by `:typographic_sym`, and `:smart_quote`.
+    #
+    # The node's value maps back to one of the keys in
+    # this Hash, and the values are unicode characters
+    # that provide a visual representation of the node.
+    #
+    # @api private
+    SYMBOLS = {
+      hellip: "…",
+      ndash:  "–", mdash:  "—",
+      laquo:  "«", raquo:  "»",
+      laquo_space: "« ", raquo_space: "» ",
+      lsquo:  "‘", rsquo:  "’",
+      ldquo:  "“", rdquo:  "”"
+    }
+
     ##
     # @param [String] text
     # @param [Integer] width
     # @return [LLM::Repl::Markdown]
     def initialize(text, width)
-      @doc = Kramdown::Document.new(text)
+      @doc = Kramdown::Document.new(fenced_code_blocks(text))
       @width = width
       @ast = []
     end
@@ -65,17 +85,20 @@ class LLM::Repl
         emit("\n\n", attrs)
       when :header
         emit("\n", attrs)
-        node.children.each { walk(_1, Curses::A_BOLD) }
+        node.children.each { walk(_1, Curses::A_BOLD | Color.white) }
         emit("\n", attrs)
       when :strong
-        node.children.each { walk(_1, Curses::A_BOLD) }
+        node.children.each { walk(_1, Curses::A_BOLD | Color.white) }
       when :em
         node.children.each { walk(_1, Curses::A_UNDERLINE) }
       when :codespan
-        emit(node.value, Curses::A_REVERSE)
+        emit(node.value, Color.green)
       when :codeblock
-        emit(node.value, Curses::A_REVERSE)
+        emit("#{lang(node)}\n", Curses::A_BOLD | Color.white) unless lang(node).empty?
+        emit(node.value, Color.green)
         emit("\n\n", attrs)
+      when :typographic_sym, :smart_quote
+        emit(symbol(node), attrs)
       when :br
         emit("\n", attrs)
       when :ul, :ol
@@ -100,7 +123,7 @@ class LLM::Repl
         emit("─" * @width, attrs)
         emit("\n\n", attrs)
       when :a
-        node.children.each { walk(_1, Curses::A_UNDERLINE) }
+        node.children.each { walk(_1, Curses::A_UNDERLINE | Color.green) }
       when :img
         emit("[image: #{node.attr["alt"]}]", attrs)
       else
@@ -111,5 +134,32 @@ class LLM::Repl
     def emit(text, attrs)
       @ast.push(Node.new(text.to_s, attrs))
     end
+
+    def symbol(node)
+      SYMBOLS[node.value]
+    end
+
+    ##
+    # Kramdown's native fenced-code syntax uses
+    # `~~~`, not the GitHub-style ``` fences that
+    # models commonly emit. Rewrite ```lang blocks
+    # so they are parsed as real code blocks instead
+    # of inline code spans. The language is preserved
+    # so Kramdown tags the block with a `language-*`
+    # class.
+    # @param [String] text
+    # @return [String]
+    def fenced_code_blocks(text)
+      text.gsub(/^```(\S*)\s*$/) { "~~~#{$1}" }
+    end
+
+    ##
+    # Extracts the language from a code block's
+    # `language-*` class.
+    # @param [Kramdown::Element] node
+    # @return [String]
+    def lang(node)
+      node.attr["class"].to_s.sub(/\Alanguage-/, "")
+    end
   end
 end